[AArch64] Fix gcc.target/aarch64/subs_compare_[12].c
[official-gcc.git] / gcc / genextract.c
blobf86efb37a68c98e4411f3932c3e02fbcd24915ed
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' 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 #define IN_TARGET_CODE 1\n\
347 #include \"config.h\"\n\
348 #include \"system.h\"\n\
349 #include \"coretypes.h\"\n\
350 #include \"tm.h\"\n\
351 #include \"rtl.h\"\n\
352 #include \"insn-config.h\"\n\
353 #include \"recog.h\"\n\
354 #include \"diagnostic-core.h\"\n\
356 /* This variable is used as the \"location\" of any missing operand\n\
357 whose numbers are skipped by a given pattern. */\n\
358 static rtx junk ATTRIBUTE_UNUSED;\n");
360 puts ("\
361 void\n\
362 insn_extract (rtx_insn *insn)\n{\n\
363 rtx *ro = recog_data.operand;\n\
364 rtx **ro_loc = recog_data.operand_loc;\n\
365 rtx pat = PATTERN (insn);\n\
366 int i ATTRIBUTE_UNUSED; /* only for peepholes */\n\
368 if (flag_checking)\n\
369 {\n\
370 memset (ro, 0xab, sizeof (*ro) * MAX_RECOG_OPERANDS);\n\
371 memset (ro_loc, 0xab, sizeof (*ro_loc) * MAX_RECOG_OPERANDS);\n\
372 }\n");
374 puts ("\
375 switch (INSN_CODE (insn))\n\
376 {\n\
377 default:\n\
378 /* Control reaches here if insn_extract has been called with an\n\
379 unrecognizable insn (code -1), or an insn whose INSN_CODE\n\
380 corresponds to a DEFINE_EXPAND in the machine description;\n\
381 either way, a bug. */\n\
382 if (INSN_CODE (insn) < 0)\n\
383 fatal_insn (\"unrecognizable insn:\", insn);\n\
384 else\n\
385 fatal_insn (\"insn with invalid code number:\", insn);\n");
389 main (int argc, const char **argv)
391 unsigned int i;
392 struct extraction *p;
393 struct code_ptr *link;
394 const char *name;
396 progname = "genextract";
398 if (!init_rtx_reader_args (argc, argv))
399 return (FATAL_EXIT_CODE);
401 /* Read the machine description. */
403 md_rtx_info info;
404 while (read_md_rtx (&info))
405 switch (GET_CODE (info.def))
407 case DEFINE_INSN:
408 gen_insn (&info);
409 break;
411 case DEFINE_PEEPHOLE:
413 struct code_ptr *link = XNEW (struct code_ptr);
415 link->insn_code = info.index;
416 link->next = peepholes;
417 peepholes = link;
419 break;
421 default:
422 break;
425 if (have_error)
426 return FATAL_EXIT_CODE;
428 print_header ();
430 /* Write out code to handle peepholes and the insn_codes that it should
431 be called for. */
432 if (peepholes)
434 for (link = peepholes; link; link = link->next)
435 printf (" case %d:\n", link->insn_code);
437 /* The vector in the insn says how many operands it has.
438 And all it contains are operands. In fact, the vector was
439 created just for the sake of this function. We need to set the
440 location of the operands for sake of simplifications after
441 extraction, like eliminating subregs. */
442 puts (" for (i = XVECLEN (pat, 0) - 1; i >= 0; i--)\n"
443 " ro[i] = *(ro_loc[i] = &XVECEXP (pat, 0, i));\n"
444 " break;\n");
447 /* Write out all the ways to extract insn operands. */
448 for (p = extractions; p; p = p->next)
450 for (link = p->insns; link; link = link->next)
452 i = link->insn_code;
453 name = get_insn_name (i);
454 if (name)
455 printf (" case %d: /* %s */\n", i, name);
456 else
457 printf (" case %d:\n", i);
460 for (i = 0; i < p->op_count; i++)
462 if (p->oplocs[i] == 0)
464 printf (" ro[%d] = const0_rtx;\n", i);
465 printf (" ro_loc[%d] = &junk;\n", i);
467 else
469 printf (" ro[%d] = *(ro_loc[%d] = &", i, i);
470 print_path (p->oplocs[i]);
471 puts (");");
475 for (i = 0; i < p->dup_count; i++)
477 printf (" recog_data.dup_loc[%d] = &", i);
478 print_path (p->duplocs[i]);
479 puts (";");
480 printf (" recog_data.dup_num[%d] = %d;\n", i, p->dupnums[i]);
483 puts (" break;\n");
486 puts (" }\n}");
487 fflush (stdout);
488 return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);