Colin Cross | b0cba6a | 2015-11-20 15:35:26 -0800 | [diff] [blame] | 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 | |
Colin Cross | b98c8b0 | 2016-07-29 13:44:28 -0700 | [diff] [blame] | 15 | package config |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 16 | |
| 17 | import ( |
| 18 | "fmt" |
| 19 | "strings" |
| 20 | |
Colin Cross | 635c3b0 | 2016-05-18 15:37:25 -0700 | [diff] [blame] | 21 | "android/soong/android" |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 22 | ) |
| 23 | |
| 24 | var ( |
Colin Cross | c4bde76 | 2015-11-23 16:11:30 -0800 | [diff] [blame] | 25 | armToolchainCflags = []string{ |
Dan Willemsen | c264c16 | 2016-05-18 22:52:25 -0700 | [diff] [blame] | 26 | "-msoft-float", |
Colin Cross | c4bde76 | 2015-11-23 16:11:30 -0800 | [diff] [blame] | 27 | } |
| 28 | |
Colin Cross | bc2c7c2 | 2017-11-18 00:10:01 +0000 | [diff] [blame] | 29 | armCflags = []string{ |
| 30 | "-fomit-frame-pointer", |
AdityaK | c4b7a18 | 2024-01-25 18:59:21 -0800 | [diff] [blame^] | 31 | // Revert this after b/322359235 is fixed |
| 32 | "-mllvm", "-enable-shrink-wrap=false", |
Colin Cross | bc2c7c2 | 2017-11-18 00:10:01 +0000 | [diff] [blame] | 33 | } |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 34 | |
AdityaK | c4b7a18 | 2024-01-25 18:59:21 -0800 | [diff] [blame^] | 35 | armCppflags = []string{ |
| 36 | // Revert this after b/322359235 is fixed |
| 37 | "-mllvm", "-enable-shrink-wrap=false", |
| 38 | } |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 39 | |
| 40 | armLdflags = []string{ |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 41 | "-Wl,--hash-style=gnu", |
Stephen Crane | b3c2154 | 2017-06-26 19:22:02 -0700 | [diff] [blame] | 42 | "-Wl,-m,armelf", |
AdityaK | c4b7a18 | 2024-01-25 18:59:21 -0800 | [diff] [blame^] | 43 | // Revert this after b/322359235 is fixed |
| 44 | "-Wl,-mllvm", "-Wl,-enable-shrink-wrap=false", |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 45 | } |
| 46 | |
Colin Cross | 33bac24 | 2021-07-14 17:03:16 -0700 | [diff] [blame] | 47 | armLldflags = armLdflags |
Chih-Hung Hsieh | 02b4da5 | 2018-04-03 11:33:34 -0700 | [diff] [blame] | 48 | |
Liz Kammer | e8303bd | 2022-02-16 09:02:48 -0500 | [diff] [blame] | 49 | armFixCortexA8LdFlags = []string{"-Wl,--fix-cortex-a8"} |
| 50 | |
| 51 | armNoFixCortexA8LdFlags = []string{"-Wl,--no-fix-cortex-a8"} |
| 52 | |
Elliott Hughes | 9bbe960 | 2023-06-30 19:31:57 +0000 | [diff] [blame] | 53 | armArmCflags = []string{} |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 54 | |
| 55 | armThumbCflags = []string{ |
| 56 | "-mthumb", |
| 57 | "-Os", |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 58 | } |
| 59 | |
Colin Cross | 33bac24 | 2021-07-14 17:03:16 -0700 | [diff] [blame] | 60 | armArchVariantCflags = map[string][]string{ |
Dan Albert | 8818f49 | 2019-02-19 13:53:01 -0800 | [diff] [blame] | 61 | "armv7-a": []string{ |
| 62 | "-march=armv7-a", |
| 63 | "-mfloat-abi=softfp", |
| 64 | "-mfpu=vfpv3-d16", |
| 65 | }, |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 66 | "armv7-a-neon": []string{ |
Isaac Chen | 2bce8ed | 2017-10-05 18:28:57 +0800 | [diff] [blame] | 67 | "-march=armv7-a", |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 68 | "-mfloat-abi=softfp", |
| 69 | "-mfpu=neon", |
| 70 | }, |
Isaac Chen | a2a5824 | 2017-08-23 10:57:17 +0000 | [diff] [blame] | 71 | "armv8-a": []string{ |
| 72 | "-march=armv8-a", |
| 73 | "-mfloat-abi=softfp", |
| 74 | "-mfpu=neon-fp-armv8", |
| 75 | }, |
mtk15504 | 270ba75 | 2018-10-31 15:26:32 +0800 | [diff] [blame] | 76 | "armv8-2a": []string{ |
| 77 | "-march=armv8.2-a", |
| 78 | "-mfloat-abi=softfp", |
| 79 | "-mfpu=neon-fp-armv8", |
| 80 | }, |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 81 | } |
| 82 | |
Colin Cross | 33bac24 | 2021-07-14 17:03:16 -0700 | [diff] [blame] | 83 | armCpuVariantCflags = map[string][]string{ |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 84 | "cortex-a7": []string{ |
| 85 | "-mcpu=cortex-a7", |
Jake Weinstein | 5cfd709 | 2017-04-06 22:25:34 -0400 | [diff] [blame] | 86 | "-mfpu=neon-vfpv4", |
Colin Cross | 4fa894d | 2022-09-30 15:44:45 -0700 | [diff] [blame] | 87 | // Fake an ARM compiler flag as these processors support LPAE which clang |
Dan Willemsen | 8e1e3fb | 2016-03-29 15:47:08 -0700 | [diff] [blame] | 88 | // don't advertise. |
| 89 | // TODO This is a hack and we need to add it for each processor that supports LPAE until some |
| 90 | // better solution comes around. See Bug 27340895 |
| 91 | "-D__ARM_FEATURE_LPAE=1", |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 92 | }, |
| 93 | "cortex-a8": []string{ |
| 94 | "-mcpu=cortex-a8", |
| 95 | }, |
| 96 | "cortex-a15": []string{ |
| 97 | "-mcpu=cortex-a15", |
Jake Weinstein | 5916657 | 2017-04-06 20:47:23 -0400 | [diff] [blame] | 98 | "-mfpu=neon-vfpv4", |
Colin Cross | 4fa894d | 2022-09-30 15:44:45 -0700 | [diff] [blame] | 99 | // Fake an ARM compiler flag as these processors support LPAE which clang |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 100 | // don't advertise. |
Dan Willemsen | 8e1e3fb | 2016-03-29 15:47:08 -0700 | [diff] [blame] | 101 | // TODO This is a hack and we need to add it for each processor that supports LPAE until some |
| 102 | // better solution comes around. See Bug 27340895 |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 103 | "-D__ARM_FEATURE_LPAE=1", |
| 104 | }, |
Jesus Sanchez-Palencia | de7c784 | 2023-03-02 16:56:05 -0800 | [diff] [blame] | 105 | "cortex-a32": []string{ |
| 106 | "-mcpu=cortex-a32", |
| 107 | "-mfpu=neon-vfpv4", |
| 108 | // Fake an ARM compiler flag as these processors support LPAE which clang |
| 109 | // don't advertise. |
| 110 | // TODO This is a hack and we need to add it for each processor that supports LPAE until some |
| 111 | // better solution comes around. See Bug 27340895 |
| 112 | "-D__ARM_FEATURE_LPAE=1", |
| 113 | }, |
Christopher Ferris | 6df46f5 | 2017-05-08 12:08:40 -0700 | [diff] [blame] | 114 | "cortex-a53": []string{ |
| 115 | "-mcpu=cortex-a53", |
| 116 | "-mfpu=neon-fp-armv8", |
Colin Cross | 4fa894d | 2022-09-30 15:44:45 -0700 | [diff] [blame] | 117 | // Fake an ARM compiler flag as these processors support LPAE which clang |
Christopher Ferris | 6df46f5 | 2017-05-08 12:08:40 -0700 | [diff] [blame] | 118 | // don't advertise. |
| 119 | // TODO This is a hack and we need to add it for each processor that supports LPAE until some |
| 120 | // better solution comes around. See Bug 27340895 |
| 121 | "-D__ARM_FEATURE_LPAE=1", |
| 122 | }, |
Christopher Ferris | ba14a8f | 2018-04-23 18:15:25 -0700 | [diff] [blame] | 123 | "cortex-a55": []string{ |
Yi Kong | 9c63363 | 2018-06-15 15:46:11 -0700 | [diff] [blame] | 124 | "-mcpu=cortex-a55", |
Christopher Ferris | ba14a8f | 2018-04-23 18:15:25 -0700 | [diff] [blame] | 125 | "-mfpu=neon-fp-armv8", |
Colin Cross | 4fa894d | 2022-09-30 15:44:45 -0700 | [diff] [blame] | 126 | // Fake an ARM compiler flag as these processors support LPAE which clang |
Christopher Ferris | ba14a8f | 2018-04-23 18:15:25 -0700 | [diff] [blame] | 127 | // don't advertise. |
| 128 | // TODO This is a hack and we need to add it for each processor that supports LPAE until some |
| 129 | // better solution comes around. See Bug 27340895 |
| 130 | "-D__ARM_FEATURE_LPAE=1", |
| 131 | }, |
| 132 | "cortex-a75": []string{ |
Yi Kong | 9c63363 | 2018-06-15 15:46:11 -0700 | [diff] [blame] | 133 | "-mcpu=cortex-a55", |
Christopher Ferris | ba14a8f | 2018-04-23 18:15:25 -0700 | [diff] [blame] | 134 | "-mfpu=neon-fp-armv8", |
Colin Cross | 4fa894d | 2022-09-30 15:44:45 -0700 | [diff] [blame] | 135 | // Fake an ARM compiler flag as these processors support LPAE which clang |
Christopher Ferris | ba14a8f | 2018-04-23 18:15:25 -0700 | [diff] [blame] | 136 | // don't advertise. |
| 137 | // TODO This is a hack and we need to add it for each processor that supports LPAE until some |
| 138 | // better solution comes around. See Bug 27340895 |
| 139 | "-D__ARM_FEATURE_LPAE=1", |
| 140 | }, |
Haibo Huang | a31e2bd | 2018-10-09 14:27:28 -0700 | [diff] [blame] | 141 | "cortex-a76": []string{ |
| 142 | "-mcpu=cortex-a55", |
| 143 | "-mfpu=neon-fp-armv8", |
Colin Cross | 4fa894d | 2022-09-30 15:44:45 -0700 | [diff] [blame] | 144 | // Fake an ARM compiler flag as these processors support LPAE which clang |
Haibo Huang | a31e2bd | 2018-10-09 14:27:28 -0700 | [diff] [blame] | 145 | // don't advertise. |
| 146 | // TODO This is a hack and we need to add it for each processor that supports LPAE until some |
| 147 | // better solution comes around. See Bug 27340895 |
| 148 | "-D__ARM_FEATURE_LPAE=1", |
| 149 | }, |
Dan Willemsen | ed89a7a | 2016-05-09 13:39:58 -0700 | [diff] [blame] | 150 | "krait": []string{ |
Dan Willemsen | bd4abf5 | 2018-10-07 21:06:36 -0700 | [diff] [blame] | 151 | "-mcpu=krait", |
Jake Weinstein | fff256f | 2017-04-06 20:38:26 -0400 | [diff] [blame] | 152 | "-mfpu=neon-vfpv4", |
Colin Cross | 4fa894d | 2022-09-30 15:44:45 -0700 | [diff] [blame] | 153 | // Fake an ARM compiler flag as these processors support LPAE which clang |
Dan Willemsen | ed89a7a | 2016-05-09 13:39:58 -0700 | [diff] [blame] | 154 | // don't advertise. |
| 155 | // TODO This is a hack and we need to add it for each processor that supports LPAE until some |
| 156 | // better solution comes around. See Bug 27340895 |
| 157 | "-D__ARM_FEATURE_LPAE=1", |
| 158 | }, |
Alex Naidis | ae4fc18 | 2016-08-20 00:14:56 +0200 | [diff] [blame] | 159 | "kryo": []string{ |
Pirama Arumuga Nainar | c17b275 | 2017-11-20 22:29:58 -0800 | [diff] [blame] | 160 | // Use cortex-a53 because the GNU assembler doesn't recognize -mcpu=kryo |
| 161 | // even though clang does. |
| 162 | "-mcpu=cortex-a53", |
Jake Weinstein | 1783a2f | 2017-04-06 20:28:05 -0400 | [diff] [blame] | 163 | "-mfpu=neon-fp-armv8", |
Colin Cross | 4fa894d | 2022-09-30 15:44:45 -0700 | [diff] [blame] | 164 | // Fake an ARM compiler flag as these processors support LPAE which clang |
Alex Naidis | ae4fc18 | 2016-08-20 00:14:56 +0200 | [diff] [blame] | 165 | // don't advertise. |
| 166 | // TODO This is a hack and we need to add it for each processor that supports LPAE until some |
| 167 | // better solution comes around. See Bug 27340895 |
| 168 | "-D__ARM_FEATURE_LPAE=1", |
| 169 | }, |
Artem Serov | d3072b0 | 2018-11-15 15:21:51 +0000 | [diff] [blame] | 170 | "kryo385": []string{ |
Colin Cross | 4fa894d | 2022-09-30 15:44:45 -0700 | [diff] [blame] | 171 | // Use cortex-a53 because kryo385 is not supported in clang. |
Artem Serov | d3072b0 | 2018-11-15 15:21:51 +0000 | [diff] [blame] | 172 | "-mcpu=cortex-a53", |
Colin Cross | 4fa894d | 2022-09-30 15:44:45 -0700 | [diff] [blame] | 173 | // Fake an ARM compiler flag as these processors support LPAE which clang |
Artem Serov | d3072b0 | 2018-11-15 15:21:51 +0000 | [diff] [blame] | 174 | // don't advertise. |
| 175 | // TODO This is a hack and we need to add it for each processor that supports LPAE until some |
| 176 | // better solution comes around. See Bug 27340895 |
| 177 | "-D__ARM_FEATURE_LPAE=1", |
| 178 | }, |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 179 | } |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 180 | ) |
| 181 | |
Dan Willemsen | 34fc3b1 | 2015-12-07 12:30:44 -0800 | [diff] [blame] | 182 | const ( |
Colin Cross | 4fa894d | 2022-09-30 15:44:45 -0700 | [diff] [blame] | 183 | name = "arm" |
| 184 | ndkTriple = "arm-linux-androideabi" |
| 185 | clangTriple = "armv7a-linux-androideabi" |
Dan Willemsen | 34fc3b1 | 2015-12-07 12:30:44 -0800 | [diff] [blame] | 186 | ) |
| 187 | |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 188 | func init() { |
Jingwen Chen | 51a1e1c | 2021-05-20 13:40:14 +0000 | [diff] [blame] | 189 | // Just exported. Not created as a Ninja static variable. |
Sam Delmerico | 7f88956 | 2022-03-25 14:55:40 +0000 | [diff] [blame] | 190 | exportedVars.ExportString("ArmClangTriple", clangTriple) |
Jingwen Chen | 51a1e1c | 2021-05-20 13:40:14 +0000 | [diff] [blame] | 191 | |
Sam Delmerico | 7f88956 | 2022-03-25 14:55:40 +0000 | [diff] [blame] | 192 | exportedVars.ExportStringListStaticVariable("ArmLdflags", armLdflags) |
Juan Yescas | 23cc4aa | 2023-08-11 12:00:40 -0700 | [diff] [blame] | 193 | exportedVars.ExportStringListStaticVariable("ArmLldflags", armLldflags) |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 194 | |
Sam Delmerico | 7f88956 | 2022-03-25 14:55:40 +0000 | [diff] [blame] | 195 | exportedVars.ExportStringListStaticVariable("ArmFixCortexA8LdFlags", armFixCortexA8LdFlags) |
| 196 | exportedVars.ExportStringListStaticVariable("ArmNoFixCortexA8LdFlags", armNoFixCortexA8LdFlags) |
Liz Kammer | e8303bd | 2022-02-16 09:02:48 -0500 | [diff] [blame] | 197 | |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 198 | // Clang cflags |
Sam Delmerico | 7f88956 | 2022-03-25 14:55:40 +0000 | [diff] [blame] | 199 | exportedVars.ExportStringListStaticVariable("ArmToolchainCflags", armToolchainCflags) |
| 200 | exportedVars.ExportStringListStaticVariable("ArmCflags", armCflags) |
| 201 | exportedVars.ExportStringListStaticVariable("ArmCppflags", armCppflags) |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 202 | |
Dan Willemsen | 6d11dd8 | 2015-11-03 14:27:00 -0800 | [diff] [blame] | 203 | // Clang ARM vs. Thumb instruction set cflags |
Sam Delmerico | 7f88956 | 2022-03-25 14:55:40 +0000 | [diff] [blame] | 204 | exportedVars.ExportStringListStaticVariable("ArmArmCflags", armArmCflags) |
| 205 | exportedVars.ExportStringListStaticVariable("ArmThumbCflags", armThumbCflags) |
Dan Willemsen | 6d11dd8 | 2015-11-03 14:27:00 -0800 | [diff] [blame] | 206 | |
Sam Delmerico | 7f88956 | 2022-03-25 14:55:40 +0000 | [diff] [blame] | 207 | exportedVars.ExportVariableReferenceDict("ArmArchVariantCflags", armArchVariantCflagsVar) |
| 208 | exportedVars.ExportVariableReferenceDict("ArmCpuVariantCflags", armCpuVariantCflagsVar) |
Liz Kammer | 82ad8cc | 2021-08-02 10:41:48 -0400 | [diff] [blame] | 209 | |
Dan Willemsen | 110a89d | 2016-01-14 15:17:19 -0800 | [diff] [blame] | 210 | // Clang arch variant cflags |
Sam Delmerico | 7f88956 | 2022-03-25 14:55:40 +0000 | [diff] [blame] | 211 | exportedVars.ExportStringListStaticVariable("ArmArmv7ACflags", armArchVariantCflags["armv7-a"]) |
| 212 | exportedVars.ExportStringListStaticVariable("ArmArmv7ANeonCflags", armArchVariantCflags["armv7-a-neon"]) |
| 213 | exportedVars.ExportStringListStaticVariable("ArmArmv8ACflags", armArchVariantCflags["armv8-a"]) |
| 214 | exportedVars.ExportStringListStaticVariable("ArmArmv82ACflags", armArchVariantCflags["armv8-2a"]) |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 215 | |
| 216 | // Clang cpu variant cflags |
Sam Delmerico | 7f88956 | 2022-03-25 14:55:40 +0000 | [diff] [blame] | 217 | exportedVars.ExportStringListStaticVariable("ArmGenericCflags", armCpuVariantCflags[""]) |
| 218 | exportedVars.ExportStringListStaticVariable("ArmCortexA7Cflags", armCpuVariantCflags["cortex-a7"]) |
| 219 | exportedVars.ExportStringListStaticVariable("ArmCortexA8Cflags", armCpuVariantCflags["cortex-a8"]) |
| 220 | exportedVars.ExportStringListStaticVariable("ArmCortexA15Cflags", armCpuVariantCflags["cortex-a15"]) |
Jesus Sanchez-Palencia | de7c784 | 2023-03-02 16:56:05 -0800 | [diff] [blame] | 221 | exportedVars.ExportStringListStaticVariable("ArmCortexA32Cflags", armCpuVariantCflags["cortex-a32"]) |
Sam Delmerico | 7f88956 | 2022-03-25 14:55:40 +0000 | [diff] [blame] | 222 | exportedVars.ExportStringListStaticVariable("ArmCortexA53Cflags", armCpuVariantCflags["cortex-a53"]) |
| 223 | exportedVars.ExportStringListStaticVariable("ArmCortexA55Cflags", armCpuVariantCflags["cortex-a55"]) |
| 224 | exportedVars.ExportStringListStaticVariable("ArmKraitCflags", armCpuVariantCflags["krait"]) |
| 225 | exportedVars.ExportStringListStaticVariable("ArmKryoCflags", armCpuVariantCflags["kryo"]) |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 226 | } |
| 227 | |
| 228 | var ( |
Colin Cross | 33bac24 | 2021-07-14 17:03:16 -0700 | [diff] [blame] | 229 | armArchVariantCflagsVar = map[string]string{ |
Colin Cross | 0523ba2 | 2021-07-14 18:45:05 -0700 | [diff] [blame] | 230 | "armv7-a": "${config.ArmArmv7ACflags}", |
| 231 | "armv7-a-neon": "${config.ArmArmv7ANeonCflags}", |
| 232 | "armv8-a": "${config.ArmArmv8ACflags}", |
| 233 | "armv8-2a": "${config.ArmArmv82ACflags}", |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 234 | } |
| 235 | |
Colin Cross | 33bac24 | 2021-07-14 17:03:16 -0700 | [diff] [blame] | 236 | armCpuVariantCflagsVar = map[string]string{ |
Colin Cross | 0523ba2 | 2021-07-14 18:45:05 -0700 | [diff] [blame] | 237 | "": "${config.ArmGenericCflags}", |
| 238 | "cortex-a7": "${config.ArmCortexA7Cflags}", |
| 239 | "cortex-a8": "${config.ArmCortexA8Cflags}", |
Wei Li | 0643c4e | 2022-11-09 16:52:10 -0800 | [diff] [blame] | 240 | "cortex-a9": "${config.ArmGenericCflags}", |
Colin Cross | 0523ba2 | 2021-07-14 18:45:05 -0700 | [diff] [blame] | 241 | "cortex-a15": "${config.ArmCortexA15Cflags}", |
Jesus Sanchez-Palencia | de7c784 | 2023-03-02 16:56:05 -0800 | [diff] [blame] | 242 | "cortex-a32": "${config.ArmCortexA32Cflags}", |
Colin Cross | 0523ba2 | 2021-07-14 18:45:05 -0700 | [diff] [blame] | 243 | "cortex-a53": "${config.ArmCortexA53Cflags}", |
| 244 | "cortex-a53.a57": "${config.ArmCortexA53Cflags}", |
| 245 | "cortex-a55": "${config.ArmCortexA55Cflags}", |
| 246 | "cortex-a72": "${config.ArmCortexA53Cflags}", |
| 247 | "cortex-a73": "${config.ArmCortexA53Cflags}", |
| 248 | "cortex-a75": "${config.ArmCortexA55Cflags}", |
| 249 | "cortex-a76": "${config.ArmCortexA55Cflags}", |
| 250 | "krait": "${config.ArmKraitCflags}", |
| 251 | "kryo": "${config.ArmKryoCflags}", |
| 252 | "kryo385": "${config.ArmCortexA53Cflags}", |
| 253 | "exynos-m1": "${config.ArmCortexA53Cflags}", |
| 254 | "exynos-m2": "${config.ArmCortexA53Cflags}", |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 255 | } |
| 256 | ) |
| 257 | |
| 258 | type toolchainArm struct { |
Colin Cross | e3fee34 | 2021-06-21 17:28:25 -0700 | [diff] [blame] | 259 | toolchainBionic |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 260 | toolchain32Bit |
Colin Cross | 33bac24 | 2021-07-14 17:03:16 -0700 | [diff] [blame] | 261 | ldflags string |
| 262 | lldflags string |
| 263 | toolchainCflags string |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 264 | } |
| 265 | |
Dan Albert | be96168 | 2015-03-18 23:38:50 -0700 | [diff] [blame] | 266 | func (t *toolchainArm) Name() string { |
Jingwen Chen | 51a1e1c | 2021-05-20 13:40:14 +0000 | [diff] [blame] | 267 | return name |
Dan Albert | be96168 | 2015-03-18 23:38:50 -0700 | [diff] [blame] | 268 | } |
| 269 | |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 270 | func (t *toolchainArm) IncludeFlags() string { |
Martin Stjernholm | 41ab251 | 2020-04-08 01:06:07 +0100 | [diff] [blame] | 271 | return "" |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 272 | } |
| 273 | |
| 274 | func (t *toolchainArm) ClangTriple() string { |
Chih-Hung Hsieh | 1e7d1bf | 2018-03-15 18:44:57 -0700 | [diff] [blame] | 275 | // http://b/72619014 work around llvm LTO bug. |
Jingwen Chen | 51a1e1c | 2021-05-20 13:40:14 +0000 | [diff] [blame] | 276 | return clangTriple |
Chih-Hung Hsieh | 1e7d1bf | 2018-03-15 18:44:57 -0700 | [diff] [blame] | 277 | } |
| 278 | |
| 279 | func (t *toolchainArm) ndkTriple() string { |
| 280 | // Use current NDK include path, while ClangTriple is changed. |
Colin Cross | 4fa894d | 2022-09-30 15:44:45 -0700 | [diff] [blame] | 281 | return ndkTriple |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 282 | } |
| 283 | |
Colin Cross | 33bac24 | 2021-07-14 17:03:16 -0700 | [diff] [blame] | 284 | func (t *toolchainArm) ToolchainCflags() string { |
| 285 | return t.toolchainCflags |
Colin Cross | c4bde76 | 2015-11-23 16:11:30 -0800 | [diff] [blame] | 286 | } |
| 287 | |
Colin Cross | 33bac24 | 2021-07-14 17:03:16 -0700 | [diff] [blame] | 288 | func (t *toolchainArm) Cflags() string { |
Colin Cross | 0523ba2 | 2021-07-14 18:45:05 -0700 | [diff] [blame] | 289 | return "${config.ArmCflags}" |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 290 | } |
| 291 | |
Colin Cross | 33bac24 | 2021-07-14 17:03:16 -0700 | [diff] [blame] | 292 | func (t *toolchainArm) Cppflags() string { |
Colin Cross | 0523ba2 | 2021-07-14 18:45:05 -0700 | [diff] [blame] | 293 | return "${config.ArmCppflags}" |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 294 | } |
| 295 | |
Colin Cross | 33bac24 | 2021-07-14 17:03:16 -0700 | [diff] [blame] | 296 | func (t *toolchainArm) Ldflags() string { |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 297 | return t.ldflags |
| 298 | } |
| 299 | |
Colin Cross | 33bac24 | 2021-07-14 17:03:16 -0700 | [diff] [blame] | 300 | func (t *toolchainArm) Lldflags() string { |
Chih-Hung Hsieh | 02b4da5 | 2018-04-03 11:33:34 -0700 | [diff] [blame] | 301 | return t.lldflags // TODO: handle V8 cases |
| 302 | } |
| 303 | |
Colin Cross | 33bac24 | 2021-07-14 17:03:16 -0700 | [diff] [blame] | 304 | func (t *toolchainArm) InstructionSetFlags(isa string) (string, error) { |
Dan Willemsen | 6d11dd8 | 2015-11-03 14:27:00 -0800 | [diff] [blame] | 305 | switch isa { |
| 306 | case "arm": |
Colin Cross | 0523ba2 | 2021-07-14 18:45:05 -0700 | [diff] [blame] | 307 | return "${config.ArmArmCflags}", nil |
Dan Willemsen | 6d11dd8 | 2015-11-03 14:27:00 -0800 | [diff] [blame] | 308 | case "thumb", "": |
Colin Cross | 0523ba2 | 2021-07-14 18:45:05 -0700 | [diff] [blame] | 309 | return "${config.ArmThumbCflags}", nil |
Dan Willemsen | 6d11dd8 | 2015-11-03 14:27:00 -0800 | [diff] [blame] | 310 | default: |
Colin Cross | 33bac24 | 2021-07-14 17:03:16 -0700 | [diff] [blame] | 311 | return t.toolchainBase.InstructionSetFlags(isa) |
Dan Willemsen | 6d11dd8 | 2015-11-03 14:27:00 -0800 | [diff] [blame] | 312 | } |
| 313 | } |
| 314 | |
Yi Kong | 924adc4 | 2018-08-31 14:27:44 -0700 | [diff] [blame] | 315 | func (toolchainArm) LibclangRuntimeLibraryArch() string { |
Jingwen Chen | 51a1e1c | 2021-05-20 13:40:14 +0000 | [diff] [blame] | 316 | return name |
Colin Cross | 16b2349 | 2016-01-06 14:41:07 -0800 | [diff] [blame] | 317 | } |
| 318 | |
Colin Cross | 635c3b0 | 2016-05-18 15:37:25 -0700 | [diff] [blame] | 319 | func armToolchainFactory(arch android.Arch) Toolchain { |
Colin Cross | c1e814d | 2015-04-28 13:15:59 -0700 | [diff] [blame] | 320 | var fixCortexA8 string |
Colin Cross | 33bac24 | 2021-07-14 17:03:16 -0700 | [diff] [blame] | 321 | toolchainCflags := make([]string, 2, 3) |
Dan Willemsen | 110a89d | 2016-01-14 15:17:19 -0800 | [diff] [blame] | 322 | |
Colin Cross | 0523ba2 | 2021-07-14 18:45:05 -0700 | [diff] [blame] | 323 | toolchainCflags[0] = "${config.ArmToolchainCflags}" |
Colin Cross | 33bac24 | 2021-07-14 17:03:16 -0700 | [diff] [blame] | 324 | toolchainCflags[1] = armArchVariantCflagsVar[arch.ArchVariant] |
Dan Willemsen | 110a89d | 2016-01-14 15:17:19 -0800 | [diff] [blame] | 325 | |
Colin Cross | 33bac24 | 2021-07-14 17:03:16 -0700 | [diff] [blame] | 326 | toolchainCflags = append(toolchainCflags, |
| 327 | variantOrDefault(armCpuVariantCflagsVar, arch.CpuVariant)) |
Isaac Chen | a2a5824 | 2017-08-23 10:57:17 +0000 | [diff] [blame] | 328 | |
Dan Willemsen | 110a89d | 2016-01-14 15:17:19 -0800 | [diff] [blame] | 329 | switch arch.ArchVariant { |
| 330 | case "armv7-a-neon": |
| 331 | switch arch.CpuVariant { |
| 332 | case "cortex-a8", "": |
| 333 | // Generic ARM might be a Cortex A8 -- better safe than sorry |
Liz Kammer | e8303bd | 2022-02-16 09:02:48 -0500 | [diff] [blame] | 334 | fixCortexA8 = "${config.ArmFixCortexA8LdFlags}" |
Dan Willemsen | 110a89d | 2016-01-14 15:17:19 -0800 | [diff] [blame] | 335 | default: |
Liz Kammer | e8303bd | 2022-02-16 09:02:48 -0500 | [diff] [blame] | 336 | fixCortexA8 = "${config.ArmNoFixCortexA8LdFlags}" |
Dan Willemsen | 110a89d | 2016-01-14 15:17:19 -0800 | [diff] [blame] | 337 | } |
Dan Albert | 8818f49 | 2019-02-19 13:53:01 -0800 | [diff] [blame] | 338 | case "armv7-a": |
Liz Kammer | e8303bd | 2022-02-16 09:02:48 -0500 | [diff] [blame] | 339 | fixCortexA8 = "${config.ArmFixCortexA8LdFlags}" |
mtk15504 | 270ba75 | 2018-10-31 15:26:32 +0800 | [diff] [blame] | 340 | case "armv8-a", "armv8-2a": |
| 341 | // Nothing extra for armv8-a/armv8-2a |
Colin Cross | c1e814d | 2015-04-28 13:15:59 -0700 | [diff] [blame] | 342 | default: |
Dan Willemsen | 110a89d | 2016-01-14 15:17:19 -0800 | [diff] [blame] | 343 | panic(fmt.Sprintf("Unknown ARM architecture version: %q", arch.ArchVariant)) |
Colin Cross | c1e814d | 2015-04-28 13:15:59 -0700 | [diff] [blame] | 344 | } |
| 345 | |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 346 | return &toolchainArm{ |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 347 | ldflags: strings.Join([]string{ |
Colin Cross | b98c8b0 | 2016-07-29 13:44:28 -0700 | [diff] [blame] | 348 | "${config.ArmLdflags}", |
Colin Cross | c1e814d | 2015-04-28 13:15:59 -0700 | [diff] [blame] | 349 | fixCortexA8, |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 350 | }, " "), |
Colin Cross | 33bac24 | 2021-07-14 17:03:16 -0700 | [diff] [blame] | 351 | lldflags: "${config.ArmLldflags}", |
| 352 | toolchainCflags: strings.Join(toolchainCflags, " "), |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 353 | } |
| 354 | } |
| 355 | |
| 356 | func init() { |
Colin Cross | a1ad8d1 | 2016-06-01 17:09:44 -0700 | [diff] [blame] | 357 | registerToolchainFactory(android.Android, android.Arm, armToolchainFactory) |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 358 | } |