/cp
[official-gcc.git] / gcc / genextract.c
blobb4df0832b3d4f595d7b7dc8edbe93c7ab24d871e
1 /* Generate code from machine description to extract operands from insn as rtl.
2 Copyright (C) 1987-2015 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"
29 #include "vec.h"
31 /* This structure contains all the information needed to describe one
32 set of extractions methods. Each method may be used by more than
33 one pattern if the operands are in the same place.
35 The string for each operand describes that path to the operand and
36 contains `0' through `9' when going into an expression and `a' through
37 `z' when going into a vector. We assume here that only the first operand
38 of an rtl expression is a vector. genrecog.c makes the same assumption
39 (and uses the same representation) and it is currently 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 vec<locstr> oplocs;
74 vec<locstr> duplocs;
75 vec<int> dupnums;
76 vec<char> pathstr;
79 int line_no;
81 /* Forward declarations. */
82 static void walk_rtx (rtx, struct accum_extract *);
84 static void
85 gen_insn (rtx insn, int insn_code_number)
87 int i;
88 unsigned int op_count, dup_count, j;
89 struct extraction *p;
90 struct code_ptr *link;
91 struct accum_extract acc;
93 acc.oplocs.create (10);
94 acc.duplocs.create (10);
95 acc.dupnums.create (10);
96 acc.pathstr.create (20);
98 /* Walk the insn's pattern, remembering at all times the path
99 down to the walking point. */
101 if (XVECLEN (insn, 1) == 1)
102 walk_rtx (XVECEXP (insn, 1, 0), &acc);
103 else
104 for (i = XVECLEN (insn, 1) - 1; i >= 0; i--)
106 acc.pathstr.safe_push ('a' + i);
107 walk_rtx (XVECEXP (insn, 1, i), &acc);
108 acc.pathstr.pop ();
111 link = XNEW (struct code_ptr);
112 link->insn_code = insn_code_number;
114 /* See if we find something that already had this extraction method. */
116 op_count = acc.oplocs.length ();
117 dup_count = acc.duplocs.length ();
118 gcc_assert (dup_count == acc.dupnums.length ());
120 for (p = extractions; p; p = p->next)
122 if (p->op_count != op_count || p->dup_count != dup_count)
123 continue;
125 for (j = 0; j < op_count; j++)
127 char *a = p->oplocs[j];
128 char *b = acc.oplocs[j];
129 if (a != b && (!a || !b || strcmp (a, b)))
130 break;
133 if (j != op_count)
134 continue;
136 for (j = 0; j < dup_count; j++)
137 if (p->dupnums[j] != acc.dupnums[j]
138 || strcmp (p->duplocs[j], acc.duplocs[j]))
139 break;
141 if (j != dup_count)
142 continue;
144 /* This extraction is the same as ours. Just link us in. */
145 link->next = p->insns;
146 p->insns = link;
147 goto done;
150 /* Otherwise, make a new extraction method. We stash the arrays
151 after the extraction structure in memory. */
153 p = XNEWVAR (struct extraction, sizeof (struct extraction)
154 + op_count*sizeof (char *)
155 + dup_count*sizeof (char *)
156 + dup_count*sizeof (int));
157 p->op_count = op_count;
158 p->dup_count = dup_count;
159 p->next = extractions;
160 extractions = p;
161 p->insns = link;
162 link->next = 0;
164 p->oplocs = (char **)((char *)p + sizeof (struct extraction));
165 p->duplocs = p->oplocs + op_count;
166 p->dupnums = (int *)(p->duplocs + dup_count);
168 memcpy (p->oplocs, acc.oplocs.address (), op_count * sizeof (locstr));
169 memcpy (p->duplocs, acc.duplocs.address (), dup_count * sizeof (locstr));
170 memcpy (p->dupnums, acc.dupnums.address (), dup_count * sizeof (int));
172 done:
173 acc.oplocs.release ();
174 acc.duplocs.release ();
175 acc.dupnums.release ();
176 acc.pathstr.release ();
179 /* Helper subroutine of walk_rtx: given a vec<locstr>, an index, and a
180 string, insert the string at the index, which should either already
181 exist and be NULL, or not yet exist within the vector. In the latter
182 case the vector is enlarged as appropriate. */
183 static void
184 VEC_safe_set_locstr (vec<locstr> *vp, unsigned int ix, char *str)
186 if (ix < (*vp).length ())
188 if ((*vp)[ix])
190 message_with_line (line_no, "repeated operand number %d", ix);
191 have_error = 1;
193 else
194 (*vp)[ix] = str;
196 else
198 while (ix > (*vp).length ())
199 vp->safe_push (NULL);
200 vp->safe_push (str);
204 /* Another helper subroutine of walk_rtx: given a vec<char>, convert it
205 to a NUL-terminated string in malloc memory. */
206 static char *
207 VEC_char_to_string (vec<char> v)
209 size_t n = v.length ();
210 char *s = XNEWVEC (char, n + 1);
211 memcpy (s, v.address (), n);
212 s[n] = '\0';
213 return s;
216 static void
217 walk_rtx (rtx x, struct accum_extract *acc)
219 RTX_CODE code;
220 int i, len, base;
221 const char *fmt;
223 if (x == 0)
224 return;
226 code = GET_CODE (x);
227 switch (code)
229 case PC:
230 case CC0:
231 case CONST_INT:
232 case SYMBOL_REF:
233 return;
235 case MATCH_OPERAND:
236 case MATCH_SCRATCH:
237 VEC_safe_set_locstr (&acc->oplocs, XINT (x, 0),
238 VEC_char_to_string (acc->pathstr));
239 break;
241 case MATCH_OPERATOR:
242 case MATCH_PARALLEL:
243 VEC_safe_set_locstr (&acc->oplocs, XINT (x, 0),
244 VEC_char_to_string (acc->pathstr));
246 base = (code == MATCH_OPERATOR ? '0' : 'a');
247 for (i = XVECLEN (x, 2) - 1; i >= 0; i--)
249 acc->pathstr.safe_push (base + i);
250 walk_rtx (XVECEXP (x, 2, i), acc);
251 acc->pathstr.pop ();
253 return;
255 case MATCH_DUP:
256 case MATCH_PAR_DUP:
257 case MATCH_OP_DUP:
258 acc->duplocs.safe_push (VEC_char_to_string (acc->pathstr));
259 acc->dupnums.safe_push (XINT (x, 0));
261 if (code == MATCH_DUP)
262 break;
264 base = (code == MATCH_OP_DUP ? '0' : 'a');
265 for (i = XVECLEN (x, 1) - 1; i >= 0; i--)
267 acc->pathstr.safe_push (base + i);
268 walk_rtx (XVECEXP (x, 1, i), acc);
269 acc->pathstr.pop ();
271 return;
273 default:
274 break;
277 fmt = GET_RTX_FORMAT (code);
278 len = GET_RTX_LENGTH (code);
279 for (i = 0; i < len; i++)
281 if (fmt[i] == 'e' || fmt[i] == 'u')
283 acc->pathstr.safe_push ('0' + i);
284 walk_rtx (XEXP (x, i), acc);
285 acc->pathstr.pop ();
287 else if (fmt[i] == 'E')
289 int j;
290 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
292 acc->pathstr.safe_push ('a' + j);
293 walk_rtx (XVECEXP (x, i, j), acc);
294 acc->pathstr.pop ();
300 /* Given a PATH, representing a path down the instruction's
301 pattern from the root to a certain point, output code to
302 evaluate to the rtx at that point. */
304 static void
305 print_path (const char *path)
307 int len = strlen (path);
308 int i;
310 if (len == 0)
312 /* Don't emit "pat", since we may try to take the address of it,
313 which isn't what is intended. */
314 fputs ("PATTERN (insn)", stdout);
315 return;
318 /* We first write out the operations (XEXP or XVECEXP) in reverse
319 order, then write "pat", then the indices in forward order. */
321 for (i = len - 1; i >= 0 ; i--)
323 if (ISLOWER (path[i]))
324 fputs ("XVECEXP (", stdout);
325 else if (ISDIGIT (path[i]))
326 fputs ("XEXP (", stdout);
327 else
328 gcc_unreachable ();
331 fputs ("pat", stdout);
333 for (i = 0; i < len; i++)
335 if (ISLOWER (path[i]))
336 printf (", 0, %d)", path[i] - 'a');
337 else if (ISDIGIT (path[i]))
338 printf (", %d)", path[i] - '0');
339 else
340 gcc_unreachable ();
344 static void
345 print_header (void)
347 /* N.B. Code below avoids putting squiggle braces in column 1 inside
348 a string, because this confuses some editors' syntax highlighting
349 engines. */
351 puts ("\
352 /* Generated automatically by the program `genextract'\n\
353 from the machine description file `md'. */\n\
355 #include \"config.h\"\n\
356 #include \"system.h\"\n\
357 #include \"coretypes.h\"\n\
358 #include \"tm.h\"\n\
359 #include \"rtl.h\"\n\
360 #include \"insn-config.h\"\n\
361 #include \"recog.h\"\n\
362 #include \"diagnostic-core.h\"\n\
364 /* This variable is used as the \"location\" of any missing operand\n\
365 whose numbers are skipped by a given pattern. */\n\
366 static rtx junk ATTRIBUTE_UNUSED;\n");
368 puts ("\
369 void\n\
370 insn_extract (rtx_insn *insn)\n{\n\
371 rtx *ro = recog_data.operand;\n\
372 rtx **ro_loc = recog_data.operand_loc;\n\
373 rtx pat = PATTERN (insn);\n\
374 int i ATTRIBUTE_UNUSED; /* only for peepholes */\n\
376 #ifdef ENABLE_CHECKING\n\
377 memset (ro, 0xab, sizeof (*ro) * MAX_RECOG_OPERANDS);\n\
378 memset (ro_loc, 0xab, sizeof (*ro_loc) * MAX_RECOG_OPERANDS);\n\
379 #endif\n");
381 puts ("\
382 switch (INSN_CODE (insn))\n\
383 {\n\
384 default:\n\
385 /* Control reaches here if insn_extract has been called with an\n\
386 unrecognizable insn (code -1), or an insn whose INSN_CODE\n\
387 corresponds to a DEFINE_EXPAND in the machine description;\n\
388 either way, a bug. */\n\
389 if (INSN_CODE (insn) < 0)\n\
390 fatal_insn (\"unrecognizable insn:\", insn);\n\
391 else\n\
392 fatal_insn (\"insn with invalid code number:\", insn);\n");
396 main (int argc, char **argv)
398 rtx desc;
399 unsigned int i;
400 struct extraction *p;
401 struct code_ptr *link;
402 const char *name;
403 int insn_code_number;
405 progname = "genextract";
407 if (!init_rtx_reader_args (argc, argv))
408 return (FATAL_EXIT_CODE);
410 /* Read the machine description. */
412 while ((desc = read_md_rtx (&line_no, &insn_code_number)) != NULL)
414 if (GET_CODE (desc) == DEFINE_INSN)
415 gen_insn (desc, insn_code_number);
417 else if (GET_CODE (desc) == DEFINE_PEEPHOLE)
419 struct code_ptr *link = XNEW (struct code_ptr);
421 link->insn_code = insn_code_number;
422 link->next = peepholes;
423 peepholes = link;
427 if (have_error)
428 return FATAL_EXIT_CODE;
430 print_header ();
432 /* Write out code to handle peepholes and the insn_codes that it should
433 be called for. */
434 if (peepholes)
436 for (link = peepholes; link; link = link->next)
437 printf (" case %d:\n", link->insn_code);
439 /* The vector in the insn says how many operands it has.
440 And all it contains are operands. In fact, the vector was
441 created just for the sake of this function. We need to set the
442 location of the operands for sake of simplifications after
443 extraction, like eliminating subregs. */
444 puts (" for (i = XVECLEN (pat, 0) - 1; i >= 0; i--)\n"
445 " ro[i] = *(ro_loc[i] = &XVECEXP (pat, 0, i));\n"
446 " break;\n");
449 /* Write out all the ways to extract insn operands. */
450 for (p = extractions; p; p = p->next)
452 for (link = p->insns; link; link = link->next)
454 i = link->insn_code;
455 name = get_insn_name (i);
456 if (name)
457 printf (" case %d: /* %s */\n", i, name);
458 else
459 printf (" case %d:\n", i);
462 for (i = 0; i < p->op_count; i++)
464 if (p->oplocs[i] == 0)
466 printf (" ro[%d] = const0_rtx;\n", i);
467 printf (" ro_loc[%d] = &junk;\n", i);
469 else
471 printf (" ro[%d] = *(ro_loc[%d] = &", i, i);
472 print_path (p->oplocs[i]);
473 puts (");");
477 for (i = 0; i < p->dup_count; i++)
479 printf (" recog_data.dup_loc[%d] = &", i);
480 print_path (p->duplocs[i]);
481 puts (";");
482 printf (" recog_data.dup_num[%d] = %d;\n", i, p->dupnums[i]);
485 puts (" break;\n");
488 puts (" }\n}");
489 fflush (stdout);
490 return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);