1/* Generate code to initialize optabs from machine description.
2 Copyright (C) 1993-2023 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 fprintf (stream: s_file, format: "void\ninit_all_optabs (struct target_optabs *optabs)\n{\n");
371 fprintf (stream: s_file, format: " bool *ena = optabs->pat_enable;\n");
372 for (i = 0; patterns.iterate (ix: i, ptr: &p); ++i)
373 fprintf (stream: s_file, format: " ena[%u] = HAVE_%s;\n", i, p->name);
374 fprintf (stream: s_file, format: "}\n\n");
375
376 fprintf (stream: s_file,
377 format: "/* Returns TRUE if the target supports any of the partial vector\n"
378 " optabs: while_ult_optab, len_load_optab, len_store_optab,\n"
379 " mask_len_load_optab or mask_len_store_optab,\n"
380 " for any mode. */\n"
381 "bool\npartial_vectors_supported_p (void)\n{\n");
382 bool any_match = false;
383 fprintf (stream: s_file, format: "\treturn");
384 bool first = true;
385 for (i = 0; patterns.iterate (ix: i, ptr: &p); ++i)
386 {
387#define CMP_NAME(N) !strncmp (p->name, (N), strlen ((N)))
388 if (CMP_NAME("while_ult") || CMP_NAME ("len_load")
389 || CMP_NAME ("len_store")|| CMP_NAME ("mask_len_load")
390 || CMP_NAME ("mask_len_store"))
391 {
392 if (first)
393 fprintf (stream: s_file, format: " HAVE_%s", p->name);
394 else
395 fprintf (stream: s_file, format: " || HAVE_%s", p->name);
396 first = false;
397 any_match = true;
398 }
399 }
400 if (!any_match)
401 fprintf (stream: s_file, format: " false");
402 fprintf (stream: s_file, format: ";\n}\n");
403
404
405 /* Perform a binary search on a pre-encoded optab+mode*2. */
406 /* ??? Perhaps even better to generate a minimal perfect hash.
407 Using gperf directly is awkward since it's so geared to working
408 with strings. Plus we have no visibility into the ordering of
409 the hash entries, which complicates the pat_enable array. */
410 fprintf (stream: s_file,
411 format: "static int\n"
412 "lookup_handler (unsigned scode)\n"
413 "{\n"
414 " int l = 0, h = ARRAY_SIZE (pats), m;\n"
415 " while (h > l)\n"
416 " {\n"
417 " m = (h + l) / 2;\n"
418 " if (scode == pats[m].scode)\n"
419 " return m;\n"
420 " else if (scode < pats[m].scode)\n"
421 " h = m;\n"
422 " else\n"
423 " l = m + 1;\n"
424 " }\n"
425 " return -1;\n"
426 "}\n\n");
427
428 fprintf (stream: s_file,
429 format: "enum insn_code\n"
430 "raw_optab_handler (unsigned scode)\n"
431 "{\n"
432 " int i = lookup_handler (scode);\n"
433 " return (i >= 0 && this_fn_optabs->pat_enable[i]\n"
434 " ? pats[i].icode : CODE_FOR_nothing);\n"
435 "}\n\n");
436
437 fprintf (stream: s_file,
438 format: "bool\n"
439 "swap_optab_enable (optab op, machine_mode m, bool set)\n"
440 "{\n"
441 " unsigned scode = (op << 20) | m;\n"
442 " int i = lookup_handler (scode);\n"
443 " if (i >= 0)\n"
444 " {\n"
445 " bool ret = this_fn_optabs->pat_enable[i];\n"
446 " this_fn_optabs->pat_enable[i] = set;\n"
447 " return ret;\n"
448 " }\n"
449 " else\n"
450 " {\n"
451 " gcc_assert (!set);\n"
452 " return false;\n"
453 " }\n"
454 "}\n\n");
455
456 /* C++ (even G++) does not support (non-trivial) designated initializers.
457 To work around that, generate these arrays programatically rather than
458 by our traditional multiple inclusion of def files. */
459
460 fprintf (stream: s_file,
461 format: "const struct convert_optab_libcall_d "
462 "convlib_def[NUM_CONVLIB_OPTABS] = {\n");
463 for (i = last_kind[0] + 1; i <= last_kind[1]; ++i)
464 fprintf (stream: s_file, format: " { %s, %s },\n", optabs[i].base, optabs[i].libcall);
465 fprintf (stream: s_file, format: "};\n\n");
466
467 fprintf (stream: s_file,
468 format: "const struct optab_libcall_d "
469 "normlib_def[NUM_NORMLIB_OPTABS] = {\n");
470 for (i = last_kind[2] + 1; i <= last_kind[3]; ++i)
471 fprintf (stream: s_file, format: " { %s, %s, %s },\n",
472 optabs[i].suffix, optabs[i].base, optabs[i].libcall);
473 fprintf (stream: s_file, format: "};\n\n");
474
475 fprintf (stream: s_file, format: "enum rtx_code const optab_to_code_[NUM_OPTABS] = {\n");
476 for (i = 0; i < n; ++i)
477 fprintf (stream: s_file, format: " %s,\n", rtx_upname[optabs[i].fcode]);
478 fprintf (stream: s_file, format: "};\n\n");
479
480 qsort (optabs, n, sizeof (optab_def), optab_rcode_cmp);
481
482 fprintf (stream: s_file, format: "const optab code_to_optab_[NUM_RTX_CODE] = {\n");
483 for (j = 0; optabs[j].rcode == UNKNOWN; ++j)
484 continue;
485 for (i = 0; i < NON_GENERATOR_NUM_RTX_CODE; ++i)
486 {
487 if (j < n && optabs[j].rcode == i)
488 fprintf (stream: s_file, format: " %s,\n", optabs[j++].name);
489 else
490 fprintf (stream: s_file, format: " unknown_optab,\n");
491 }
492 fprintf (stream: s_file, format: "};\n\n");
493
494 fprintf (stream: h_file, format: "#endif\n");
495 return (fclose (stream: h_file) == 0 && fclose (stream: s_file) == 0
496 ? SUCCESS_EXIT_CODE : FATAL_EXIT_CODE);
497}
498

source code of gcc/genopinit.cc