1/* Generate code to initialize optabs from machine description.
2 Copyright (C) 1993-2024 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.
10
11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3. If not see
18<http://www.gnu.org/licenses/>. */
19
20
21#include "bconfig.h"
22#include "system.h"
23#include "coretypes.h"
24#include "tm.h"
25#include "rtl.h"
26#include "errors.h"
27#include "gensupport.h"
28
29
30#define DEF_RTL_EXPR(V, N, X, C) #V,
31
32static const char * const rtx_upname[] = {
33#include "rtl.def"
34};
35
36#undef DEF_RTL_EXPR
37
38/* Vector in which to collect insns that match. */
39static vec<optab_pattern> patterns;
40
41static void
42gen_insn (md_rtx_info *info)
43{
44 optab_pattern p;
45 if (find_optab (&p, XSTR (info->def, 0)))
46 patterns.safe_push (obj: p);
47}
48
49static int
50pattern_cmp (const void *va, const void *vb)
51{
52 const optab_pattern *a = (const optab_pattern *)va;
53 const optab_pattern *b = (const optab_pattern *)vb;
54 return a->sort_num - b->sort_num;
55}
56
57static int
58optab_kind_cmp (const void *va, const void *vb)
59{
60 const optab_def *a = (const optab_def *)va;
61 const optab_def *b = (const optab_def *)vb;
62 int diff = a->kind - b->kind;
63 if (diff == 0)
64 diff = a->op - b->op;
65 return diff;
66}
67
68static int
69optab_rcode_cmp (const void *va, const void *vb)
70{
71 const optab_def *a = (const optab_def *)va;
72 const optab_def *b = (const optab_def *)vb;
73 return a->rcode - b->rcode;
74}
75
76static const char *header_file_name = "init-opinit.h";
77static const char *source_file_name = "init-opinit.c";
78
79static bool
80handle_arg (const char *arg)
81{
82 switch (arg[1])
83 {
84 case 'h':
85 header_file_name = &arg[2];
86 return true;
87 case 'c':
88 source_file_name = &arg[2];
89 return true;
90 default:
91 return false;
92 }
93}
94
95static FILE *
96open_outfile (const char *file_name)
97{
98 FILE *f = fopen (file_name, "w");
99 if (!f)
100 fatal ("cannot open file %s: %s", file_name, xstrerror (errno));
101 fprintf (stream: f,
102 format: "/* Generated automatically by the program `genopinit'\n"
103 " from the machine description file `md'. */\n\n");
104 return f;
105}
106
107/* Declare the maybe_code_for_* function for ONAME, and provide
108 an inline definition of the assserting code_for_* wrapper. */
109
110static void
111handle_overloaded_code_for (FILE *file, overloaded_name *oname)
112{
113 fprintf (stream: file, format: "\nextern insn_code maybe_code_for_%s (", oname->name);
114 for (unsigned int i = 0; i < oname->arg_types.length (); ++i)
115 fprintf (stream: file, format: "%s%s", i == 0 ? "" : ", ", oname->arg_types[i]);
116 fprintf (stream: file, format: ");\n");
117
118 fprintf (stream: file, format: "inline insn_code\ncode_for_%s (", oname->name);
119 for (unsigned int i = 0; i < oname->arg_types.length (); ++i)
120 fprintf (stream: file, format: "%s%s arg%d", i == 0 ? "" : ", ", oname->arg_types[i], i);
121 fprintf (stream: file, format: ")\n{\n insn_code code = maybe_code_for_%s (", oname->name);
122 for (unsigned int i = 0; i < oname->arg_types.length (); ++i)
123 fprintf (stream: file, format: "%sarg%d", i == 0 ? "" : ", ", i);
124 fprintf (stream: file,
125 format: ");\n"
126 " gcc_assert (code != CODE_FOR_nothing);\n"
127 " return code;\n"
128 "}\n");
129}
130
131/* Declare the maybe_gen_* function for ONAME, and provide
132 an inline definition of the assserting gen_* wrapper. */
133
134static void
135handle_overloaded_gen (FILE *file, overloaded_name *oname)
136{
137 unsigned HOST_WIDE_INT seen = 0;
138 for (overloaded_instance *instance = oname->first_instance->next;
139 instance; instance = instance->next)
140 {
141 pattern_stats stats;
142 get_pattern_stats (ranges: &stats, XVEC (instance->insn, 1));
143 unsigned HOST_WIDE_INT mask
144 = HOST_WIDE_INT_1U << stats.num_generator_args;
145 if (seen & mask)
146 continue;
147
148 seen |= mask;
149
150 fprintf (stream: file, format: "\nextern rtx maybe_gen_%s (", oname->name);
151 for (unsigned int i = 0; i < oname->arg_types.length (); ++i)
152 fprintf (stream: file, format: "%s%s", i == 0 ? "" : ", ", oname->arg_types[i]);
153 for (int i = 0; i < stats.num_generator_args; ++i)
154 fprintf (stream: file, format: ", rtx");
155 fprintf (stream: file, format: ");\n");
156
157 fprintf (stream: file, format: "inline rtx\ngen_%s (", oname->name);
158 for (unsigned int i = 0; i < oname->arg_types.length (); ++i)
159 fprintf (stream: file, format: "%s%s arg%d", i == 0 ? "" : ", ",
160 oname->arg_types[i], i);
161 for (int i = 0; i < stats.num_generator_args; ++i)
162 fprintf (stream: file, format: ", rtx x%d", i);
163 fprintf (stream: file, format: ")\n{\n rtx res = maybe_gen_%s (", oname->name);
164 for (unsigned int i = 0; i < oname->arg_types.length (); ++i)
165 fprintf (stream: file, format: "%sarg%d", i == 0 ? "" : ", ", i);
166 for (int i = 0; i < stats.num_generator_args; ++i)
167 fprintf (stream: file, format: ", x%d", i);
168 fprintf (stream: file,
169 format: ");\n"
170 " gcc_assert (res);\n"
171 " return res;\n"
172 "}\n");
173 }
174}
175
176int
177main (int argc, const char **argv)
178{
179 FILE *h_file, *s_file;
180 unsigned int i, j, n, last_kind[5];
181 optab_pattern *p;
182
183 progname = "genopinit";
184
185 if (NUM_OPTABS > 0xfff || NUM_MACHINE_MODES > 0x3ff)
186 fatal ("genopinit range assumptions invalid");
187
188 if (!init_rtx_reader_args_cb (argc, argv, handle_arg))
189 return (FATAL_EXIT_CODE);
190
191 h_file = open_outfile (file_name: header_file_name);
192 s_file = open_outfile (file_name: source_file_name);
193
194 /* Read the machine description. */
195 md_rtx_info info;
196 while (read_md_rtx (&info))
197 switch (GET_CODE (info.def))
198 {
199 case DEFINE_INSN:
200 case DEFINE_EXPAND:
201 gen_insn (info: &info);
202 break;
203
204 default:
205 break;
206 }
207
208 /* Sort the collected patterns. */
209 patterns.qsort (pattern_cmp);
210
211 /* Now that we've handled the "extra" patterns, eliminate them from
212 the optabs array. That way they don't get in the way below. */
213 n = num_optabs;
214 for (i = 0; i < n; )
215 if (optabs[i].base == NULL)
216 optabs[i] = optabs[--n];
217 else
218 ++i;
219
220 /* Sort the (real) optabs. Better than forcing the optabs.def file to
221 remain sorted by kind. We also scrogged any real ordering with the
222 purging of the X patterns above. */
223 qsort (optabs, n, sizeof (optab_def), optab_kind_cmp);
224
225 fprintf (stream: h_file, format: "#ifndef GCC_INSN_OPINIT_H\n");
226 fprintf (stream: h_file, format: "#define GCC_INSN_OPINIT_H 1\n");
227
228 /* Emit the optab enumeration for the header file. */
229 fprintf (stream: h_file, format: "enum optab_tag {\n");
230 for (i = j = 0; i < n; ++i)
231 {
232 optabs[i].op = i;
233 fprintf (stream: h_file, format: " %s,\n", optabs[i].name);
234 if (optabs[i].kind != j)
235 last_kind[j++] = i - 1;
236 }
237 fprintf (stream: h_file, format: " FIRST_CONV_OPTAB = %s,\n", optabs[last_kind[0]+1].name);
238 fprintf (stream: h_file, format: " LAST_CONVLIB_OPTAB = %s,\n", optabs[last_kind[1]].name);
239 fprintf (stream: h_file, format: " LAST_CONV_OPTAB = %s,\n", optabs[last_kind[2]].name);
240 fprintf (stream: h_file, format: " FIRST_NORM_OPTAB = %s,\n", optabs[last_kind[2]+1].name);
241 fprintf (stream: h_file, format: " LAST_NORMLIB_OPTAB = %s,\n", optabs[last_kind[3]].name);
242 fprintf (stream: h_file, format: " LAST_NORM_OPTAB = %s\n", optabs[i-1].name);
243 fprintf (stream: h_file, format: "};\n\n");
244
245 fprintf (stream: h_file, format: "#define NUM_OPTABS %u\n", n);
246 fprintf (stream: h_file, format: "#define NUM_CONVLIB_OPTABS %u\n",
247 last_kind[1] - last_kind[0]);
248 fprintf (stream: h_file, format: "#define NUM_NORMLIB_OPTABS %u\n",
249 last_kind[3] - last_kind[2]);
250 fprintf (stream: h_file, format: "#define NUM_OPTAB_PATTERNS %u\n",
251 (unsigned) patterns.length ());
252
253 fprintf (stream: h_file,
254 format: "typedef enum optab_tag optab;\n"
255 "typedef enum optab_tag convert_optab;\n"
256 "typedef enum optab_tag direct_optab;\n"
257 "\n"
258 "struct optab_libcall_d\n"
259 "{\n"
260 " char libcall_suffix;\n"
261 " const char *libcall_basename;\n"
262 " void (*libcall_gen) (optab, const char *name,\n"
263 " char suffix, machine_mode);\n"
264 "};\n"
265 "\n"
266 "struct convert_optab_libcall_d\n"
267 "{\n"
268 " const char *libcall_basename;\n"
269 " void (*libcall_gen) (convert_optab, const char *name,\n"
270 " machine_mode, machine_mode);\n"
271 "};\n"
272 "\n"
273 "/* Given an enum insn_code, access the function to construct\n"
274 " the body of that kind of insn. */\n"
275 "#define GEN_FCN(CODE) (insn_data[CODE].genfun)\n"
276 "\n"
277 "#ifdef NUM_RTX_CODE\n"
278 "/* Contains the optab used for each rtx code, and vice-versa. */\n"
279 "extern const optab code_to_optab_[NUM_RTX_CODE];\n"
280 "extern const enum rtx_code optab_to_code_[NUM_OPTABS];\n"
281 "\n"
282 "static inline optab\n"
283 "code_to_optab (enum rtx_code code)\n"
284 "{\n"
285 " return code_to_optab_[code];\n"
286 "}\n"
287 "\n"
288 "static inline enum rtx_code\n"
289 "optab_to_code (optab op)\n"
290 "{\n"
291 " return optab_to_code_[op];\n"
292 "}\n");
293
294 for (overloaded_name *oname = rtx_reader_ptr->get_overloads ();
295 oname; oname = oname->next)
296 {
297 handle_overloaded_code_for (file: h_file, oname);
298 handle_overloaded_gen (file: h_file, oname);
299 }
300
301 fprintf (stream: h_file,
302 format: "#endif\n"
303 "\n"
304 "extern const struct convert_optab_libcall_d convlib_def[NUM_CONVLIB_OPTABS];\n"
305 "extern const struct optab_libcall_d normlib_def[NUM_NORMLIB_OPTABS];\n"
306 "\n"
307 "/* Returns the active icode for the given (encoded) optab. */\n"
308 "extern enum insn_code raw_optab_handler (unsigned);\n"
309 "extern bool swap_optab_enable (optab, machine_mode, bool);\n"
310 "\n"
311 "/* Target-dependent globals. */\n"
312 "struct target_optabs {\n"
313 " /* Patterns that are used by optabs that are enabled for this target. */\n"
314 " bool pat_enable[NUM_OPTAB_PATTERNS];\n"
315 "\n"
316 " /* Index VOIDmode caches if the target supports vec_gather_load for any\n"
317 " vector mode. Every other index X caches specifically for mode X.\n"
318 " 1 means yes, -1 means no. */\n"
319 " signed char supports_vec_gather_load[NUM_MACHINE_MODES];\n"
320 " signed char supports_vec_scatter_store[NUM_MACHINE_MODES];\n"
321 "};\n"
322 "extern void init_all_optabs (struct target_optabs *);\n"
323 "extern bool partial_vectors_supported_p (void);\n"
324 "\n"
325 "extern struct target_optabs default_target_optabs;\n"
326 "extern struct target_optabs *this_fn_optabs;\n"
327 "#if SWITCHABLE_TARGET\n"
328 "extern struct target_optabs *this_target_optabs;\n"
329 "#else\n"
330 "#define this_target_optabs (&default_target_optabs)\n"
331 "#endif\n");
332
333 fprintf (stream: s_file,
334 format: "#define IN_TARGET_CODE 1\n"
335 "#include \"config.h\"\n"
336 "#include \"system.h\"\n"
337 "#include \"coretypes.h\"\n"
338 "#include \"backend.h\"\n"
339 "#include \"predict.h\"\n"
340 "#include \"tree.h\"\n"
341 "#include \"rtl.h\"\n"
342 "#include \"alias.h\"\n"
343 "#include \"varasm.h\"\n"
344 "#include \"stor-layout.h\"\n"
345 "#include \"calls.h\"\n"
346 "#include \"memmodel.h\"\n"
347 "#include \"tm_p.h\"\n"
348 "#include \"flags.h\"\n"
349 "#include \"insn-config.h\"\n"
350 "#include \"expmed.h\"\n"
351 "#include \"dojump.h\"\n"
352 "#include \"explow.h\"\n"
353 "#include \"emit-rtl.h\"\n"
354 "#include \"stmt.h\"\n"
355 "#include \"expr.h\"\n"
356 "#include \"insn-codes.h\"\n"
357 "#include \"optabs.h\"\n"
358 "\n"
359 "struct optab_pat {\n"
360 " unsigned scode;\n"
361 " enum insn_code icode;\n"
362 "};\n\n");
363
364 fprintf (stream: s_file,
365 format: "static const struct optab_pat pats[NUM_OPTAB_PATTERNS] = {\n");
366 for (i = 0; patterns.iterate (ix: i, ptr: &p); ++i)
367 fprintf (stream: s_file, format: " { %#08x, CODE_FOR_%s },\n", p->sort_num, p->name);
368 fprintf (stream: s_file, format: "};\n\n");
369
370 /* Some targets like riscv have a large number of patterns. In order to
371 prevent pathological situations in dataflow analysis split the init
372 function into separate ones that initialize 1000 patterns each. */
373
374 const int patterns_per_function = 1000;
375
376 if (patterns.length () > patterns_per_function)
377 {
378 unsigned num_init_functions
379 = patterns.length () / patterns_per_function + 1;
380 for (i = 0; i < num_init_functions; i++)
381 {
382 fprintf (stream: s_file, format: "static void\ninit_optabs_%02d "
383 "(struct target_optabs *optabs)\n{\n", i);
384 fprintf (stream: s_file, format: " bool *ena = optabs->pat_enable;\n");
385 unsigned start = i * patterns_per_function;
386 unsigned end = MIN (patterns.length (),
387 (i + 1) * patterns_per_function);
388 for (j = start; j < end; ++j)
389 fprintf (stream: s_file, format: " ena[%u] = HAVE_%s;\n", j, patterns[j].name);
390 fprintf (stream: s_file, format: "}\n\n");
391 }
392
393 fprintf (stream: s_file, format: "void\ninit_all_optabs "
394 "(struct target_optabs *optabs)\n{\n");
395 for (i = 0; i < num_init_functions; ++i)
396 fprintf (stream: s_file, format: " init_optabs_%02d (optabs);\n", i);
397 fprintf (stream: s_file, format: "}\n\n");
398 }
399 else
400 {
401 fprintf (stream: s_file, format: "void\ninit_all_optabs "
402 "(struct target_optabs *optabs)\n{\n");
403 fprintf (stream: s_file, format: " bool *ena = optabs->pat_enable;\n");
404 for (i = 0; patterns.iterate (ix: i, ptr: &p); ++i)
405 fprintf (stream: s_file, format: " ena[%u] = HAVE_%s;\n", i, p->name);
406 fprintf (stream: s_file, format: "}\n\n");
407 }
408
409 fprintf (stream: s_file,
410 format: "/* Returns TRUE if the target supports any of the partial vector\n"
411 " optabs: while_ult_optab, len_load_optab, len_store_optab,\n"
412 " mask_len_load_optab or mask_len_store_optab,\n"
413 " for any mode. */\n"
414 "bool\npartial_vectors_supported_p (void)\n{\n");
415 bool any_match = false;
416 fprintf (stream: s_file, format: "\treturn");
417 bool first = true;
418 for (i = 0; patterns.iterate (ix: i, ptr: &p); ++i)
419 {
420#define CMP_NAME(N) !strncmp (p->name, (N), strlen ((N)))
421 if (CMP_NAME("while_ult") || CMP_NAME ("len_load")
422 || CMP_NAME ("len_store")|| CMP_NAME ("mask_len_load")
423 || CMP_NAME ("mask_len_store"))
424 {
425 if (first)
426 fprintf (stream: s_file, format: " HAVE_%s", p->name);
427 else
428 fprintf (stream: s_file, format: " || HAVE_%s", p->name);
429 first = false;
430 any_match = true;
431 }
432 }
433 if (!any_match)
434 fprintf (stream: s_file, format: " false");
435 fprintf (stream: s_file, format: ";\n}\n");
436
437
438 /* Perform a binary search on a pre-encoded optab+mode*2. */
439 /* ??? Perhaps even better to generate a minimal perfect hash.
440 Using gperf directly is awkward since it's so geared to working
441 with strings. Plus we have no visibility into the ordering of
442 the hash entries, which complicates the pat_enable array. */
443 fprintf (stream: s_file,
444 format: "static int\n"
445 "lookup_handler (unsigned scode)\n"
446 "{\n"
447 " int l = 0, h = ARRAY_SIZE (pats), m;\n"
448 " while (h > l)\n"
449 " {\n"
450 " m = (h + l) / 2;\n"
451 " if (scode == pats[m].scode)\n"
452 " return m;\n"
453 " else if (scode < pats[m].scode)\n"
454 " h = m;\n"
455 " else\n"
456 " l = m + 1;\n"
457 " }\n"
458 " return -1;\n"
459 "}\n\n");
460
461 fprintf (stream: s_file,
462 format: "enum insn_code\n"
463 "raw_optab_handler (unsigned scode)\n"
464 "{\n"
465 " int i = lookup_handler (scode);\n"
466 " return (i >= 0 && this_fn_optabs->pat_enable[i]\n"
467 " ? pats[i].icode : CODE_FOR_nothing);\n"
468 "}\n\n");
469
470 fprintf (stream: s_file,
471 format: "bool\n"
472 "swap_optab_enable (optab op, machine_mode m, bool set)\n"
473 "{\n"
474 " unsigned scode = (op << 20) | m;\n"
475 " int i = lookup_handler (scode);\n"
476 " if (i >= 0)\n"
477 " {\n"
478 " bool ret = this_fn_optabs->pat_enable[i];\n"
479 " this_fn_optabs->pat_enable[i] = set;\n"
480 " return ret;\n"
481 " }\n"
482 " else\n"
483 " {\n"
484 " gcc_assert (!set);\n"
485 " return false;\n"
486 " }\n"
487 "}\n\n");
488
489 /* C++ (even G++) does not support (non-trivial) designated initializers.
490 To work around that, generate these arrays programatically rather than
491 by our traditional multiple inclusion of def files. */
492
493 fprintf (stream: s_file,
494 format: "const struct convert_optab_libcall_d "
495 "convlib_def[NUM_CONVLIB_OPTABS] = {\n");
496 for (i = last_kind[0] + 1; i <= last_kind[1]; ++i)
497 fprintf (stream: s_file, format: " { %s, %s },\n", optabs[i].base, optabs[i].libcall);
498 fprintf (stream: s_file, format: "};\n\n");
499
500 fprintf (stream: s_file,
501 format: "const struct optab_libcall_d "
502 "normlib_def[NUM_NORMLIB_OPTABS] = {\n");
503 for (i = last_kind[2] + 1; i <= last_kind[3]; ++i)
504 fprintf (stream: s_file, format: " { %s, %s, %s },\n",
505 optabs[i].suffix, optabs[i].base, optabs[i].libcall);
506 fprintf (stream: s_file, format: "};\n\n");
507
508 fprintf (stream: s_file, format: "enum rtx_code const optab_to_code_[NUM_OPTABS] = {\n");
509 for (i = 0; i < n; ++i)
510 fprintf (stream: s_file, format: " %s,\n", rtx_upname[optabs[i].fcode]);
511 fprintf (stream: s_file, format: "};\n\n");
512
513 qsort (optabs, n, sizeof (optab_def), optab_rcode_cmp);
514
515 fprintf (stream: s_file, format: "const optab code_to_optab_[NUM_RTX_CODE] = {\n");
516 for (j = 0; optabs[j].rcode == UNKNOWN; ++j)
517 continue;
518 for (i = 0; i < NON_GENERATOR_NUM_RTX_CODE; ++i)
519 {
520 if (j < n && optabs[j].rcode == i)
521 fprintf (stream: s_file, format: " %s,\n", optabs[j++].name);
522 else
523 fprintf (stream: s_file, format: " unknown_optab,\n");
524 }
525 fprintf (stream: s_file, format: "};\n\n");
526
527 fprintf (stream: h_file, format: "#endif\n");
528 return (fclose (stream: h_file) == 0 && fclose (stream: s_file) == 0
529 ? SUCCESS_EXIT_CODE : FATAL_EXIT_CODE);
530}
531

source code of gcc/genopinit.cc