Merge "Publish Soong configuration to Make variables"

3 files changed, 355 insertions, 0 deletions

diff --git a/Android.bp b/Android.bp
index 831b703f..c1d664f4 100644
--- a/Android.bp
+++ b/Android.bp
@@ -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)
+}