1// Copyright 2015 Google Inc. All rights reserved. 2// 3// Licensed under the Apache License, Version 2.0 (the "License"); 4// you may not use this file except in compliance with the License. 5// You may obtain a copy of the License at 6// 7// http://www.apache.org/licenses/LICENSE-2.0 8// 9// Unless required by applicable law or agreed to in writing, software 10// distributed under the License is distributed on an "AS IS" BASIS, 11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12// See the License for the specific language governing permissions and 13// limitations under the License. 14 15package config 16 17import ( 18 "fmt" 19 "strings" 20 21 "android/soong/android" 22) 23 24var ( 25 arm64Cflags = []string{ 26 // Help catch common 32/64-bit errors. 27 "-Werror=implicit-function-declaration", 28 } 29 30 arm64ArchVariantCflags = map[string][]string{ 31 "armv8-a": []string{ 32 "-march=armv8-a", 33 }, 34 "armv8-a-branchprot": []string{ 35 "-march=armv8-a", 36 "-mbranch-protection=standard", 37 }, 38 "armv8-2a": []string{ 39 "-march=armv8.2-a", 40 }, 41 "armv8-2a-dotprod": []string{ 42 "-march=armv8.2-a+dotprod", 43 }, 44 // On ARMv9 and later, Pointer Authentication Codes (PAC) are mandatory, 45 // so -fstack-protector is unnecessary. 46 "armv9-a": []string{ 47 "-march=armv9-a", 48 "-mbranch-protection=standard", 49 "-fno-stack-protector", 50 }, 51 "armv9-2a": []string{ 52 "-march=armv9.2-a", 53 "-mbranch-protection=standard", 54 "-fno-stack-protector", 55 }, 56 "armv9-3a": []string{ 57 "-march=armv9.3-a", 58 "-mbranch-protection=standard", 59 "-fno-stack-protector", 60 }, 61 "armv9-4a": []string{ 62 "-march=armv9.4-a", 63 "-mbranch-protection=standard", 64 "-fno-stack-protector", 65 }, 66 } 67 68 arm64Ldflags = []string{ 69 "-Wl,-z,separate-code", 70 "-Wl,-z,separate-loadable-segments", 71 } 72 73 arm64Lldflags = arm64Ldflags 74 75 arm64Cppflags = []string{} 76 77 arm64CpuVariantCflags = map[string][]string{ 78 "cortex-a53": []string{ 79 "-mcpu=cortex-a53", 80 }, 81 "cortex-a55": []string{ 82 "-mcpu=cortex-a55", 83 }, 84 "cortex-a75": []string{ 85 // Use the cortex-a55 since it is similar to the little 86 // core (cortex-a55) and is sensitive to ordering. 87 "-mcpu=cortex-a55", 88 }, 89 "cortex-a76": []string{ 90 // Use the cortex-a55 since it is similar to the little 91 // core (cortex-a55) and is sensitive to ordering. 92 "-mcpu=cortex-a55", 93 }, 94 "kryo": []string{ 95 "-mcpu=kryo", 96 }, 97 "kryo385": []string{ 98 // Use cortex-a53 because kryo385 is not supported in clang. 99 "-mcpu=cortex-a53", 100 }, 101 "exynos-m1": []string{ 102 "-mcpu=exynos-m1", 103 }, 104 "exynos-m2": []string{ 105 "-mcpu=exynos-m2", 106 }, 107 } 108) 109 110func init() { 111 pctx.StaticVariable("Arm64Ldflags", strings.Join(arm64Ldflags, " ")) 112 113 pctx.VariableFunc("Arm64Lldflags", func(ctx android.PackageVarContext) string { 114 maxPageSizeFlag := "-Wl,-z,max-page-size=" + ctx.Config().MaxPageSizeSupported() 115 flags := append(arm64Lldflags, maxPageSizeFlag) 116 return strings.Join(flags, " ") 117 }) 118 119 pctx.VariableFunc("Arm64Cflags", func(ctx android.PackageVarContext) string { 120 flags := arm64Cflags 121 if ctx.Config().NoBionicPageSizeMacro() { 122 flags = append(flags, "-D__BIONIC_NO_PAGE_SIZE_MACRO") 123 } else { 124 flags = append(flags, "-D__BIONIC_DEPRECATED_PAGE_SIZE_MACRO") 125 } 126 return strings.Join(flags, " ") 127 }) 128 129 pctx.StaticVariable("Arm64Cppflags", strings.Join(arm64Cppflags, " ")) 130 131 for variant, cflags := range arm64ArchVariantCflags { 132 pctx.StaticVariable("Arm64"+variant+"VariantCflags", strings.Join(cflags, " ")) 133 } 134 135 pctx.StaticVariable("Arm64CortexA53Cflags", strings.Join(arm64CpuVariantCflags["cortex-a53"], " ")) 136 pctx.StaticVariable("Arm64CortexA55Cflags", strings.Join(arm64CpuVariantCflags["cortex-a55"], " ")) 137 pctx.StaticVariable("Arm64KryoCflags", strings.Join(arm64CpuVariantCflags["kryo"], " ")) 138 pctx.StaticVariable("Arm64ExynosM1Cflags", strings.Join(arm64CpuVariantCflags["exynos-m1"], " ")) 139 pctx.StaticVariable("Arm64ExynosM2Cflags", strings.Join(arm64CpuVariantCflags["exynos-m2"], " ")) 140 141 pctx.StaticVariable("Arm64FixCortexA53Ldflags", "-Wl,--fix-cortex-a53-843419") 142} 143 144var ( 145 arm64CpuVariantCflagsVar = map[string]string{ 146 "cortex-a53": "${config.Arm64CortexA53Cflags}", 147 "cortex-a55": "${config.Arm64CortexA55Cflags}", 148 "cortex-a72": "${config.Arm64CortexA53Cflags}", 149 "cortex-a73": "${config.Arm64CortexA53Cflags}", 150 "cortex-a75": "${config.Arm64CortexA55Cflags}", 151 "cortex-a76": "${config.Arm64CortexA55Cflags}", 152 "kryo": "${config.Arm64KryoCflags}", 153 "kryo385": "${config.Arm64CortexA53Cflags}", 154 "exynos-m1": "${config.Arm64ExynosM1Cflags}", 155 "exynos-m2": "${config.Arm64ExynosM2Cflags}", 156 } 157 158 arm64CpuVariantLdflags = map[string]string{ 159 "cortex-a53": "${config.Arm64FixCortexA53Ldflags}", 160 "cortex-a72": "${config.Arm64FixCortexA53Ldflags}", 161 "cortex-a73": "${config.Arm64FixCortexA53Ldflags}", 162 "kryo": "${config.Arm64FixCortexA53Ldflags}", 163 "exynos-m1": "${config.Arm64FixCortexA53Ldflags}", 164 "exynos-m2": "${config.Arm64FixCortexA53Ldflags}", 165 } 166) 167 168type toolchainArm64 struct { 169 toolchainBionic 170 toolchain64Bit 171 172 ldflags string 173 lldflags string 174 toolchainCflags string 175} 176 177func (t *toolchainArm64) Name() string { 178 return "arm64" 179} 180 181func (t *toolchainArm64) IncludeFlags() string { 182 return "" 183} 184 185func (t *toolchainArm64) ClangTriple() string { 186 return "aarch64-linux-android" 187} 188 189func (t *toolchainArm64) Cflags() string { 190 return "${config.Arm64Cflags}" 191} 192 193func (t *toolchainArm64) Cppflags() string { 194 return "${config.Arm64Cppflags}" 195} 196 197func (t *toolchainArm64) Ldflags() string { 198 return t.ldflags 199} 200 201func (t *toolchainArm64) Lldflags() string { 202 return t.lldflags 203} 204 205func (t *toolchainArm64) ToolchainCflags() string { 206 return t.toolchainCflags 207} 208 209func (toolchainArm64) LibclangRuntimeLibraryArch() string { 210 return "aarch64" 211} 212 213func arm64ToolchainFactory(arch android.Arch) Toolchain { 214 // Error now rather than having a confusing Ninja error 215 if _, ok := arm64ArchVariantCflags[arch.ArchVariant]; !ok { 216 panic(fmt.Sprintf("Unknown ARM64 architecture version: %q", arch.ArchVariant)) 217 } 218 219 toolchainCflags := []string{"${config.Arm64" + arch.ArchVariant + "VariantCflags}"} 220 toolchainCflags = append(toolchainCflags, 221 variantOrDefault(arm64CpuVariantCflagsVar, arch.CpuVariant)) 222 223 extraLdflags := variantOrDefault(arm64CpuVariantLdflags, arch.CpuVariant) 224 return &toolchainArm64{ 225 ldflags: strings.Join([]string{ 226 "${config.Arm64Ldflags}", 227 extraLdflags, 228 }, " "), 229 lldflags: strings.Join([]string{ 230 "${config.Arm64Lldflags}", 231 extraLdflags, 232 }, " "), 233 toolchainCflags: strings.Join(toolchainCflags, " "), 234 } 235} 236 237func init() { 238 registerToolchainFactory(android.Android, android.Arm64, arm64ToolchainFactory) 239} 240