1 /* Native CPU detection for aarch64.
2 Copyright (C) 2015-2018 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
9 any later version.
10
11 GCC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
19
20 #define IN_TARGET_CODE 1
21
22 #include "config.h"
23 #define INCLUDE_STRING
24 #include "system.h"
25 #include "coretypes.h"
26 #include "tm.h"
27
28 /* Defined in common/config/aarch64/aarch64-common.c. */
29 std::string aarch64_get_extension_string_for_isa_flags (unsigned long,
30 unsigned long);
31
32 struct aarch64_arch_extension
33 {
34 const char *ext;
35 unsigned int flag;
36 const char *feat_string;
37 };
38
39 #define AARCH64_OPT_EXTENSION(EXT_NAME, FLAG_CANONICAL, FLAGS_ON, FLAGS_OFF, FEATURE_STRING) \
40 { EXT_NAME, FLAG_CANONICAL, FEATURE_STRING },
41 static struct aarch64_arch_extension aarch64_extensions[] =
42 {
43 #include "aarch64-option-extensions.def"
44 };
45
46
47 struct aarch64_core_data
48 {
49 const char* name;
50 const char* arch;
51 unsigned char implementer_id; /* Exactly 8 bits */
52 unsigned int part_no; /* 12 bits + 12 bits */
53 unsigned variant;
54 const unsigned long flags;
55 };
56
57 #define AARCH64_BIG_LITTLE(BIG, LITTLE) \
58 (((BIG)&0xFFFu) << 12 | ((LITTLE) & 0xFFFu))
59 #define INVALID_IMP ((unsigned char) -1)
60 #define INVALID_CORE ((unsigned)-1)
61 #define ALL_VARIANTS ((unsigned)-1)
62
63 #define AARCH64_CORE(CORE_NAME, CORE_IDENT, SCHED, ARCH, FLAGS, COSTS, IMP, PART, VARIANT) \
64 { CORE_NAME, #ARCH, IMP, PART, VARIANT, FLAGS },
65
66 static struct aarch64_core_data aarch64_cpu_data[] =
67 {
68 #include "aarch64-cores.def"
69 { NULL, NULL, INVALID_IMP, INVALID_CORE, ALL_VARIANTS, 0 }
70 };
71
72
73 struct aarch64_arch_driver_info
74 {
75 const char* id;
76 const char* name;
77 const unsigned long flags;
78 };
79
80 #define AARCH64_ARCH(NAME, CORE, ARCH_IDENT, ARCH_REV, FLAGS) \
81 { #ARCH_IDENT, NAME, FLAGS },
82
83 static struct aarch64_arch_driver_info aarch64_arches[] =
84 {
85 #include "aarch64-arches.def"
86 {NULL, NULL, 0}
87 };
88
89
90 /* Return an aarch64_arch_driver_info for the architecture described
91 by ID, or NULL if ID describes something we don't know about. */
92
93 static struct aarch64_arch_driver_info*
get_arch_from_id(const char * id)94 get_arch_from_id (const char* id)
95 {
96 unsigned int i = 0;
97
98 for (i = 0; aarch64_arches[i].id != NULL; i++)
99 {
100 if (strcmp (id, aarch64_arches[i].id) == 0)
101 return &aarch64_arches[i];
102 }
103
104 return NULL;
105 }
106
107 /* Check wether the CORE array is the same as the big.LITTLE BL_CORE.
108 For an example CORE={0xd08, 0xd03} and
109 BL_CORE=AARCH64_BIG_LITTLE (0xd08, 0xd03) will return true. */
110
111 static bool
valid_bL_core_p(unsigned int * core,unsigned int bL_core)112 valid_bL_core_p (unsigned int *core, unsigned int bL_core)
113 {
114 return AARCH64_BIG_LITTLE (core[0], core[1]) == bL_core
115 || AARCH64_BIG_LITTLE (core[1], core[0]) == bL_core;
116 }
117
118 /* Returns the hex integer that is after ':' for the FIELD.
119 Returns -1 is returned if there was problem parsing the integer. */
120 static unsigned
parse_field(const char * field)121 parse_field (const char *field)
122 {
123 const char *rest = strchr (field, ':');
124 char *after;
125 unsigned fint = strtol (rest + 1, &after, 16);
126 if (after == rest + 1)
127 return -1;
128 return fint;
129 }
130
131 /* Return true iff ARR contains CORE, in either of the two elements. */
132
133 static bool
contains_core_p(unsigned * arr,unsigned core)134 contains_core_p (unsigned *arr, unsigned core)
135 {
136 if (arr[0] != INVALID_CORE)
137 {
138 if (arr[0] == core)
139 return true;
140
141 if (arr[1] != INVALID_CORE)
142 return arr[1] == core;
143 }
144
145 return false;
146 }
147
148 /* This will be called by the spec parser in gcc.c when it sees
149 a %:local_cpu_detect(args) construct. Currently it will be called
150 with either "arch", "cpu" or "tune" as argument depending on if
151 -march=native, -mcpu=native or -mtune=native is to be substituted.
152
153 It returns a string containing new command line parameters to be
154 put at the place of the above two options, depending on what CPU
155 this is executed. E.g. "-march=armv8-a" on a Cortex-A57 for
156 -march=native. If the routine can't detect a known processor,
157 the -march or -mtune option is discarded.
158
159 For -mtune and -mcpu arguments it attempts to detect the CPU or
160 a big.LITTLE system.
161 ARGC and ARGV are set depending on the actual arguments given
162 in the spec. */
163
164 const char *
host_detect_local_cpu(int argc,const char ** argv)165 host_detect_local_cpu (int argc, const char **argv)
166 {
167 const char *res = NULL;
168 static const int num_exts = ARRAY_SIZE (aarch64_extensions);
169 char buf[128];
170 FILE *f = NULL;
171 bool arch = false;
172 bool tune = false;
173 bool cpu = false;
174 unsigned int i = 0;
175 unsigned char imp = INVALID_IMP;
176 unsigned int cores[2] = { INVALID_CORE, INVALID_CORE };
177 unsigned int n_cores = 0;
178 unsigned int variants[2] = { ALL_VARIANTS, ALL_VARIANTS };
179 unsigned int n_variants = 0;
180 bool processed_exts = false;
181 const char *ext_string = "";
182 unsigned long extension_flags = 0;
183 unsigned long default_flags = 0;
184
185 gcc_assert (argc);
186
187 if (!argv[0])
188 goto not_found;
189
190 /* Are we processing -march, mtune or mcpu? */
191 arch = strcmp (argv[0], "arch") == 0;
192 if (!arch)
193 tune = strcmp (argv[0], "tune") == 0;
194
195 if (!arch && !tune)
196 cpu = strcmp (argv[0], "cpu") == 0;
197
198 if (!arch && !tune && !cpu)
199 goto not_found;
200
201 f = fopen ("/proc/cpuinfo", "r");
202
203 if (f == NULL)
204 goto not_found;
205
206 /* Look through /proc/cpuinfo to determine the implementer
207 and then the part number that identifies a particular core. */
208 while (fgets (buf, sizeof (buf), f) != NULL)
209 {
210 if (strstr (buf, "implementer") != NULL)
211 {
212 unsigned cimp = parse_field (buf);
213 if (cimp == INVALID_IMP)
214 goto not_found;
215
216 if (imp == INVALID_IMP)
217 imp = cimp;
218 /* FIXME: BIG.little implementers are always equal. */
219 else if (imp != cimp)
220 goto not_found;
221 }
222
223 if (strstr (buf, "variant") != NULL)
224 {
225 unsigned cvariant = parse_field (buf);
226 if (!contains_core_p (variants, cvariant))
227 {
228 if (n_variants == 2)
229 goto not_found;
230
231 variants[n_variants++] = cvariant;
232 }
233 continue;
234 }
235
236 if (strstr (buf, "part") != NULL)
237 {
238 unsigned ccore = parse_field (buf);
239 if (!contains_core_p (cores, ccore))
240 {
241 if (n_cores == 2)
242 goto not_found;
243
244 cores[n_cores++] = ccore;
245 }
246 continue;
247 }
248 if (!tune && !processed_exts && strstr (buf, "Features") != NULL)
249 {
250 for (i = 0; i < num_exts; i++)
251 {
252 char *p = NULL;
253 char *feat_string
254 = concat (aarch64_extensions[i].feat_string, NULL);
255 bool enabled = true;
256
257 /* This may be a multi-token feature string. We need
258 to match all parts, which could be in any order.
259 If this isn't a multi-token feature string, strtok is
260 just going to return a pointer to feat_string. */
261 p = strtok (feat_string, " ");
262 while (p != NULL)
263 {
264 if (strstr (buf, p) == NULL)
265 {
266 /* Failed to match this token. Turn off the
267 features we'd otherwise enable. */
268 enabled = false;
269 break;
270 }
271 p = strtok (NULL, " ");
272 }
273
274 if (enabled)
275 extension_flags |= aarch64_extensions[i].flag;
276 else
277 extension_flags &= ~(aarch64_extensions[i].flag);
278 }
279
280 processed_exts = true;
281 }
282 }
283
284 fclose (f);
285 f = NULL;
286
287 /* Weird cpuinfo format that we don't know how to handle. */
288 if (n_cores == 0
289 || n_cores > 2
290 || (n_cores == 1 && n_variants != 1)
291 || imp == INVALID_IMP)
292 goto not_found;
293
294 /* Simple case, one core type or just looking for the arch. */
295 if (n_cores == 1 || arch)
296 {
297 /* Search for one of the cores in the list. */
298 for (i = 0; aarch64_cpu_data[i].name != NULL; i++)
299 if (aarch64_cpu_data[i].implementer_id == imp
300 && cores[0] == aarch64_cpu_data[i].part_no
301 && (aarch64_cpu_data[i].variant == ALL_VARIANTS
302 || variants[0] == aarch64_cpu_data[i].variant))
303 break;
304 if (aarch64_cpu_data[i].name == NULL)
305 goto not_found;
306
307 if (arch)
308 {
309 const char *arch_id = aarch64_cpu_data[i].arch;
310 aarch64_arch_driver_info* arch_info = get_arch_from_id (arch_id);
311
312 /* We got some arch indentifier that's not in aarch64-arches.def? */
313 if (!arch_info)
314 goto not_found;
315
316 res = concat ("-march=", arch_info->name, NULL);
317 default_flags = arch_info->flags;
318 }
319 else
320 {
321 default_flags = aarch64_cpu_data[i].flags;
322 res = concat ("-m",
323 cpu ? "cpu" : "tune", "=",
324 aarch64_cpu_data[i].name,
325 NULL);
326 }
327 }
328 /* We have big.LITTLE. */
329 else
330 {
331 for (i = 0; aarch64_cpu_data[i].name != NULL; i++)
332 {
333 if (aarch64_cpu_data[i].implementer_id == imp
334 && valid_bL_core_p (cores, aarch64_cpu_data[i].part_no))
335 {
336 res = concat ("-m",
337 cpu ? "cpu" : "tune", "=",
338 aarch64_cpu_data[i].name,
339 NULL);
340 default_flags = aarch64_cpu_data[i].flags;
341 break;
342 }
343 }
344 if (!res)
345 goto not_found;
346 }
347
348 if (tune)
349 return res;
350
351 ext_string
352 = aarch64_get_extension_string_for_isa_flags (extension_flags,
353 default_flags).c_str ();
354
355 res = concat (res, ext_string, NULL);
356
357 return res;
358
359 not_found:
360 {
361 /* If detection fails we ignore the option.
362 Clean up and return empty string. */
363
364 if (f)
365 fclose (f);
366
367 return "";
368 }
369 }
370
371