tequilaOS/platform_build_soong
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Support building for Fuchsia. am: c32c6b0d79 am: ac2925f410

Browse source 
am: b85599e803

Change-Id: I6ef28e11e3fbe3dc3217ae7b1c05f39ada1ebbd3
This commit is contained in:
Doug Horn 2019-01-24 16:14:20 -08:00 committed by android-build-merger
commit 4faa6d2488
11 changed files with 393 additions and 33 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Android.bp
View file

@ -97,10 +97,12 @@ bootstrap_go_package {
"cc/config/arm_device.go",
"cc/config/arm64_device.go",
"cc/config/arm64_fuchsia_device.go",
"cc/config/mips_device.go",
"cc/config/mips64_device.go",
"cc/config/x86_device.go",
"cc/config/x86_64_device.go",
"cc/config/x86_64_fuchsia_device.go",
"cc/config/x86_darwin_host.go",
"cc/config/x86_linux_host.go",

16
android/config.go
View file

@ -224,6 +224,22 @@ func TestConfig(buildDir string, env map[string]string) Config {
return Config{config}
}
func TestArchConfigFuchsia(buildDir string, env map[string]string) Config {
testConfig := TestConfig(buildDir, env)
config := testConfig.config
config.Targets = map[OsType][]Target{
Fuchsia: []Target{
{Fuchsia, Arch{ArchType: Arm64, ArchVariant: "", Native: true}},
},
BuildOs: []Target{
{BuildOs, Arch{ArchType: X86_64}},
},
}
return testConfig
}
// TestConfig returns a Config object suitable for using for tests that need to run the arch mutator
func TestArchConfig(buildDir string, env map[string]string) Config {
testConfig := TestConfig(buildDir, env)

2
cc/binary.go
View file

@ -196,7 +196,7 @@ func (binary *binaryDecorator) linkerInit(ctx BaseModuleContext) {
if binary.Properties.Static_executable == nil && ctx.Config().HostStaticBinaries() {
binary.Properties.Static_executable = BoolPtr(true)
}
} else {
} else if !ctx.Fuchsia() {
// Static executables are not supported on Darwin or Windows
binary.Properties.Static_executable = nil
}

7
cc/cc.go
View file

@ -599,7 +599,7 @@ func (ctx *moduleContextImpl) staticBinary() bool {
}
func (ctx *moduleContextImpl) useSdk() bool {
if ctx.ctx.Device() && !ctx.useVndk() && !ctx.inRecovery() {
if ctx.ctx.Device() && !ctx.useVndk() && !ctx.inRecovery() && !ctx.ctx.Fuchsia() {
return String(ctx.mod.Properties.Sdk_version) != ""
}
return false
@ -668,6 +668,11 @@ func (ctx *moduleContextImpl) shouldCreateVndkSourceAbiDump() bool {
if ctx.ctx.Config().IsEnvTrue("SKIP_ABI_CHECKS") {
return false
}
if ctx.ctx.Fuchsia() {
return false
}
if sanitize := ctx.mod.sanitize; sanitize != nil {
if !sanitize.isVariantOnProductionDevice() {
return false

135
cc/cc_test.go
View file

@ -51,29 +51,8 @@ func TestMain(m *testing.M) {
os.Exit(run())
}
func createTestContext(t *testing.T, config android.Config, bp string) *android.TestContext {
ctx := android.NewTestArchContext()
ctx.RegisterModuleType("cc_binary", android.ModuleFactoryAdaptor(BinaryFactory))
ctx.RegisterModuleType("cc_library", android.ModuleFactoryAdaptor(LibraryFactory))
ctx.RegisterModuleType("cc_library_shared", android.ModuleFactoryAdaptor(LibrarySharedFactory))
ctx.RegisterModuleType("cc_library_headers", android.ModuleFactoryAdaptor(LibraryHeaderFactory))
ctx.RegisterModuleType("toolchain_library", android.ModuleFactoryAdaptor(ToolchainLibraryFactory))
ctx.RegisterModuleType("llndk_library", android.ModuleFactoryAdaptor(LlndkLibraryFactory))
ctx.RegisterModuleType("llndk_headers", android.ModuleFactoryAdaptor(llndkHeadersFactory))
ctx.RegisterModuleType("vendor_public_library", android.ModuleFactoryAdaptor(vendorPublicLibraryFactory))
ctx.RegisterModuleType("cc_object", android.ModuleFactoryAdaptor(ObjectFactory))
ctx.RegisterModuleType("filegroup", android.ModuleFactoryAdaptor(android.FileGroupFactory))
ctx.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
ctx.BottomUp("image", ImageMutator).Parallel()
ctx.BottomUp("link", LinkageMutator).Parallel()
ctx.BottomUp("vndk", VndkMutator).Parallel()
ctx.BottomUp("version", VersionMutator).Parallel()
ctx.BottomUp("begin", BeginMutator).Parallel()
})
ctx.Register()
// add some modules that are required by the compiler and/or linker
bp = bp + `
func gatherRequiredDeps(os android.OsType) string {
ret := `
toolchain_library {
name: "libatomic",
vendor_available: true,
@ -215,8 +194,45 @@ func createTestContext(t *testing.T, config android.Config, bp string) *android.
cc_library {
name: "libprotobuf-cpp-lite",
}
`
if os == android.Fuchsia {
ret += `
cc_library {
name: "libbioniccompat",
stl: "none",
}
cc_library {
name: "libcompiler_rt",
stl: "none",
}
`
}
return ret
}
`
func createTestContext(t *testing.T, config android.Config, bp string, os android.OsType) *android.TestContext {
ctx := android.NewTestArchContext()
ctx.RegisterModuleType("cc_binary", android.ModuleFactoryAdaptor(BinaryFactory))
ctx.RegisterModuleType("cc_library", android.ModuleFactoryAdaptor(LibraryFactory))
ctx.RegisterModuleType("cc_library_shared", android.ModuleFactoryAdaptor(LibrarySharedFactory))
ctx.RegisterModuleType("cc_library_headers", android.ModuleFactoryAdaptor(LibraryHeaderFactory))
ctx.RegisterModuleType("toolchain_library", android.ModuleFactoryAdaptor(ToolchainLibraryFactory))
ctx.RegisterModuleType("llndk_library", android.ModuleFactoryAdaptor(LlndkLibraryFactory))
ctx.RegisterModuleType("llndk_headers", android.ModuleFactoryAdaptor(llndkHeadersFactory))
ctx.RegisterModuleType("vendor_public_library", android.ModuleFactoryAdaptor(vendorPublicLibraryFactory))
ctx.RegisterModuleType("cc_object", android.ModuleFactoryAdaptor(ObjectFactory))
ctx.RegisterModuleType("filegroup", android.ModuleFactoryAdaptor(android.FileGroupFactory))
ctx.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
ctx.BottomUp("image", ImageMutator).Parallel()
ctx.BottomUp("link", LinkageMutator).Parallel()
ctx.BottomUp("vndk", VndkMutator).Parallel()
ctx.BottomUp("version", VersionMutator).Parallel()
ctx.BottomUp("begin", BeginMutator).Parallel()
})
ctx.Register()
// add some modules that are required by the compiler and/or linker
bp = bp + gatherRequiredDeps(os)
ctx.MockFileSystem(map[string][]byte{
"Android.bp": []byte(bp),
@ -232,8 +248,12 @@ func createTestContext(t *testing.T, config android.Config, bp string) *android.
}
func testCcWithConfig(t *testing.T, bp string, config android.Config) *android.TestContext {
return testCcWithConfigForOs(t, bp, config, android.Android)
}
func testCcWithConfigForOs(t *testing.T, bp string, config android.Config, os android.OsType) *android.TestContext {
t.Helper()
ctx := createTestContext(t, config, bp)
ctx := createTestContext(t, config, bp, os)
_, errs := ctx.ParseFileList(".", []string{"Android.bp"})
android.FailIfErrored(t, errs)
@ -266,7 +286,7 @@ func testCcError(t *testing.T, pattern string, bp string) {
config.TestProductVariables.DeviceVndkVersion = StringPtr("current")
config.TestProductVariables.Platform_vndk_version = StringPtr("VER")
ctx := createTestContext(t, config, bp)
ctx := createTestContext(t, config, bp, android.Android)
_, errs := ctx.ParseFileList(".", []string{"Android.bp"})
if len(errs) > 0 {
@ -289,6 +309,69 @@ const (
recoveryVariant = "android_arm64_armv8-a_recovery_shared"
)
func TestFuchsiaDeps(t *testing.T) {
t.Helper()
bp := `
cc_library {
name: "libTest",
srcs: ["foo.c"],
target: {
fuchsia: {
srcs: ["bar.c"],
},
},
}`
config := android.TestArchConfigFuchsia(buildDir, nil)
ctx := testCcWithConfigForOs(t, bp, config, android.Fuchsia)
rt := false
fb := false
ld := ctx.ModuleForTests("libTest", "fuchsia_arm64_shared").Rule("ld")
implicits := ld.Implicits
for _, lib := range implicits {
if strings.Contains(lib.Rel(), "libcompiler_rt") {
rt = true
}
if strings.Contains(lib.Rel(), "libbioniccompat") {
fb = true
}
}
if !rt || !fb {
t.Errorf("fuchsia libs must link libcompiler_rt and libbioniccompat")
}
}
func TestFuchsiaTargetDecl(t *testing.T) {
t.Helper()
bp := `
cc_library {
name: "libTest",
srcs: ["foo.c"],
target: {
fuchsia: {
srcs: ["bar.c"],
},
},
}`
config := android.TestArchConfigFuchsia(buildDir, nil)
ctx := testCcWithConfigForOs(t, bp, config, android.Fuchsia)
ld := ctx.ModuleForTests("libTest", "fuchsia_arm64_shared").Rule("ld")
var objs []string
for _, o := range ld.Inputs {
objs = append(objs, o.Base())
}
if len(objs) != 2 || objs[0] != "foo.o" || objs[1] != "bar.o" {
t.Errorf("inputs of libTest must be []string{\"foo.o\", \"bar.o\"}, but was %#v.", objs)
}
}
func TestVendorSrc(t *testing.T) {
ctx := testCc(t, `
cc_library {

101
cc/config/arm64_fuchsia_device.go Normal file
View file

@ -0,0 +1,101 @@
// Copyright 2018 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 config
import (
"android/soong/android"
)
var fuchsiaArm64SysRoot string = "prebuilts/fuchsia_sdk/arch/arm64/sysroot"
var fuchsiaArm64PrebuiltLibsRoot string = "fuchsia/prebuilt_libs/"
type toolchainFuchsiaArm64 struct {
toolchain64Bit
toolchainFuchsia
}
func (t *toolchainFuchsiaArm64) Name() string {
return "arm64"
}
func (t *toolchainFuchsiaArm64) GccRoot() string {
return "${config.Arm64GccRoot}"
}
func (t *toolchainFuchsiaArm64) GccTriple() string {
return "aarch64-linux-android"
}
func (t *toolchainFuchsiaArm64) GccVersion() string {
return arm64GccVersion
}
func (t *toolchainFuchsiaArm64) Cflags() string {
return ""
}
func (t *toolchainFuchsiaArm64) Cppflags() string {
return ""
}
func (t *toolchainFuchsiaArm64) Ldflags() string {
return "-Wl,--fix-cortex-a53-843419"
}
func (t *toolchainFuchsiaArm64) IncludeFlags() string {
return ""
}
func (t *toolchainFuchsiaArm64) ToolchainCflags() string {
return "-mcpu=cortex-a53"
}
func (t *toolchainFuchsiaArm64) ClangTriple() string {
return "arm64-fuchsia-android"
}
func (t *toolchainFuchsiaArm64) ClangCppflags() string {
return "-Wno-error=deprecated-declarations"
}
func (t *toolchainFuchsiaArm64) ClangLdflags() string {
return "--target=arm64-fuchsia --sysroot=" + fuchsiaArm64SysRoot + " -L" + fuchsiaArm64PrebuiltLibsRoot + "/aarch64-fuchsia/lib " + "-Lprebuilts/fuchsia_sdk/arch/arm64/dist/"
}
func (t *toolchainFuchsiaArm64) ClangLldflags() string {
return "--target=arm64-fuchsia --sysroot=" + fuchsiaArm64SysRoot + " -L" + fuchsiaArm64PrebuiltLibsRoot + "/aarch64-fuchsia/lib " + "-Lprebuilts/fuchsia_sdk/arch/arm64/dist/"
}
func (t *toolchainFuchsiaArm64) ClangCflags() string {
return "--target=arm64-fuchsia --sysroot=" + fuchsiaArm64SysRoot + " -I" + fuchsiaArm64SysRoot + "/include"
}
func (t *toolchainFuchsiaArm64) Bionic() bool {
return false
}
func (t *toolchainFuchsiaArm64) ToolchainClangCflags() string {
return "-march=armv8-a"
}
var toolchainArm64FuchsiaSingleton Toolchain = &toolchainFuchsiaArm64{}
func arm64FuchsiaToolchainFactory(arch android.Arch) Toolchain {
return toolchainArm64FuchsiaSingleton
}
func init() {
registerToolchainFactory(android.Fuchsia, android.Arm64, arm64FuchsiaToolchainFactory)
}

9
cc/config/global.go
View file

@ -150,8 +150,13 @@ func init() {
pctx.StaticVariable("CommonClangGlobalCflags",
strings.Join(append(ClangFilterUnknownCflags(commonGlobalCflags), "${ClangExtraCflags}"), " "))
pctx.StaticVariable("DeviceClangGlobalCflags",
strings.Join(append(ClangFilterUnknownCflags(deviceGlobalCflags), "${ClangExtraTargetCflags}"), " "))
pctx.VariableFunc("DeviceClangGlobalCflags", func(ctx android.PackageVarContext) string {
if ctx.Config().Fuchsia() {
return strings.Join(ClangFilterUnknownCflags(deviceGlobalCflags), " ")
} else {
return strings.Join(append(ClangFilterUnknownCflags(deviceGlobalCflags), "${ClangExtraTargetCflags}"), " ")
}
})
pctx.StaticVariable("HostClangGlobalCflags",
strings.Join(ClangFilterUnknownCflags(hostGlobalCflags), " "))
pctx.StaticVariable("NoOverrideClangGlobalCflags",

106
cc/config/x86_64_fuchsia_device.go Normal file
View file

@ -0,0 +1,106 @@
// Copyright 2018 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 config
import (
"android/soong/android"
)
var fuchsiaSysRoot string = "prebuilts/fuchsia_sdk/arch/x64/sysroot"
var fuchsiaPrebuiltLibsRoot string = "fuchsia/prebuilt_libs"
type toolchainFuchsia struct {
cFlags, ldFlags string
}
type toolchainFuchsiaX8664 struct {
toolchain64Bit
toolchainFuchsia
}
func (t *toolchainFuchsiaX8664) Name() string {
return "x86_64"
}
func (t *toolchainFuchsiaX8664) GccRoot() string {
return "${config.X86_64GccRoot}"
}
func (t *toolchainFuchsiaX8664) GccTriple() string {
return "x86_64-linux-android"
}
func (t *toolchainFuchsiaX8664) GccVersion() string {
return x86_64GccVersion
}
func (t *toolchainFuchsiaX8664) Cflags() string {
return ""
}
func (t *toolchainFuchsiaX8664) Cppflags() string {
return ""
}
func (t *toolchainFuchsiaX8664) Ldflags() string {
return ""
}
func (t *toolchainFuchsiaX8664) IncludeFlags() string {
return ""
}
func (t *toolchainFuchsiaX8664) ClangTriple() string {
return "x86_64-fuchsia-android"
}
func (t *toolchainFuchsiaX8664) ClangCppflags() string {
return "-Wno-error=deprecated-declarations"
}
func (t *toolchainFuchsiaX8664) ClangLdflags() string {
return "--target=x86_64-fuchsia --sysroot=" + fuchsiaSysRoot + " -L" + fuchsiaPrebuiltLibsRoot + "/x86_64-fuchsia/lib " + "-Lprebuilts/fuchsia_sdk/arch/x64/dist/"
}
func (t *toolchainFuchsiaX8664) ClangLldflags() string {
return "--target=x86_64-fuchsia --sysroot=" + fuchsiaSysRoot + " -L" + fuchsiaPrebuiltLibsRoot + "/x86_64-fuchsia/lib " + "-Lprebuilts/fuchsia_sdk/arch/x64/dist/"
}
func (t *toolchainFuchsiaX8664) ClangCflags() string {
return "--target=x86_64-fuchsia --sysroot=" + fuchsiaSysRoot + " -I" + fuchsiaSysRoot + "/include"
}
func (t *toolchainFuchsiaX8664) Bionic() bool {
return false
}
func (t *toolchainFuchsiaX8664) YasmFlags() string {
return "-f elf64 -m amd64"
}
func (t *toolchainFuchsiaX8664) ToolchainClangCflags() string {
return "-DUSE_SSSE3 -mssse3"
}
var toolchainFuchsiaSingleton Toolchain = &toolchainFuchsiaX8664{}
func fuchsiaToolchainFactory(arch android.Arch) Toolchain {
return toolchainFuchsiaSingleton
}
func init() {
registerToolchainFactory(android.Fuchsia, android.X86_64, fuchsiaToolchainFactory)
}

18
cc/linker.go
View file

@ -270,6 +270,18 @@ func (linker *baseLinker) linkerDeps(ctx DepsContext, deps Deps) Deps {
deps.LateSharedLibs = append(deps.LateSharedLibs, systemSharedLibs...)
}
if ctx.Fuchsia() {
if ctx.ModuleName() != "libbioniccompat" &&
ctx.ModuleName() != "libcompiler_rt-extras" &&
ctx.ModuleName() != "libcompiler_rt" {
deps.StaticLibs = append(deps.StaticLibs, "libbioniccompat")
}
if ctx.ModuleName() != "libcompiler_rt" && ctx.ModuleName() != "libcompiler_rt-extras" {
deps.LateStaticLibs = append(deps.LateStaticLibs, "libcompiler_rt")
}
}
if ctx.Windows() {
deps.LateStaticLibs = append(deps.LateStaticLibs, "libwinpthread")
}
@ -360,7 +372,7 @@ func (linker *baseLinker) linkerFlags(ctx ModuleContext, flags Flags) Flags {
flags.LdFlags = append(flags.LdFlags, toolchain.ClangLdflags())
}
if !ctx.toolchain().Bionic() {
if !ctx.toolchain().Bionic() && !ctx.Fuchsia() {
CheckBadHostLdlibs(ctx, "host_ldlibs", linker.Properties.Host_ldlibs)
flags.LdFlags = append(flags.LdFlags, linker.Properties.Host_ldlibs...)
@ -379,6 +391,10 @@ func (linker *baseLinker) linkerFlags(ctx ModuleContext, flags Flags) Flags {
}
}
if ctx.Fuchsia() {
flags.LdFlags = append(flags.LdFlags, "-lfdio", "-lzircon")
}
CheckBadLinkerFlags(ctx, "ldflags", linker.Properties.Ldflags)
flags.LdFlags = append(flags.LdFlags, proptools.NinjaAndShellEscape(linker.Properties.Ldflags)...)

5
cc/sanitize.go
View file

@ -167,6 +167,11 @@ func (sanitize *sanitize) begin(ctx BaseModuleContext) {
s.Never = BoolPtr(true)
}
// Sanitizers do not work on Fuchsia yet.
if ctx.Fuchsia() {
s.Never = BoolPtr(true)
}
// Never always wins.
if Bool(s.Never) {
return

25
cc/stl.go
View file

@ -91,6 +91,26 @@ func (stl *stl) begin(ctx BaseModuleContext) {
ctx.ModuleErrorf("stl: %q is not a supported STL for windows", s)
return ""
}
} else if ctx.Fuchsia() {
switch s {
case "c++_static":
return "libc++_static"
case "c++_shared":
return "libc++"
case "libc++", "libc++_static":
return s
case "none":
return ""
case "":
if ctx.static() {
return "libc++_static"
} else {
return "libc++"
}
default:
ctx.ModuleErrorf("stl: %q is not a supported STL on Fuchsia", s)
return ""
}
} else {
switch s {
case "libc++", "libc++_static":
@ -248,8 +268,9 @@ var hostDynamicGccLibs, hostStaticGccLibs map[android.OsType][]string
func init() {
hostDynamicGccLibs = map[android.OsType][]string{
android.Linux: []string{"-lgcc_s", "-lgcc", "-lc", "-lgcc_s", "-lgcc"},
android.Darwin: []string{"-lc", "-lSystem"},
android.Fuchsia: []string{"-lc", "-lunwind"},
android.Linux: []string{"-lgcc_s", "-lgcc", "-lc", "-lgcc_s", "-lgcc"},
android.Darwin: []string{"-lc", "-lSystem"},
android.Windows: []string{"-Wl,--start-group", "-lmingw32", "-lgcc", "-lgcc_eh",
"-lmoldname", "-lmingwex", "-lmsvcrt", "-lucrt", "-lpthread",
"-ladvapi32", "-lshell32", "-luser32", "-lkernel32", "-lpsapi",