Daily bump.
[official-gcc.git] / gcc / genextract.c
blob387184b4ae1681851cb62cc25f5caa1b69cbbde9
1 /* Generate code from machine description to extract operands from insn as rtl.
2 Copyright (C) 1987-2018 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 for more details.
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/>. */
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 "read-md.h"
28 #include "gensupport.h"
30 /* This structure contains all the information needed to describe one
31 set of extractions methods. Each method may be used by more than
32 one pattern if the operands are in the same place.
34 The string for each operand describes that path to the operand and
35 contains `0' through `9' when going into an expression and `a' through
36 `z' then 'A' through to 'Z' when going into a vector. We assume here that
37 only the first operand of an rtl expression is a vector. genrecog.c makes
38 the same assumption (and uses the same representation) and it is currently
39 true. */
41 typedef char *locstr;
43 struct extraction
45 unsigned int op_count;
46 unsigned int dup_count;
47 locstr *oplocs;
48 locstr *duplocs;
49 int *dupnums;
50 struct code_ptr *insns;
51 struct extraction *next;
54 /* Holds a single insn code that uses an extraction method. */
55 struct code_ptr
57 int insn_code;
58 struct code_ptr *next;
61 /* All extractions needed for this machine description. */
62 static struct extraction *extractions;
64 /* All insn codes for old-style peepholes. */
65 static struct code_ptr *peepholes;
67 /* This structure is used by gen_insn and walk_rtx to accumulate the
68 data that will be used to produce an extractions structure. */
71 struct accum_extract
73 accum_extract () : oplocs (10), duplocs (10), dupnums (10), pathstr (20) {}
75 auto_vec<locstr> oplocs;
76 auto_vec<locstr> duplocs;
77 auto_vec<int> dupnums;
78 auto_vec<char> pathstr;
81 /* Forward declarations. */
82 static void walk_rtx (md_rtx_info *, rtx, struct accum_extract *);
84 #define UPPER_OFFSET ('A' - ('z' - 'a' + 1))
86 /* Convert integer OPERAND into a character - either into [a-zA-Z] for vector
87 operands or [0-9] for integer operands - and push onto the end of the path
88 in ACC. */
89 static void
90 push_pathstr_operand (int operand, bool is_vector,
91 struct accum_extract *acc)
93 if (is_vector && 'a' + operand > 'z')
94 acc->pathstr.safe_push (operand + UPPER_OFFSET);
95 else if (is_vector)
96 acc->pathstr.safe_push (operand + 'a');
97 else
98 acc->pathstr.safe_push (operand + '0');
101 static void
102 gen_insn (md_rtx_info *info)
104 int i;
105 unsigned int op_count, dup_count, j;
106 struct extraction *p;
107 struct code_ptr *link;
108 struct accum_extract acc;
110 /* Walk the insn's pattern, remembering at all times the path
111 down to the walking point. */
113 rtx insn = info->def;
114 if (XVECLEN (insn, 1) == 1)
115 walk_rtx (info, XVECEXP (insn, 1, 0), &acc);
116 else
117 for (i = XVECLEN (insn, 1) - 1; i >= 0; i--)
119 push_pathstr_operand (i, true, &acc);
120 walk_rtx (info, XVECEXP (insn, 1, i), &acc);
121 acc.pathstr.pop ();
124 link = XNEW (struct code_ptr);
125 link->insn_code = info->index;
127 /* See if we find something that already had this extraction method. */
129 op_count = acc.oplocs.length ();
130 dup_count = acc.duplocs.length ();
131 gcc_assert (dup_count == acc.dupnums.length ());
133 for (p = extractions; p; p = p->next)
135 if (p->op_count != op_count || p->dup_count != dup_count)
136 continue;
138 for (j = 0; j < op_count; j++)
140 char *a = p->oplocs[j];
141 char *b = acc.oplocs[j];
142 if (a != b && (!a || !b || strcmp (a, b)))
143 break;
146 if (j != op_count)
147 continue;
149 for (j = 0; j < dup_count; j++)
150 if (p->dupnums[j] != acc.dupnums[j]
151 || strcmp (p->duplocs[j], acc.duplocs[j]))
152 break;
154 if (j != dup_count)
155 continue;
157 /* This extraction is the same as ours. Just link us in. */
158 link->next = p->insns;
159 p->insns = link;
160 return;
163 /* Otherwise, make a new extraction method. We stash the arrays
164 after the extraction structure in memory. */
166 p = XNEWVAR (struct extraction, sizeof (struct extraction)
167 + op_count*sizeof (char *)
168 + dup_count*sizeof (char *)
169 + dup_count*sizeof (int));
170 p->op_count = op_count;
171 p->dup_count = dup_count;
172 p->next = extractions;
173 extractions = p;
174 p->insns = link;
175 link->next = 0;
177 p->oplocs = (char **)((char *)p + sizeof (struct extraction));
178 p->duplocs = p->oplocs + op_count;
179 p->dupnums = (int *)(p->duplocs + dup_count);
181 memcpy (p->oplocs, acc.oplocs.address (), op_count * sizeof (locstr));
182 memcpy (p->duplocs, acc.duplocs.address (), dup_count * sizeof (locstr));
183 memcpy (p->dupnums, acc.dupnums.address (), dup_count * sizeof (int));
186 /* Helper subroutine of walk_rtx: given a vec<locstr>, an index, and a
187 string, insert the string at the index, which should either already
188 exist and be NULL, or not yet exist within the vector. In the latter
189 case the vector is enlarged as appropriate. INFO describes the
190 containing define_* expression. */
191 static void
192 VEC_safe_set_locstr (md_rtx_info *info, vec<locstr> *vp,
193 unsigned int ix, char *str)
195 if (ix < (*vp).length ())
197 if ((*vp)[ix])
199 message_at (info->loc, "repeated operand number %d", ix);
200 have_error = 1;
202 else
203 (*vp)[ix] = str;
205 else
207 while (ix > (*vp).length ())
208 vp->safe_push (NULL);
209 vp->safe_push (str);
213 /* Another helper subroutine of walk_rtx: given a vec<char>, convert it
214 to a NUL-terminated string in malloc memory. */
215 static char *
216 VEC_char_to_string (vec<char> v)
218 size_t n = v.length ();
219 char *s = XNEWVEC (char, n + 1);
220 memcpy (s, v.address (), n);
221 s[n] = '\0';
222 return s;
225 static void
226 walk_rtx (md_rtx_info *info, rtx x, struct accum_extract *acc)
228 RTX_CODE code;
229 int i, len;
230 const char *fmt;
232 if (x == 0)
233 return;
235 code = GET_CODE (x);
236 switch (code)
238 case PC:
239 case CC0:
240 case CONST_INT:
241 case SYMBOL_REF:
242 return;
244 case MATCH_OPERAND:
245 case MATCH_SCRATCH:
246 VEC_safe_set_locstr (info, &acc->oplocs, XINT (x, 0),
247 VEC_char_to_string (acc->pathstr));
248 break;
250 case MATCH_OPERATOR:
251 case MATCH_PARALLEL:
252 VEC_safe_set_locstr (info, &acc->oplocs, XINT (x, 0),
253 VEC_char_to_string (acc->pathstr));
255 for (i = XVECLEN (x, 2) - 1; i >= 0; i--)
257 push_pathstr_operand (i, code != MATCH_OPERATOR, acc);
258 walk_rtx (info, XVECEXP (x, 2, i), acc);
259 acc->pathstr.pop ();
261 return;
263 case MATCH_DUP:
264 case MATCH_PAR_DUP:
265 case MATCH_OP_DUP:
266 acc->duplocs.safe_push (VEC_char_to_string (acc->pathstr));
267 acc->dupnums.safe_push (XINT (x, 0));
269 if (code == MATCH_DUP)
270 break;
272 for (i = XVECLEN (x, 1) - 1; i >= 0; i--)
274 push_pathstr_operand (i, code != MATCH_OP_DUP, acc);
275 walk_rtx (info, XVECEXP (x, 1, i), acc);
276 acc->pathstr.pop ();
278 return;
280 default:
281 break;
284 fmt = GET_RTX_FORMAT (code);
285 len = GET_RTX_LENGTH (code);
286 for (i = 0; i < len; i++)
288 if (fmt[i] == 'e' || fmt[i] == 'u')
290 push_pathstr_operand (i, false, acc);
291 walk_rtx (info, XEXP (x, i), acc);
292 acc->pathstr.pop ();
294 else if (fmt[i] == 'E')
296 int j;
297 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
299 push_pathstr_operand (j, true, acc);
300 walk_rtx (info, XVECEXP (x, i, j), acc);
301 acc->pathstr.pop ();
307 /* Given a PATH, representing a path down the instruction's
308 pattern from the root to a certain point, output code to
309 evaluate to the rtx at that point. */
311 static void
312 print_path (const char *path)
314 int len = strlen (path);
315 int i;
317 if (len == 0)
319 /* Don't emit "pat", since we may try to take the address of it,
320 which isn't what is intended. */
321 fputs ("PATTERN (insn)", stdout);
322 return;
325 /* We first write out the operations (XEXP or XVECEXP) in reverse
326 order, then write "pat", then the indices in forward order. */
328 for (i = len - 1; i >= 0 ; i--)
330 if (ISLOWER (path[i]) || ISUPPER (path[i]))
331 fputs ("XVECEXP (", stdout);
332 else if (ISDIGIT (path[i]))
333 fputs ("XEXP (", stdout);
334 else
335 gcc_unreachable ();
338 fputs ("pat", stdout);
340 for (i = 0; i < len; i++)
342 if (ISUPPER (path[i]))
343 printf (", 0, %d)", path[i] - UPPER_OFFSET);
344 else if (ISLOWER (path[i]))
345 printf (", 0, %d)", path[i] - 'a');
346 else if (ISDIGIT (path[i]))
347 printf (", %d)", path[i] - '0');
348 else
349 gcc_unreachable ();
353 static void
354 print_header (void)
356 /* N.B. Code below avoids putting squiggle braces in column 1 inside
357 a string, because this confuses some editors' syntax highlighting
358 engines. */
360 puts ("\
361 /* Generated automatically by the program `genextract'\n\
362 from the machine description file `md'. */\n\
364 #define IN_TARGET_CODE 1\n\
365 #include \"config.h\"\n\
366 #include \"system.h\"\n\
367 #include \"coretypes.h\"\n\
368 #include \"tm.h\"\n\
369 #include \"rtl.h\"\n\
370 #include \"insn-config.h\"\n\
371 #include \"recog.h\"\n\
372 #include \"diagnostic-core.h\"\n\
374 /* This variable is used as the \"location\" of any missing operand\n\
375 whose numbers are skipped by a given pattern. */\n\
376 static rtx junk ATTRIBUTE_UNUSED;\n");
378 puts ("\
379 void\n\
380 insn_extract (rtx_insn *insn)\n{\n\
381 rtx *ro = recog_data.operand;\n\
382 rtx **ro_loc = recog_data.operand_loc;\n\
383 rtx pat = PATTERN (insn);\n\
384 int i ATTRIBUTE_UNUSED; /* only for peepholes */\n\
386 if (flag_checking)\n\
387 {\n\
388 memset (ro, 0xab, sizeof (*ro) * MAX_RECOG_OPERANDS);\n\
389 memset (ro_loc, 0xab, sizeof (*ro_loc) * MAX_RECOG_OPERANDS);\n\
390 }\n");
392 puts ("\
393 switch (INSN_CODE (insn))\n\
394 {\n\
395 default:\n\
396 /* Control reaches here if insn_extract has been called with an\n\
397 unrecognizable insn (code -1), or an insn whose INSN_CODE\n\
398 corresponds to a DEFINE_EXPAND in the machine description;\n\
399 either way, a bug. */\n\
400 if (INSN_CODE (insn) < 0)\n\
401 fatal_insn (\"unrecognizable insn:\", insn);\n\
402 else\n\
403 fatal_insn (\"insn with invalid code number:\", insn);\n");
407 main (int argc, const char **argv)
409 unsigned int i;
410 struct extraction *p;
411 struct code_ptr *link;
412 const char *name;
414 progname = "genextract";
416 if (!init_rtx_reader_args (argc, argv))
417 return (FATAL_EXIT_CODE);
419 /* Read the machine description. */
421 md_rtx_info info;
422 while (read_md_rtx (&info))
423 switch (GET_CODE (info.def))
425 case DEFINE_INSN:
426 gen_insn (&info);
427 break;
429 case DEFINE_PEEPHOLE:
431 struct code_ptr *link = XNEW (struct code_ptr);
433 link->insn_code = info.index;
434 link->next = peepholes;
435 peepholes = link;
437 break;
439 default:
440 break;
443 if (have_error)
444 return FATAL_EXIT_CODE;
446 print_header ();
448 /* Write out code to handle peepholes and the insn_codes that it should
449 be called for. */
450 if (peepholes)
452 for (link = peepholes; link; link = link->next)
453 printf (" case %d:\n", link->insn_code);
455 /* The vector in the insn says how many operands it has.
456 And all it contains are operands. In fact, the vector was
457 created just for the sake of this function. We need to set the
458 location of the operands for sake of simplifications after
459 extraction, like eliminating subregs. */
460 puts (" for (i = XVECLEN (pat, 0) - 1; i >= 0; i--)\n"
461 " ro[i] = *(ro_loc[i] = &XVECEXP (pat, 0, i));\n"
462 " break;\n");
465 /* Write out all the ways to extract insn operands. */
466 for (p = extractions; p; p = p->next)
468 for (link = p->insns; link; link = link->next)
470 i = link->insn_code;
471 name = get_insn_name (i);
472 if (name)
473 printf (" case %d: /* %s */\n", i, name);
474 else
475 printf (" case %d:\n", i);
478 for (i = 0; i < p->op_count; i++)
480 if (p->oplocs[i] == 0)
482 printf (" ro[%d] = const0_rtx;\n", i);
483 printf (" ro_loc[%d] = &junk;\n", i);
485 else
487 printf (" ro[%d] = *(ro_loc[%d] = &", i, i);
488 print_path (p->oplocs[i]);
489 puts (");");
493 for (i = 0; i < p->dup_count; i++)
495 printf (" recog_data.dup_loc[%d] = &", i);
496 print_path (p->duplocs[i]);
497 puts (";");
498 printf (" recog_data.dup_num[%d] = %d;\n", i, p->dupnums[i]);
501 puts (" break;\n");
504 puts (" }\n}");
505 fflush (stdout);
506 return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);