arm_device.go 8.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320
  1. package cc
  2. import (
  3. "fmt"
  4. "strings"
  5. "android/soong/common"
  6. )
  7. var (
  8. armCflags = []string{
  9. "-fno-exceptions", // from build/core/combo/select.mk
  10. "-Wno-multichar", // from build/core/combo/select.mk
  11. "-msoft-float",
  12. "-ffunction-sections",
  13. "-fdata-sections",
  14. "-funwind-tables",
  15. "-fstack-protector",
  16. "-Wa,--noexecstack",
  17. "-Werror=format-security",
  18. "-D_FORTIFY_SOURCE=2",
  19. "-fno-short-enums",
  20. "-no-canonical-prefixes",
  21. "-fno-canonical-system-headers",
  22. "-fno-builtin-sin",
  23. "-fno-strict-volatile-bitfields",
  24. "-mthumb-interwork",
  25. // TARGET_RELEASE_CFLAGS
  26. "-DNDEBUG",
  27. "-g",
  28. "-Wstrict-aliasing=2",
  29. "-fgcse-after-reload",
  30. "-frerun-cse-after-loop",
  31. "-frename-registers",
  32. }
  33. armCppflags = []string{
  34. "-fvisibility-inlines-hidden",
  35. }
  36. armLdflags = []string{
  37. "-Wl,-z,noexecstack",
  38. "-Wl,-z,relro",
  39. "-Wl,-z,now",
  40. "-Wl,--build-id=md5",
  41. "-Wl,--warn-shared-textrel",
  42. "-Wl,--fatal-warnings",
  43. "-Wl,--icf=safe",
  44. "-Wl,--hash-style=gnu",
  45. }
  46. armArmCflags = []string{
  47. "-O2",
  48. "-fomit-frame-pointer",
  49. "-fstrict-aliasing",
  50. "-funswitch-loops",
  51. }
  52. armThumbCflags = []string{
  53. "-mthumb",
  54. "-Os",
  55. "-fomit-frame-pointer",
  56. "-fno-strict-aliasing",
  57. }
  58. armArchVariantCflags = map[string][]string{
  59. "armv5te": []string{
  60. "-march=armv5te",
  61. "-mtune=xscale",
  62. "-D__ARM_ARCH_5__",
  63. "-D__ARM_ARCH_5T__",
  64. "-D__ARM_ARCH_5E__",
  65. "-D__ARM_ARCH_5TE__",
  66. },
  67. "armv7-a": []string{
  68. "-march=armv7-a",
  69. "-mfloat-abi=softfp",
  70. "-mfpu=vfpv3-d16",
  71. },
  72. "armv7-a-neon": []string{
  73. "-mfloat-abi=softfp",
  74. "-mfpu=neon",
  75. },
  76. }
  77. armCpuVariantCflags = map[string][]string{
  78. "cortex-a7": []string{
  79. "-mcpu=cortex-a7",
  80. },
  81. "cortex-a8": []string{
  82. "-mcpu=cortex-a8",
  83. },
  84. "cortex-a15": []string{
  85. "-mcpu=cortex-a15",
  86. // Fake an ARM compiler flag as these processors support LPAE which GCC/clang
  87. // don't advertise.
  88. "-D__ARM_FEATURE_LPAE=1",
  89. },
  90. }
  91. armClangCpuVariantCflags = copyVariantFlags(armCpuVariantCflags)
  92. armClangArchVariantCflags = copyVariantFlags(armArchVariantCflags)
  93. )
  94. func copyVariantFlags(m map[string][]string) map[string][]string {
  95. ret := make(map[string][]string, len(m))
  96. for k, v := range m {
  97. l := make([]string, len(m[k]))
  98. for i := range m[k] {
  99. l[i] = v[i]
  100. }
  101. ret[k] = l
  102. }
  103. return ret
  104. }
  105. func init() {
  106. replaceFirst := func(slice []string, from, to string) {
  107. if slice[0] != from {
  108. panic(fmt.Errorf("Expected %q, found %q", from, to))
  109. }
  110. slice[0] = to
  111. }
  112. replaceFirst(armClangArchVariantCflags["armv5te"], "-march=armv5te", "-march=armv5t")
  113. armClangCpuVariantCflags["krait"] = []string{
  114. "-mcpu=krait",
  115. "-mfpu=neon-vfpv4",
  116. }
  117. pctx.StaticVariable("armGccVersion", "4.9")
  118. pctx.StaticVariable("armGccRoot",
  119. "prebuilts/gcc/${HostPrebuiltTag}/arm/arm-linux-androideabi-${armGccVersion}")
  120. pctx.StaticVariable("armGccTriple", "arm-linux-androideabi")
  121. pctx.StaticVariable("armCflags", strings.Join(armCflags, " "))
  122. pctx.StaticVariable("armLdflags", strings.Join(armLdflags, " "))
  123. pctx.StaticVariable("armCppflags", strings.Join(armCppflags, " "))
  124. pctx.StaticVariable("armIncludeFlags", strings.Join([]string{
  125. "-isystem ${LibcRoot}/arch-arm/include",
  126. "-isystem ${LibcRoot}/include",
  127. "-isystem ${LibcRoot}/kernel/uapi",
  128. "-isystem ${LibcRoot}/kernel/uapi/asm-arm",
  129. "-isystem ${LibmRoot}/include",
  130. "-isystem ${LibmRoot}/include/arm",
  131. }, " "))
  132. // Extended cflags
  133. // ARM vs. Thumb instruction set flags
  134. pctx.StaticVariable("armArmCflags", strings.Join(armArmCflags, " "))
  135. pctx.StaticVariable("armThumbCflags", strings.Join(armThumbCflags, " "))
  136. // Architecture variant cflags
  137. pctx.StaticVariable("armArmv5TECflags", strings.Join(armArchVariantCflags["armv5te"], " "))
  138. pctx.StaticVariable("armArmv7ACflags", strings.Join(armArchVariantCflags["armv7-a"], " "))
  139. pctx.StaticVariable("armArmv7ANeonCflags", strings.Join(armArchVariantCflags["armv7-a-neon"], " "))
  140. // Cpu variant cflags
  141. pctx.StaticVariable("armCortexA7Cflags", strings.Join(armCpuVariantCflags["cortex-a7"], " "))
  142. pctx.StaticVariable("armCortexA8Cflags", strings.Join(armCpuVariantCflags["cortex-a8"], " "))
  143. pctx.StaticVariable("armCortexA15Cflags", strings.Join(armCpuVariantCflags["cortex-a15"], " "))
  144. // Clang cflags
  145. pctx.StaticVariable("armClangCflags", strings.Join(clangFilterUnknownCflags(armCflags), " "))
  146. pctx.StaticVariable("armClangLdflags", strings.Join(clangFilterUnknownCflags(armLdflags), " "))
  147. pctx.StaticVariable("armClangCppflags", strings.Join(clangFilterUnknownCflags(armCppflags), " "))
  148. // Clang cpu variant cflags
  149. pctx.StaticVariable("armClangArmv5TECflags",
  150. strings.Join(armClangArchVariantCflags["armv5te"], " "))
  151. pctx.StaticVariable("armClangArmv7ACflags",
  152. strings.Join(armClangArchVariantCflags["armv7-a"], " "))
  153. pctx.StaticVariable("armClangArmv7ANeonCflags",
  154. strings.Join(armClangArchVariantCflags["armv7-a-neon"], " "))
  155. // Clang cpu variant cflags
  156. pctx.StaticVariable("armClangCortexA7Cflags",
  157. strings.Join(armClangCpuVariantCflags["cortex-a7"], " "))
  158. pctx.StaticVariable("armClangCortexA8Cflags",
  159. strings.Join(armClangCpuVariantCflags["cortex-a8"], " "))
  160. pctx.StaticVariable("armClangCortexA15Cflags",
  161. strings.Join(armClangCpuVariantCflags["cortex-a15"], " "))
  162. pctx.StaticVariable("armClangKraitCflags",
  163. strings.Join(armClangCpuVariantCflags["krait"], " "))
  164. }
  165. var (
  166. armArchVariantCflagsVar = map[string]string{
  167. "armv5te": "${armArmv5TECflags}",
  168. "armv7-a": "${armArmv7ACflags}",
  169. "armv7-a-neon": "${armArmv7ANeonCflags}",
  170. }
  171. armCpuVariantCflagsVar = map[string]string{
  172. "": "",
  173. "cortex-a7": "${armCortexA7Cflags}",
  174. "cortex-a8": "${armCortexA8Cflags}",
  175. "cortex-a15": "${armCortexA15Cflags}",
  176. "krait": "${armCortexA15Cflags}",
  177. "denver": "${armCortexA15Cflags}",
  178. }
  179. armClangArchVariantCflagsVar = map[string]string{
  180. "armv5te": "${armClangArmv5TECflags}",
  181. "armv7-a": "${armClangArmv7ACflags}",
  182. "armv7-a-neon": "${armClangArmv7ANeonCflags}",
  183. }
  184. armClangCpuVariantCflagsVar = map[string]string{
  185. "": "",
  186. "cortex-a7": "${armClangCortexA7Cflags}",
  187. "cortex-a8": "${armClangCortexA8Cflags}",
  188. "cortex-a15": "${armClangCortexA15Cflags}",
  189. "krait": "${armClangKraitCflags}",
  190. "denver": "${armClangCortexA15Cflags}",
  191. }
  192. )
  193. type toolchainArm struct {
  194. toolchain32Bit
  195. cflags, ldflags, clangCflags string
  196. }
  197. func (t *toolchainArm) Name() string {
  198. return "arm"
  199. }
  200. func (t *toolchainArm) GccRoot() string {
  201. return "${armGccRoot}"
  202. }
  203. func (t *toolchainArm) GccTriple() string {
  204. return "${armGccTriple}"
  205. }
  206. func (t *toolchainArm) GccVersion() string {
  207. return "${armGccVersion}"
  208. }
  209. func (t *toolchainArm) Cflags() string {
  210. return t.cflags
  211. }
  212. func (t *toolchainArm) Cppflags() string {
  213. return "${armCppflags}"
  214. }
  215. func (t *toolchainArm) Ldflags() string {
  216. return t.ldflags
  217. }
  218. func (t *toolchainArm) IncludeFlags() string {
  219. return "${armIncludeFlags}"
  220. }
  221. func (t *toolchainArm) InstructionSetFlags(isa string) (string, error) {
  222. switch isa {
  223. case "arm":
  224. return "${armArmCflags}", nil
  225. case "thumb", "":
  226. return "${armThumbCflags}", nil
  227. default:
  228. return t.toolchainBase.InstructionSetFlags(isa)
  229. }
  230. }
  231. func (t *toolchainArm) ClangTriple() string {
  232. return "${armGccTriple}"
  233. }
  234. func (t *toolchainArm) ClangCflags() string {
  235. return t.clangCflags
  236. }
  237. func (t *toolchainArm) ClangCppflags() string {
  238. return "${armClangCppflags}"
  239. }
  240. func (t *toolchainArm) ClangLdflags() string {
  241. return t.ldflags
  242. }
  243. func armToolchainFactory(archVariant string, cpuVariant string) Toolchain {
  244. var fixCortexA8 string
  245. switch cpuVariant {
  246. case "cortex-a8", "":
  247. // Generic ARM might be a Cortex A8 -- better safe than sorry
  248. fixCortexA8 = "-Wl,--fix-cortex-a8"
  249. default:
  250. fixCortexA8 = "-Wl,--no-fix-cortex-a8"
  251. }
  252. return &toolchainArm{
  253. cflags: strings.Join([]string{
  254. "${armCflags}",
  255. armArchVariantCflagsVar[archVariant],
  256. armCpuVariantCflagsVar[cpuVariant],
  257. }, " "),
  258. ldflags: strings.Join([]string{
  259. "${armLdflags}",
  260. fixCortexA8,
  261. }, " "),
  262. clangCflags: strings.Join([]string{
  263. "${armClangCflags}",
  264. armClangArchVariantCflagsVar[archVariant],
  265. armClangCpuVariantCflagsVar[cpuVariant],
  266. }, " "),
  267. }
  268. }
  269. func init() {
  270. registerToolchainFactory(common.Device, common.Arm, armToolchainFactory)
  271. }