• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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-2a": []string{
35			"-march=armv8.2a",
36		},
37	}
38
39	arm64Ldflags = []string{
40		"-Wl,-m,aarch64_elf64_le_vec",
41		"-Wl,--hash-style=gnu",
42		"-Wl,-z,separate-code",
43		"-fuse-ld=gold",
44		"-Wl,--icf=safe",
45	}
46
47	arm64Lldflags = append(ClangFilterUnknownLldflags(arm64Ldflags),
48		"-Wl,-z,max-page-size=4096")
49
50	arm64Cppflags = []string{}
51
52	arm64ClangCpuVariantCflags = map[string][]string{
53		"cortex-a53": []string{
54			"-mcpu=cortex-a53",
55		},
56		"cortex-a55": []string{
57			"-mcpu=cortex-a55",
58		},
59		"cortex-a75": []string{
60			// Use the cortex-a55 since it is similar to the little
61			// core (cortex-a55) and is sensitive to ordering.
62			"-mcpu=cortex-a55",
63		},
64		"cortex-a76": []string{
65			// Use the cortex-a55 since it is similar to the little
66			// core (cortex-a55) and is sensitive to ordering.
67			"-mcpu=cortex-a55",
68		},
69		"kryo": []string{
70			"-mcpu=kryo",
71		},
72		"kryo385": []string{
73			// Use cortex-a53 because kryo385 is not supported in GCC/clang.
74			"-mcpu=cortex-a53",
75		},
76		"exynos-m1": []string{
77			"-mcpu=exynos-m1",
78		},
79		"exynos-m2": []string{
80			"-mcpu=exynos-m2",
81		},
82	}
83)
84
85const (
86	arm64GccVersion = "4.9"
87)
88
89func init() {
90	pctx.StaticVariable("arm64GccVersion", arm64GccVersion)
91
92	pctx.SourcePathVariable("Arm64GccRoot",
93		"prebuilts/gcc/${HostPrebuiltTag}/aarch64/aarch64-linux-android-${arm64GccVersion}")
94
95	pctx.StaticVariable("Arm64Ldflags", strings.Join(arm64Ldflags, " "))
96	pctx.StaticVariable("Arm64Lldflags", strings.Join(arm64Lldflags, " "))
97	pctx.StaticVariable("Arm64IncludeFlags", bionicHeaders("arm64"))
98
99	pctx.StaticVariable("Arm64ClangCflags", strings.Join(ClangFilterUnknownCflags(arm64Cflags), " "))
100	pctx.StaticVariable("Arm64ClangLdflags", strings.Join(ClangFilterUnknownCflags(arm64Ldflags), " "))
101	pctx.StaticVariable("Arm64ClangLldflags", strings.Join(ClangFilterUnknownCflags(arm64Lldflags), " "))
102	pctx.StaticVariable("Arm64ClangCppflags", strings.Join(ClangFilterUnknownCflags(arm64Cppflags), " "))
103
104	pctx.StaticVariable("Arm64ClangArmv8ACflags", strings.Join(arm64ArchVariantCflags["armv8-a"], " "))
105	pctx.StaticVariable("Arm64ClangArmv82ACflags", strings.Join(arm64ArchVariantCflags["armv8-2a"], " "))
106
107	pctx.StaticVariable("Arm64ClangCortexA53Cflags",
108		strings.Join(arm64ClangCpuVariantCflags["cortex-a53"], " "))
109
110	pctx.StaticVariable("Arm64ClangCortexA55Cflags",
111		strings.Join(arm64ClangCpuVariantCflags["cortex-a55"], " "))
112
113	pctx.StaticVariable("Arm64ClangKryoCflags",
114		strings.Join(arm64ClangCpuVariantCflags["kryo"], " "))
115
116	pctx.StaticVariable("Arm64ClangExynosM1Cflags",
117		strings.Join(arm64ClangCpuVariantCflags["exynos-m1"], " "))
118
119	pctx.StaticVariable("Arm64ClangExynosM2Cflags",
120		strings.Join(arm64ClangCpuVariantCflags["exynos-m2"], " "))
121}
122
123var (
124	arm64ClangArchVariantCflagsVar = map[string]string{
125		"armv8-a":  "${config.Arm64ClangArmv8ACflags}",
126		"armv8-2a": "${config.Arm64ClangArmv82ACflags}",
127	}
128
129	arm64ClangCpuVariantCflagsVar = map[string]string{
130		"":           "",
131		"cortex-a53": "${config.Arm64ClangCortexA53Cflags}",
132		"cortex-a55": "${config.Arm64ClangCortexA55Cflags}",
133		"cortex-a72": "${config.Arm64ClangCortexA53Cflags}",
134		"cortex-a73": "${config.Arm64ClangCortexA53Cflags}",
135		"cortex-a75": "${config.Arm64ClangCortexA55Cflags}",
136		"cortex-a76": "${config.Arm64ClangCortexA55Cflags}",
137		"kryo":       "${config.Arm64ClangKryoCflags}",
138		"kryo385":    "${config.Arm64ClangCortexA53Cflags}",
139		"exynos-m1":  "${config.Arm64ClangExynosM1Cflags}",
140		"exynos-m2":  "${config.Arm64ClangExynosM2Cflags}",
141	}
142)
143
144type toolchainArm64 struct {
145	toolchain64Bit
146
147	ldflags              string
148	lldflags             string
149	toolchainClangCflags string
150}
151
152func (t *toolchainArm64) Name() string {
153	return "arm64"
154}
155
156func (t *toolchainArm64) GccRoot() string {
157	return "${config.Arm64GccRoot}"
158}
159
160func (t *toolchainArm64) GccTriple() string {
161	return "aarch64-linux-android"
162}
163
164func (t *toolchainArm64) GccVersion() string {
165	return arm64GccVersion
166}
167
168func (t *toolchainArm64) IncludeFlags() string {
169	return "${config.Arm64IncludeFlags}"
170}
171
172func (t *toolchainArm64) ClangTriple() string {
173	return t.GccTriple()
174}
175
176func (t *toolchainArm64) ClangCflags() string {
177	return "${config.Arm64ClangCflags}"
178}
179
180func (t *toolchainArm64) ClangCppflags() string {
181	return "${config.Arm64ClangCppflags}"
182}
183
184func (t *toolchainArm64) ClangLdflags() string {
185	return t.ldflags
186}
187
188func (t *toolchainArm64) ClangLldflags() string {
189	return t.lldflags
190}
191
192func (t *toolchainArm64) ToolchainClangCflags() string {
193	return t.toolchainClangCflags
194}
195
196func (toolchainArm64) LibclangRuntimeLibraryArch() string {
197	return "aarch64"
198}
199
200func arm64ToolchainFactory(arch android.Arch) Toolchain {
201	switch arch.ArchVariant {
202	case "armv8-a":
203	case "armv8-2a":
204		// Nothing extra for armv8-a/armv8-2a
205	default:
206		panic(fmt.Sprintf("Unknown ARM architecture version: %q", arch.ArchVariant))
207	}
208
209	toolchainClangCflags := []string{arm64ClangArchVariantCflagsVar[arch.ArchVariant]}
210	toolchainClangCflags = append(toolchainClangCflags,
211		variantOrDefault(arm64ClangCpuVariantCflagsVar, arch.CpuVariant))
212
213	var extraLdflags string
214	switch arch.CpuVariant {
215	case "cortex-a53", "cortex-a72", "cortex-a73", "kryo", "exynos-m1", "exynos-m2":
216		extraLdflags = "-Wl,--fix-cortex-a53-843419"
217	}
218
219	return &toolchainArm64{
220		ldflags: strings.Join([]string{
221			"${config.Arm64Ldflags}",
222			extraLdflags,
223		}, " "),
224		lldflags: strings.Join([]string{
225			"${config.Arm64Lldflags}",
226			extraLdflags,
227		}, " "),
228		toolchainClangCflags: strings.Join(toolchainClangCflags, " "),
229	}
230}
231
232func init() {
233	registerToolchainFactory(android.Android, android.Arm64, arm64ToolchainFactory)
234}
235