Daily bump.
[official-gcc.git] / gcc / genextract.c
blobe6d53379e34282e3e35a993f53dc35597efeac6d
1 /* Generate code from machine description to extract operands from insn as rtl.
2 Copyright (C) 1987-2016 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' when going into a vector. We assume here that only the first operand
37 of an rtl expression is a vector. genrecog.c makes the same assumption
38 (and uses the same representation) and it is currently true. */
40 typedef char *locstr;
42 struct extraction
44 unsigned int op_count;
45 unsigned int dup_count;
46 locstr *oplocs;
47 locstr *duplocs;
48 int *dupnums;
49 struct code_ptr *insns;
50 struct extraction *next;
53 /* Holds a single insn code that uses an extraction method. */
54 struct code_ptr
56 int insn_code;
57 struct code_ptr *next;
60 /* All extractions needed for this machine description. */
61 static struct extraction *extractions;
63 /* All insn codes for old-style peepholes. */
64 static struct code_ptr *peepholes;
66 /* This structure is used by gen_insn and walk_rtx to accumulate the
67 data that will be used to produce an extractions structure. */
70 struct accum_extract
72 accum_extract () : oplocs (10), duplocs (10), dupnums (10), pathstr (20) {}
74 auto_vec<locstr> oplocs;
75 auto_vec<locstr> duplocs;
76 auto_vec<int> dupnums;
77 auto_vec<char> pathstr;
80 /* Forward declarations. */
81 static void walk_rtx (md_rtx_info *, rtx, struct accum_extract *);
83 static void
84 gen_insn (md_rtx_info *info)
86 int i;
87 unsigned int op_count, dup_count, j;
88 struct extraction *p;
89 struct code_ptr *link;
90 struct accum_extract acc;
92 /* Walk the insn's pattern, remembering at all times the path
93 down to the walking point. */
95 rtx insn = info->def;
96 if (XVECLEN (insn, 1) == 1)
97 walk_rtx (info, XVECEXP (insn, 1, 0), &acc);
98 else
99 for (i = XVECLEN (insn, 1) - 1; i >= 0; i--)
101 acc.pathstr.safe_push ('a' + i);
102 walk_rtx (info, XVECEXP (insn, 1, i), &acc);
103 acc.pathstr.pop ();
106 link = XNEW (struct code_ptr);
107 link->insn_code = info->index;
109 /* See if we find something that already had this extraction method. */
111 op_count = acc.oplocs.length ();
112 dup_count = acc.duplocs.length ();
113 gcc_assert (dup_count == acc.dupnums.length ());
115 for (p = extractions; p; p = p->next)
117 if (p->op_count != op_count || p->dup_count != dup_count)
118 continue;
120 for (j = 0; j < op_count; j++)
122 char *a = p->oplocs[j];
123 char *b = acc.oplocs[j];
124 if (a != b && (!a || !b || strcmp (a, b)))
125 break;
128 if (j != op_count)
129 continue;
131 for (j = 0; j < dup_count; j++)
132 if (p->dupnums[j] != acc.dupnums[j]
133 || strcmp (p->duplocs[j], acc.duplocs[j]))
134 break;
136 if (j != dup_count)
137 continue;
139 /* This extraction is the same as ours. Just link us in. */
140 link->next = p->insns;
141 p->insns = link;
142 return;
145 /* Otherwise, make a new extraction method. We stash the arrays
146 after the extraction structure in memory. */
148 p = XNEWVAR (struct extraction, sizeof (struct extraction)
149 + op_count*sizeof (char *)
150 + dup_count*sizeof (char *)
151 + dup_count*sizeof (int));
152 p->op_count = op_count;
153 p->dup_count = dup_count;
154 p->next = extractions;
155 extractions = p;
156 p->insns = link;
157 link->next = 0;
159 p->oplocs = (char **)((char *)p + sizeof (struct extraction));
160 p->duplocs = p->oplocs + op_count;
161 p->dupnums = (int *)(p->duplocs + dup_count);
163 memcpy (p->oplocs, acc.oplocs.address (), op_count * sizeof (locstr));
164 memcpy (p->duplocs, acc.duplocs.address (), dup_count * sizeof (locstr));
165 memcpy (p->dupnums, acc.dupnums.address (), dup_count * sizeof (int));
168 /* Helper subroutine of walk_rtx: given a vec<locstr>, an index, and a
169 string, insert the string at the index, which should either already
170 exist and be NULL, or not yet exist within the vector. In the latter
171 case the vector is enlarged as appropriate. INFO describes the
172 containing define_* expression. */
173 static void
174 VEC_safe_set_locstr (md_rtx_info *info, vec<locstr> *vp,
175 unsigned int ix, char *str)
177 if (ix < (*vp).length ())
179 if ((*vp)[ix])
181 message_at (info->loc, "repeated operand number %d", ix);
182 have_error = 1;
184 else
185 (*vp)[ix] = str;
187 else
189 while (ix > (*vp).length ())
190 vp->safe_push (NULL);
191 vp->safe_push (str);
195 /* Another helper subroutine of walk_rtx: given a vec<char>, convert it
196 to a NUL-terminated string in malloc memory. */
197 static char *
198 VEC_char_to_string (vec<char> v)
200 size_t n = v.length ();
201 char *s = XNEWVEC (char, n + 1);
202 memcpy (s, v.address (), n);
203 s[n] = '\0';
204 return s;
207 static void
208 walk_rtx (md_rtx_info *info, rtx x, struct accum_extract *acc)
210 RTX_CODE code;
211 int i, len, base;
212 const char *fmt;
214 if (x == 0)
215 return;
217 code = GET_CODE (x);
218 switch (code)
220 case PC:
221 case CC0:
222 case CONST_INT:
223 case SYMBOL_REF:
224 return;
226 case MATCH_OPERAND:
227 case MATCH_SCRATCH:
228 VEC_safe_set_locstr (info, &acc->oplocs, XINT (x, 0),
229 VEC_char_to_string (acc->pathstr));
230 break;
232 case MATCH_OPERATOR:
233 case MATCH_PARALLEL:
234 VEC_safe_set_locstr (info, &acc->oplocs, XINT (x, 0),
235 VEC_char_to_string (acc->pathstr));
237 base = (code == MATCH_OPERATOR ? '0' : 'a');
238 for (i = XVECLEN (x, 2) - 1; i >= 0; i--)
240 acc->pathstr.safe_push (base + i);
241 walk_rtx (info, XVECEXP (x, 2, i), acc);
242 acc->pathstr.pop ();
244 return;
246 case MATCH_DUP:
247 case MATCH_PAR_DUP:
248 case MATCH_OP_DUP:
249 acc->duplocs.safe_push (VEC_char_to_string (acc->pathstr));
250 acc->dupnums.safe_push (XINT (x, 0));
252 if (code == MATCH_DUP)
253 break;
255 base = (code == MATCH_OP_DUP ? '0' : 'a');
256 for (i = XVECLEN (x, 1) - 1; i >= 0; i--)
258 acc->pathstr.safe_push (base + i);
259 walk_rtx (info, XVECEXP (x, 1, i), acc);
260 acc->pathstr.pop ();
262 return;
264 default:
265 break;
268 fmt = GET_RTX_FORMAT (code);
269 len = GET_RTX_LENGTH (code);
270 for (i = 0; i < len; i++)
272 if (fmt[i] == 'e' || fmt[i] == 'u')
274 acc->pathstr.safe_push ('0' + i);
275 walk_rtx (info, XEXP (x, i), acc);
276 acc->pathstr.pop ();
278 else if (fmt[i] == 'E')
280 int j;
281 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
283 acc->pathstr.safe_push ('a' + j);
284 walk_rtx (info, XVECEXP (x, i, j), acc);
285 acc->pathstr.pop ();
291 /* Given a PATH, representing a path down the instruction's
292 pattern from the root to a certain point, output code to
293 evaluate to the rtx at that point. */
295 static void
296 print_path (const char *path)
298 int len = strlen (path);
299 int i;
301 if (len == 0)
303 /* Don't emit "pat", since we may try to take the address of it,
304 which isn't what is intended. */
305 fputs ("PATTERN (insn)", stdout);
306 return;
309 /* We first write out the operations (XEXP or XVECEXP) in reverse
310 order, then write "pat", then the indices in forward order. */
312 for (i = len - 1; i >= 0 ; i--)
314 if (ISLOWER (path[i]))
315 fputs ("XVECEXP (", stdout);
316 else if (ISDIGIT (path[i]))
317 fputs ("XEXP (", stdout);
318 else
319 gcc_unreachable ();
322 fputs ("pat", stdout);
324 for (i = 0; i < len; i++)
326 if (ISLOWER (path[i]))
327 printf (", 0, %d)", path[i] - 'a');
328 else if (ISDIGIT (path[i]))
329 printf (", %d)", path[i] - '0');
330 else
331 gcc_unreachable ();
335 static void
336 print_header (void)
338 /* N.B. Code below avoids putting squiggle braces in column 1 inside
339 a string, because this confuses some editors' syntax highlighting
340 engines. */
342 puts ("\
343 /* Generated automatically by the program `genextract'\n\
344 from the machine description file `md'. */\n\
346 #include \"config.h\"\n\
347 #include \"system.h\"\n\
348 #include \"coretypes.h\"\n\
349 #include \"tm.h\"\n\
350 #include \"rtl.h\"\n\
351 #include \"insn-config.h\"\n\
352 #include \"recog.h\"\n\
353 #include \"diagnostic-core.h\"\n\
355 /* This variable is used as the \"location\" of any missing operand\n\
356 whose numbers are skipped by a given pattern. */\n\
357 static rtx junk ATTRIBUTE_UNUSED;\n");
359 puts ("\
360 void\n\
361 insn_extract (rtx_insn *insn)\n{\n\
362 rtx *ro = recog_data.operand;\n\
363 rtx **ro_loc = recog_data.operand_loc;\n\
364 rtx pat = PATTERN (insn);\n\
365 int i ATTRIBUTE_UNUSED; /* only for peepholes */\n\
367 if (flag_checking)\n\
368 {\n\
369 memset (ro, 0xab, sizeof (*ro) * MAX_RECOG_OPERANDS);\n\
370 memset (ro_loc, 0xab, sizeof (*ro_loc) * MAX_RECOG_OPERANDS);\n\
371 }\n");
373 puts ("\
374 switch (INSN_CODE (insn))\n\
375 {\n\
376 default:\n\
377 /* Control reaches here if insn_extract has been called with an\n\
378 unrecognizable insn (code -1), or an insn whose INSN_CODE\n\
379 corresponds to a DEFINE_EXPAND in the machine description;\n\
380 either way, a bug. */\n\
381 if (INSN_CODE (insn) < 0)\n\
382 fatal_insn (\"unrecognizable insn:\", insn);\n\
383 else\n\
384 fatal_insn (\"insn with invalid code number:\", insn);\n");
388 main (int argc, const char **argv)
390 unsigned int i;
391 struct extraction *p;
392 struct code_ptr *link;
393 const char *name;
395 progname = "genextract";
397 if (!init_rtx_reader_args (argc, argv))
398 return (FATAL_EXIT_CODE);
400 /* Read the machine description. */
402 md_rtx_info info;
403 while (read_md_rtx (&info))
404 switch (GET_CODE (info.def))
406 case DEFINE_INSN:
407 gen_insn (&info);
408 break;
410 case DEFINE_PEEPHOLE:
412 struct code_ptr *link = XNEW (struct code_ptr);
414 link->insn_code = info.index;
415 link->next = peepholes;
416 peepholes = link;
418 break;
420 default:
421 break;
424 if (have_error)
425 return FATAL_EXIT_CODE;
427 print_header ();
429 /* Write out code to handle peepholes and the insn_codes that it should
430 be called for. */
431 if (peepholes)
433 for (link = peepholes; link; link = link->next)
434 printf (" case %d:\n", link->insn_code);
436 /* The vector in the insn says how many operands it has.
437 And all it contains are operands. In fact, the vector was
438 created just for the sake of this function. We need to set the
439 location of the operands for sake of simplifications after
440 extraction, like eliminating subregs. */
441 puts (" for (i = XVECLEN (pat, 0) - 1; i >= 0; i--)\n"
442 " ro[i] = *(ro_loc[i] = &XVECEXP (pat, 0, i));\n"
443 " break;\n");
446 /* Write out all the ways to extract insn operands. */
447 for (p = extractions; p; p = p->next)
449 for (link = p->insns; link; link = link->next)
451 i = link->insn_code;
452 name = get_insn_name (i);
453 if (name)
454 printf (" case %d: /* %s */\n", i, name);
455 else
456 printf (" case %d:\n", i);
459 for (i = 0; i < p->op_count; i++)
461 if (p->oplocs[i] == 0)
463 printf (" ro[%d] = const0_rtx;\n", i);
464 printf (" ro_loc[%d] = &junk;\n", i);
466 else
468 printf (" ro[%d] = *(ro_loc[%d] = &", i, i);
469 print_path (p->oplocs[i]);
470 puts (");");
474 for (i = 0; i < p->dup_count; i++)
476 printf (" recog_data.dup_loc[%d] = &", i);
477 print_path (p->duplocs[i]);
478 puts (";");
479 printf (" recog_data.dup_num[%d] = %d;\n", i, p->dupnums[i]);
482 puts (" break;\n");
485 puts (" }\n}");
486 fflush (stdout);
487 return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);