Add soong_build primary builder
Initial build logic for building android with soong. It can build
a variety of C and C++ files for arm/arm64 and host.
Change-Id: I10eb37c2c2a50be6af1bb5fd568c0962b9476bf0
diff --git a/cc/arm_device.go b/cc/arm_device.go
new file mode 100644
index 0000000..d070935
--- /dev/null
+++ b/cc/arm_device.go
@@ -0,0 +1,301 @@
+package cc
+
+import (
+ "fmt"
+ "strings"
+
+ "android/soong/common"
+)
+
+var (
+ armCflags = []string{
+ "-fno-exceptions", // from build/core/combo/select.mk
+ "-Wno-multichar", // from build/core/combo/select.mk
+ "-fno-strict-aliasing",
+ "-fstack-protector",
+ "-ffunction-sections",
+ "-fdata-sections",
+ "-funwind-tables",
+ "-fstack-protector",
+ "-Wa,--noexecstack",
+ "-Werror=format-security",
+ "-D_FORTIFY_SOURCE=2",
+ "-fno-short-enums",
+ "-no-canonical-prefixes",
+ "-fno-canonical-system-headers",
+ "-include ${SrcDir}/build/core/combo/include/arch/linux-arm/AndroidConfig.h",
+
+ "-fno-builtin-sin",
+ "-fno-strict-volatile-bitfields",
+
+ // TARGET_RELEASE_CFLAGS
+ "-DNDEBUG",
+ "-g",
+ "-Wstrict-aliasing=2",
+ "-fgcse-after-reload",
+ "-frerun-cse-after-loop",
+ "-frename-registers",
+ }
+
+ armCppflags = []string{
+ "-fvisibility-inlines-hidden",
+ }
+
+ armLdflags = []string{
+ "-Wl,-z,noexecstack",
+ "-Wl,-z,relro",
+ "-Wl,-z,now",
+ "-Wl,--build-id=md5",
+ "-Wl,--warn-shared-textrel",
+ "-Wl,--fatal-warnings",
+ "-Wl,-icf=safe",
+ "-Wl,--hash-style=gnu",
+
+ // Disable transitive dependency library symbol resolving.
+ "-Wl,--allow-shlib-undefined",
+ }
+
+ armArmCflags = []string{
+ "-O2",
+ "-fomit-frame-pointer",
+ "-fstrict-aliasing",
+ "-funswitch-loops",
+ }
+
+ armThumbCflags = []string{
+ "-mthumb",
+ "-Os",
+ "-fomit-frame-pointer",
+ "-fno-strict-aliasing",
+ }
+
+ armArchVariantCflags = map[string][]string{
+ "armv5te": []string{
+ "-march=armv5te",
+ "-mtune=xscale",
+ "-D__ARM_ARCH_5__",
+ "-D__ARM_ARCH_5T__",
+ "-D__ARM_ARCH_5E__",
+ "-D__ARM_ARCH_5TE__",
+ },
+ "armv7-a": []string{
+ "-march=armv7-a",
+ "-mfloat-abi=softfp",
+ "-mfpu=vfpv3-d16",
+ },
+ "armv7-a-neon": []string{
+ "-mfloat-abi=softfp",
+ "-mfpu=neon",
+ },
+ }
+
+ armArchVariantLdflags = map[string][]string{
+ "armv7-a": []string{
+ "-Wl,--fix-cortex-a8",
+ },
+ }
+
+ armCpuVariantCflags = map[string][]string{
+ "cortex-a7": []string{
+ "-mcpu=cortex-a7",
+ },
+ "cortex-a8": []string{
+ "-mcpu=cortex-a8",
+ },
+ "cortex-a15": []string{
+ "-mcpu=cortex-a15",
+ // Fake an ARM compiler flag as these processors support LPAE which GCC/clang
+ // don't advertise.
+ "-D__ARM_FEATURE_LPAE=1",
+ },
+ }
+
+ armClangCpuVariantCflags = armCpuVariantCflags
+ armClangArchVariantCflags = armArchVariantCflags
+)
+
+func init() {
+ replaceFirst := func(slice []string, from, to string) {
+ if slice[0] != from {
+ panic(fmt.Errorf("Expected %q, found %q", from, to))
+ }
+
+ slice[0] = to
+ }
+
+ replaceFirst(armClangArchVariantCflags["armv5te"], "-march=armv5te", "-march=armv5t")
+ replaceFirst(armClangCpuVariantCflags["cortex-a15"], "-mcpu=cortex-a15", "-march=armv7-a")
+ armClangCpuVariantCflags["krait"] = []string{
+ "-mcpu=krait",
+ }
+
+ pctx.StaticVariable("armGccVersion", "4.9")
+
+ pctx.StaticVariable("armGccRoot",
+ "${SrcDir}/prebuilts/gcc/${HostPrebuiltTag}/arm/arm-linux-androideabi-${armGccVersion}")
+
+ pctx.StaticVariable("armGccTriple", "arm-linux-androideabi")
+
+ pctx.StaticVariable("armCflags", strings.Join(armCflags, " "))
+ pctx.StaticVariable("armLdflags", strings.Join(armLdflags, " "))
+ pctx.StaticVariable("armCppflags", strings.Join(armCppflags, " "))
+ pctx.StaticVariable("armIncludeFlags", strings.Join([]string{
+ "-isystem ${LibcRoot}/arch-arm/include",
+ "-isystem ${LibcRoot}/include",
+ "-isystem ${LibcRoot}/kernel/uapi",
+ "-isystem ${LibcRoot}/kernel/uapi/asm-arm",
+ "-isystem ${LibmRoot}/include",
+ "-isystem ${LibmRoot}/include/arm",
+ }, " "))
+
+ // Extended cflags
+
+ // ARM mode vs. Thumb mode
+ pctx.StaticVariable("armArmCflags", strings.Join(armArmCflags, " "))
+ pctx.StaticVariable("armThumbCflags", strings.Join(armThumbCflags, " "))
+
+ // Architecture variant cflags
+ pctx.StaticVariable("armArmv5TECflags", strings.Join(armArchVariantCflags["armv5te"], " "))
+ pctx.StaticVariable("armArmv7ACflags", strings.Join(armArchVariantCflags["armv7-a"], " "))
+ pctx.StaticVariable("armArmv7ANeonCflags", strings.Join(armArchVariantCflags["armv7-a-neon"], " "))
+
+ // Architecture variant ldflags
+ pctx.StaticVariable("armArmv7ALdflags", strings.Join(armArchVariantLdflags["armv7-a"], " "))
+
+ // Cpu variant cflags
+ pctx.StaticVariable("armCortexA7Cflags", strings.Join(armCpuVariantCflags["cortex-a7"], " "))
+ pctx.StaticVariable("armCortexA8Cflags", strings.Join(armCpuVariantCflags["cortex-a8"], " "))
+ pctx.StaticVariable("armCortexA15Cflags", strings.Join(armCpuVariantCflags["cortex-a15"], " "))
+
+ // Clang cflags
+ pctx.StaticVariable("armClangCflags", strings.Join(clangFilterUnknownCflags(armCflags), " "))
+ pctx.StaticVariable("armClangLdflags", strings.Join(clangFilterUnknownCflags(armLdflags), " "))
+ pctx.StaticVariable("armClangCppflags", strings.Join(clangFilterUnknownCflags(armCppflags), " "))
+
+ // Clang cpu variant cflags
+ pctx.StaticVariable("armClangArmv5TECflags",
+ strings.Join(armClangArchVariantCflags["armv5te"], " "))
+ pctx.StaticVariable("armClangArmv7ACflags",
+ strings.Join(armClangArchVariantCflags["armv7-a"], " "))
+ pctx.StaticVariable("armClangArmv7ANeonCflags",
+ strings.Join(armClangArchVariantCflags["armv7-a-neon"], " "))
+
+ // Clang cpu variant cflags
+ pctx.StaticVariable("armClangCortexA7Cflags",
+ strings.Join(armClangCpuVariantCflags["cortex-a7"], " "))
+ pctx.StaticVariable("armClangCortexA8Cflags",
+ strings.Join(armClangCpuVariantCflags["cortex-a8"], " "))
+ pctx.StaticVariable("armClangCortexA15Cflags",
+ strings.Join(armClangCpuVariantCflags["cortex-a15"], " "))
+ pctx.StaticVariable("armClangKraitCflags",
+ strings.Join(armClangCpuVariantCflags["krait"], " "))
+}
+
+var (
+ armArchVariantCflagsVar = map[string]string{
+ "armv5te": "${armArmv5TECflags}",
+ "armv7-a": "${armArmv7ACflags}",
+ "armv7-a-neon": "${armArmv7ANeonCflags}",
+ }
+
+ armArchVariantLdflagsVar = map[string]string{
+ "armv7-a": "${armArmv7ALdflags}",
+ "armv7-a-neon": "${armArmv7ALdflags}",
+ }
+
+ armCpuVariantCflagsVar = map[string]string{
+ "": "",
+ "cortex-a7": "${armCortexA7Cflags}",
+ "cortex-a8": "${armCortexA8Cflags}",
+ "cortex-a15": "${armCortexA15Cflags}",
+ "krait": "${armCortexA15Cflags}",
+ "denver": "${armCortexA15Cflags}",
+ }
+
+ armClangArchVariantCflagsVar = map[string]string{
+ "armv5te": "${armClangArmv5TECflags}",
+ "armv7-a": "${armClangArmv7ACflags}",
+ "armv7-a-neon": "${armClangArmv7ANeonCflags}",
+ }
+
+ armClangCpuVariantCflagsVar = map[string]string{
+ "": "",
+ "cortex-a7": "${armClangCortexA7Cflags}",
+ "cortex-a8": "${armClangCortexA8Cflags}",
+ "cortex-a15": "${armClangCortexA15Cflags}",
+ "krait": "${armClangKraitCflags}",
+ "denver": "${armClangCortexA15Cflags}",
+ }
+)
+
+type toolchainArm struct {
+ toolchain32Bit
+ cflags, ldflags, clangCflags string
+}
+
+func (t *toolchainArm) GccRoot() string {
+ return "${armGccRoot}"
+}
+
+func (t *toolchainArm) GccTriple() string {
+ return "${armGccTriple}"
+}
+
+func (t *toolchainArm) Cflags() string {
+ return t.cflags
+}
+
+func (t *toolchainArm) Cppflags() string {
+ return "${armCppflags}"
+}
+
+func (t *toolchainArm) Ldflags() string {
+ return t.ldflags
+}
+
+func (t *toolchainArm) IncludeFlags() string {
+ return "${armIncludeFlags}"
+}
+
+func (t *toolchainArm) ClangTriple() string {
+ return "${armGccTriple}"
+}
+
+func (t *toolchainArm) ClangCflags() string {
+ return t.clangCflags
+}
+
+func (t *toolchainArm) ClangCppflags() string {
+ return "${armClangCppflags}"
+}
+
+func (t *toolchainArm) ClangLdflags() string {
+ return t.ldflags
+}
+
+func armToolchainFactory(archVariant string, cpuVariant string) toolchain {
+ return &toolchainArm{
+ cflags: strings.Join([]string{
+ "${armCflags}",
+ "${armIncludeFlags}",
+ "${armThumbCflags}",
+ armArchVariantCflagsVar[archVariant],
+ armCpuVariantCflagsVar[cpuVariant],
+ }, " "),
+ ldflags: strings.Join([]string{
+ "${armLdflags}",
+ armArchVariantLdflagsVar[archVariant],
+ }, " "),
+ clangCflags: strings.Join([]string{
+ "${armClangCflags}",
+ "${armIncludeFlags}",
+ "${armThumbCflags}",
+ armClangArchVariantCflagsVar[archVariant],
+ armClangCpuVariantCflagsVar[cpuVariant],
+ }, " "),
+ }
+}
+
+func init() {
+ registerToolchainFactory(common.Device, common.Arm, armToolchainFactory)
+}