blob: b2b07648dc850002427c690c3f8151d2af1e7a40 [file] [log] [blame] [edit]
// Copyright 2015 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 (
"fmt"
"strings"
"android/soong/android"
)
var (
arm64Cflags = []string{
// Help catch common 32/64-bit errors.
"-Werror=implicit-function-declaration",
}
arm64ArchVariantCflags = map[string][]string{
"armv8-a": []string{
"-march=armv8-a",
},
"armv8-2a": []string{
"-march=armv8.2a",
},
}
arm64Ldflags = []string{
"-Wl,-m,aarch64_elf64_le_vec",
"-Wl,--hash-style=gnu",
"-fuse-ld=gold",
"-Wl,--icf=safe",
}
arm64Cppflags = []string{}
arm64CpuVariantCflags = map[string][]string{
"cortex-a53": []string{
"-mcpu=cortex-a53",
},
"cortex-a55": []string{
// The cortex-a55 target is not yet supported,
// so use cortex-a53.
"-mcpu=cortex-a53",
},
"cortex-a75": []string{
// Use the cortex-a53 since it is similar to the little
// core (cortex-a55) and is sensitive to ordering.
// The cortex-a55 target is not yet supported.
"-mcpu=cortex-a53",
},
"kryo": []string{
// Use the cortex-a57 cpu since some compilers
// don't support a Kryo specific target yet.
"-mcpu=cortex-a57",
},
"exynos-m1": []string{
"-mcpu=exynos-m1",
},
"exynos-m2": []string{
"-mcpu=exynos-m2",
},
}
arm64ClangCpuVariantCflags = copyVariantFlags(arm64CpuVariantCflags)
)
const (
arm64GccVersion = "4.9"
)
func init() {
android.RegisterArchVariants(android.Arm64,
"armv8_a",
"armv8_2a",
"cortex-a53",
"cortex-a55",
"cortex-a73",
"cortex-a75",
"kryo",
"exynos-m1",
"exynos-m2",
"denver64")
// Clang supports specific Kryo targeting
replaceFirst(arm64ClangCpuVariantCflags["kryo"], "-mcpu=cortex-a57", "-mcpu=kryo")
pctx.StaticVariable("arm64GccVersion", arm64GccVersion)
pctx.SourcePathVariable("Arm64GccRoot",
"prebuilts/gcc/${HostPrebuiltTag}/aarch64/aarch64-linux-android-${arm64GccVersion}")
pctx.StaticVariable("Arm64Cflags", strings.Join(arm64Cflags, " "))
pctx.StaticVariable("Arm64Ldflags", strings.Join(arm64Ldflags, " "))
pctx.StaticVariable("Arm64Cppflags", strings.Join(arm64Cppflags, " "))
pctx.StaticVariable("Arm64IncludeFlags", bionicHeaders("arm64"))
pctx.StaticVariable("Arm64ClangCflags", strings.Join(ClangFilterUnknownCflags(arm64Cflags), " "))
pctx.StaticVariable("Arm64ClangLdflags", strings.Join(ClangFilterUnknownCflags(arm64Ldflags), " "))
pctx.StaticVariable("Arm64ClangCppflags", strings.Join(ClangFilterUnknownCflags(arm64Cppflags), " "))
pctx.StaticVariable("Arm64ClangArmv8ACflags", strings.Join(arm64ArchVariantCflags["armv8-a"], " "))
pctx.StaticVariable("Arm64ClangArmv82ACflags", strings.Join(arm64ArchVariantCflags["armv8-2a"], " "))
pctx.StaticVariable("Arm64CortexA53Cflags",
strings.Join(arm64CpuVariantCflags["cortex-a53"], " "))
pctx.StaticVariable("Arm64ClangCortexA53Cflags",
strings.Join(arm64ClangCpuVariantCflags["cortex-a53"], " "))
pctx.StaticVariable("Arm64CortexA55Cflags",
strings.Join(arm64CpuVariantCflags["cortex-a55"], " "))
pctx.StaticVariable("Arm64ClangCortexA55Cflags",
strings.Join(arm64ClangCpuVariantCflags["cortex-a55"], " "))
pctx.StaticVariable("Arm64KryoCflags",
strings.Join(arm64CpuVariantCflags["kryo"], " "))
pctx.StaticVariable("Arm64ClangKryoCflags",
strings.Join(arm64ClangCpuVariantCflags["kryo"], " "))
pctx.StaticVariable("Arm64ExynosM1Cflags",
strings.Join(arm64CpuVariantCflags["cortex-a53"], " "))
pctx.StaticVariable("Arm64ClangExynosM1Cflags",
strings.Join(arm64ClangCpuVariantCflags["exynos-m1"], " "))
pctx.StaticVariable("Arm64ExynosM2Cflags",
strings.Join(arm64CpuVariantCflags["cortex-a53"], " "))
pctx.StaticVariable("Arm64ClangExynosM2Cflags",
strings.Join(arm64ClangCpuVariantCflags["exynos-m2"], " "))
}
var (
arm64CpuVariantCflagsVar = map[string]string{
"": "",
"cortex-a53": "${config.Arm64CortexA53Cflags}",
"cortex-a55": "${config.Arm64CortexA55Cflags}",
"cortex-a73": "${config.Arm64CortexA53Cflags}",
"cortex-a75": "${config.Arm64CortexA55Cflags}",
"kryo": "${config.Arm64KryoCflags}",
"exynos-m1": "${config.Arm64ExynosM1Cflags}",
"exynos-m2": "${config.Arm64ExynosM2Cflags}",
}
arm64ClangArchVariantCflagsVar = map[string]string{
"armv8-a": "${config.Arm64ClangArmv8ACflags}",
"armv8-2a": "${config.Arm64ClangArmv82ACflags}",
}
arm64ClangCpuVariantCflagsVar = map[string]string{
"": "",
"cortex-a53": "${config.Arm64ClangCortexA53Cflags}",
"cortex-a55": "${config.Arm64ClangCortexA55Cflags}",
"cortex-a73": "${config.Arm64ClangCortexA53Cflags}",
"cortex-a75": "${config.Arm64ClangCortexA55Cflags}",
"kryo": "${config.Arm64ClangKryoCflags}",
"exynos-m1": "${config.Arm64ClangExynosM1Cflags}",
"exynos-m2": "${config.Arm64ClangExynosM2Cflags}",
}
)
type toolchainArm64 struct {
toolchain64Bit
ldflags string
toolchainCflags string
toolchainClangCflags string
}
func (t *toolchainArm64) Name() string {
return "arm64"
}
func (t *toolchainArm64) GccRoot() string {
return "${config.Arm64GccRoot}"
}
func (t *toolchainArm64) GccTriple() string {
return "aarch64-linux-android"
}
func (t *toolchainArm64) GccVersion() string {
return arm64GccVersion
}
func (t *toolchainArm64) ToolchainCflags() string {
return t.toolchainCflags
}
func (t *toolchainArm64) Cflags() string {
return "${config.Arm64Cflags}"
}
func (t *toolchainArm64) Cppflags() string {
return "${config.Arm64Cppflags}"
}
func (t *toolchainArm64) Ldflags() string {
return t.ldflags
}
func (t *toolchainArm64) IncludeFlags() string {
return "${config.Arm64IncludeFlags}"
}
func (t *toolchainArm64) ClangTriple() string {
return t.GccTriple()
}
func (t *toolchainArm64) ClangCflags() string {
return "${config.Arm64ClangCflags}"
}
func (t *toolchainArm64) ClangCppflags() string {
return "${config.Arm64ClangCppflags}"
}
func (t *toolchainArm64) ClangLdflags() string {
return t.ldflags
}
func (t *toolchainArm64) ToolchainClangCflags() string {
return t.toolchainClangCflags
}
func (toolchainArm64) SanitizerRuntimeLibraryArch() string {
return "aarch64"
}
func arm64ToolchainFactory(arch android.Arch) Toolchain {
switch arch.ArchVariant {
case "armv8-a":
case "armv8-2a":
// Nothing extra for armv8-a/armv8-2a
default:
panic(fmt.Sprintf("Unknown ARM architecture version: %q", arch.ArchVariant))
}
toolchainClangCflags := []string{arm64ClangArchVariantCflagsVar[arch.ArchVariant]}
toolchainClangCflags = append(toolchainClangCflags,
variantOrDefault(arm64ClangCpuVariantCflagsVar, arch.CpuVariant))
var extraLdflags string
switch arch.CpuVariant {
case "cortex-a53", "cortex-a73", "kryo", "exynos-m1", "exynos-m2",
// This variant might not need the workaround but leave it
// in the list since it has had the workaround on before.
"denver64":
extraLdflags = "-Wl,--fix-cortex-a53-843419"
}
return &toolchainArm64{
ldflags: strings.Join([]string{
"${config.Arm64Ldflags}",
extraLdflags,
}, " "),
toolchainCflags: variantOrDefault(arm64CpuVariantCflagsVar, arch.CpuVariant),
toolchainClangCflags: strings.Join(toolchainClangCflags, " "),
}
}
func init() {
registerToolchainFactory(android.Android, android.Arm64, arm64ToolchainFactory)
}