Missed one in last change.
[official-gcc.git] / gcc / genextract.c
blobcf2f2ab50fd04126beb66e0d02c3d5283535fc23
1 /* Generate code from machine description to extract operands from insn as rtl.
2 Copyright (C) 1987, 1991, 1992, 1993, 1997, 1998, 1999, 2000, 2003
3 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA. */
23 #include "bconfig.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "tm.h"
27 #include "rtl.h"
28 #include "errors.h"
29 #include "insn-config.h"
30 #include "gensupport.h"
33 /* This structure contains all the information needed to describe one
34 set of extractions methods. Each method may be used by more than
35 one pattern if the operands are in the same place.
37 The string for each operand describes that path to the operand and
38 contains `0' through `9' when going into an expression and `a' through
39 `z' when going into a vector. We assume here that only the first operand
40 of an rtl expression is a vector. genrecog.c makes the same assumption
41 (and uses the same representation) and it is currently true. */
43 struct extraction
45 int op_count;
46 char *oplocs[MAX_RECOG_OPERANDS];
47 int dup_count;
48 char *duplocs[MAX_DUP_OPERANDS];
49 int dupnums[MAX_DUP_OPERANDS];
50 struct code_ptr *insns;
51 struct extraction *next;
54 /* Holds a single insn code that use an extraction method. */
56 struct code_ptr
58 int insn_code;
59 struct code_ptr *next;
62 static struct extraction *extractions;
64 /* Holds an array of names indexed by insn_code_number. */
65 static char **insn_name_ptr = 0;
66 static int insn_name_ptr_size = 0;
68 /* Number instruction patterns handled, starting at 0 for first one. */
70 static int insn_code_number;
72 /* Records the large operand number in this insn. */
74 static int op_count;
76 /* Records the location of any operands using the string format described
77 above. */
79 static char *oplocs[MAX_RECOG_OPERANDS];
81 /* Number the occurrences of MATCH_DUP in each instruction,
82 starting at 0 for the first occurrence. */
84 static int dup_count;
86 /* Records the location of any MATCH_DUP operands. */
88 static char *duplocs[MAX_DUP_OPERANDS];
90 /* Record the operand number of any MATCH_DUPs. */
92 static int dupnums[MAX_DUP_OPERANDS];
94 /* Record the list of insn_codes for peepholes. */
96 static struct code_ptr *peepholes;
98 static void gen_insn (rtx);
99 static void walk_rtx (rtx, const char *);
100 static void print_path (const char *);
101 static void record_insn_name (int, const char *);
103 static void
104 gen_insn (rtx insn)
106 int i;
107 struct extraction *p;
108 struct code_ptr *link;
110 op_count = 0;
111 dup_count = 0;
113 /* No operands seen so far in this pattern. */
114 memset (oplocs, 0, sizeof oplocs);
116 /* Walk the insn's pattern, remembering at all times the path
117 down to the walking point. */
119 if (XVECLEN (insn, 1) == 1)
120 walk_rtx (XVECEXP (insn, 1, 0), "");
121 else
122 for (i = XVECLEN (insn, 1) - 1; i >= 0; i--)
124 char path[2];
126 path[0] = 'a' + i;
127 path[1] = 0;
129 walk_rtx (XVECEXP (insn, 1, i), path);
132 link = (struct code_ptr *) xmalloc (sizeof (struct code_ptr));
133 link->insn_code = insn_code_number;
135 /* See if we find something that already had this extraction method. */
137 for (p = extractions; p; p = p->next)
139 if (p->op_count != op_count || p->dup_count != dup_count)
140 continue;
142 for (i = 0; i < op_count; i++)
143 if (p->oplocs[i] != oplocs[i]
144 && ! (p->oplocs[i] != 0 && oplocs[i] != 0
145 && ! strcmp (p->oplocs[i], oplocs[i])))
146 break;
148 if (i != op_count)
149 continue;
151 for (i = 0; i < dup_count; i++)
152 if (p->dupnums[i] != dupnums[i]
153 || strcmp (p->duplocs[i], duplocs[i]))
154 break;
156 if (i != dup_count)
157 continue;
159 /* This extraction is the same as ours. Just link us in. */
160 link->next = p->insns;
161 p->insns = link;
162 return;
165 /* Otherwise, make a new extraction method. */
167 p = (struct extraction *) xmalloc (sizeof (struct extraction));
168 p->op_count = op_count;
169 p->dup_count = dup_count;
170 p->next = extractions;
171 extractions = p;
172 p->insns = link;
173 link->next = 0;
175 for (i = 0; i < op_count; i++)
176 p->oplocs[i] = oplocs[i];
178 for (i = 0; i < dup_count; i++)
179 p->dupnums[i] = dupnums[i], p->duplocs[i] = duplocs[i];
182 static void
183 walk_rtx (rtx x, const char *path)
185 RTX_CODE code;
186 int i;
187 int len;
188 const char *fmt;
189 int depth = strlen (path);
190 char *newpath;
192 if (x == 0)
193 return;
195 code = GET_CODE (x);
197 switch (code)
199 case PC:
200 case CC0:
201 case CONST_INT:
202 case SYMBOL_REF:
203 return;
205 case MATCH_OPERAND:
206 case MATCH_SCRATCH:
207 oplocs[XINT (x, 0)] = xstrdup (path);
208 op_count = MAX (op_count, XINT (x, 0) + 1);
209 break;
211 case MATCH_DUP:
212 duplocs[dup_count] = xstrdup (path);
213 dupnums[dup_count] = XINT (x, 0);
214 dup_count++;
215 break;
217 case MATCH_PAR_DUP:
218 case MATCH_OP_DUP:
219 duplocs[dup_count] = xstrdup (path);
220 dupnums[dup_count] = XINT (x, 0);
221 dup_count++;
223 newpath = (char *) xmalloc (depth + 2);
224 strcpy (newpath, path);
225 newpath[depth + 1] = 0;
227 for (i = XVECLEN (x, 1) - 1; i >= 0; i--)
229 newpath[depth] = (code == MATCH_OP_DUP ? '0' : 'a') + i;
230 walk_rtx (XVECEXP (x, 1, i), newpath);
232 free (newpath);
233 return;
235 case MATCH_OPERATOR:
236 oplocs[XINT (x, 0)] = xstrdup (path);
237 op_count = MAX (op_count, XINT (x, 0) + 1);
239 newpath = (char *) xmalloc (depth + 2);
240 strcpy (newpath, path);
241 newpath[depth + 1] = 0;
243 for (i = XVECLEN (x, 2) - 1; i >= 0; i--)
245 newpath[depth] = '0' + i;
246 walk_rtx (XVECEXP (x, 2, i), newpath);
248 free (newpath);
249 return;
251 case MATCH_PARALLEL:
252 oplocs[XINT (x, 0)] = xstrdup (path);
253 op_count = MAX (op_count, XINT (x, 0) + 1);
255 newpath = (char *) xmalloc (depth + 2);
256 strcpy (newpath, path);
257 newpath[depth + 1] = 0;
259 for (i = XVECLEN (x, 2) - 1; i >= 0; i--)
261 newpath[depth] = 'a' + i;
262 walk_rtx (XVECEXP (x, 2, i), newpath);
264 free (newpath);
265 return;
267 case ADDRESS:
268 walk_rtx (XEXP (x, 0), path);
269 return;
271 default:
272 break;
275 newpath = (char *) xmalloc (depth + 2);
276 strcpy (newpath, path);
277 newpath[depth + 1] = 0;
279 fmt = GET_RTX_FORMAT (code);
280 len = GET_RTX_LENGTH (code);
281 for (i = 0; i < len; i++)
283 if (fmt[i] == 'e' || fmt[i] == 'u')
285 newpath[depth] = '0' + i;
286 walk_rtx (XEXP (x, i), newpath);
288 else if (fmt[i] == 'E')
290 int j;
291 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
293 newpath[depth] = 'a' + j;
294 walk_rtx (XVECEXP (x, i, j), newpath);
298 free (newpath);
301 /* Given a PATH, representing a path down the instruction's
302 pattern from the root to a certain point, output code to
303 evaluate to the rtx at that point. */
305 static void
306 print_path (const char *path)
308 int len = strlen (path);
309 int i;
311 if (len == 0)
313 /* Don't emit "pat", since we may try to take the address of it,
314 which isn't what is intended. */
315 printf("PATTERN (insn)");
316 return;
319 /* We first write out the operations (XEXP or XVECEXP) in reverse
320 order, then write "insn", then the indices in forward order. */
322 for (i = len - 1; i >= 0 ; i--)
324 if (ISLOWER(path[i]))
325 printf ("XVECEXP (");
326 else if (ISDIGIT(path[i]))
327 printf ("XEXP (");
328 else
329 abort ();
332 printf ("pat");
334 for (i = 0; i < len; i++)
336 if (ISLOWER(path[i]))
337 printf (", 0, %d)", path[i] - 'a');
338 else if (ISDIGIT(path[i]))
339 printf (", %d)", path[i] - '0');
340 else
341 abort ();
347 main (int argc, char **argv)
349 rtx desc;
350 int i;
351 struct extraction *p;
352 struct code_ptr *link;
353 const char *name;
355 progname = "genextract";
357 if (argc <= 1)
358 fatal ("no input file name");
360 if (init_md_reader_args (argc, argv) != SUCCESS_EXIT_CODE)
361 return (FATAL_EXIT_CODE);
363 /* Assign sequential codes to all entries in the machine description
364 in parallel with the tables in insn-output.c. */
366 insn_code_number = 0;
368 printf ("/* Generated automatically by the program `genextract'\n\
369 from the machine description file `md'. */\n\n");
371 printf ("#include \"config.h\"\n");
372 printf ("#include \"system.h\"\n");
373 printf ("#include \"coretypes.h\"\n");
374 printf ("#include \"tm.h\"\n");
375 printf ("#include \"rtl.h\"\n");
376 printf ("#include \"insn-config.h\"\n");
377 printf ("#include \"recog.h\"\n");
378 printf ("#include \"toplev.h\"\n\n");
380 /* This variable exists only so it can be the "location"
381 of any missing operand whose numbers are skipped by a given pattern. */
382 printf ("static rtx junk ATTRIBUTE_UNUSED;\n");
384 printf ("void\ninsn_extract (rtx insn)\n");
385 printf ("{\n");
386 printf (" rtx *ro = recog_data.operand;\n");
387 printf (" rtx **ro_loc = recog_data.operand_loc;\n");
388 printf (" rtx pat = PATTERN (insn);\n");
389 printf (" int i ATTRIBUTE_UNUSED;\n\n");
390 printf (" memset (ro, 0, sizeof (*ro) * MAX_RECOG_OPERANDS);\n");
391 printf (" memset (ro_loc, 0, sizeof (*ro_loc) * MAX_RECOG_OPERANDS);\n");
392 printf (" switch (INSN_CODE (insn))\n");
393 printf (" {\n");
394 printf (" case -1:\n");
395 printf (" fatal_insn_not_found (insn);\n\n");
397 /* Read the machine description. */
399 while (1)
401 int line_no;
403 desc = read_md_rtx (&line_no, &insn_code_number);
404 if (desc == NULL)
405 break;
407 if (GET_CODE (desc) == DEFINE_INSN)
409 record_insn_name (insn_code_number, XSTR (desc, 0));
410 gen_insn (desc);
413 else if (GET_CODE (desc) == DEFINE_PEEPHOLE)
415 struct code_ptr *link
416 = (struct code_ptr *) xmalloc (sizeof (struct code_ptr));
418 link->insn_code = insn_code_number;
419 link->next = peepholes;
420 peepholes = link;
424 /* Write out code to handle peepholes and the insn_codes that it should
425 be called for. */
426 if (peepholes)
428 for (link = peepholes; link; link = link->next)
429 printf (" case %d:\n", link->insn_code);
431 /* The vector in the insn says how many operands it has.
432 And all it contains are operands. In fact, the vector was
433 created just for the sake of this function. We need to set the
434 location of the operands for sake of simplifications after
435 extraction, like eliminating subregs. */
436 printf (" for (i = XVECLEN (pat, 0) - 1; i >= 0; i--)\n");
437 printf (" ro[i] = *(ro_loc[i] = &XVECEXP (pat, 0, i));\n");
438 printf (" break;\n\n");
441 /* Write out all the ways to extract insn operands. */
442 for (p = extractions; p; p = p->next)
444 for (link = p->insns; link; link = link->next)
446 i = link->insn_code;
447 name = get_insn_name (i);
448 if (name)
449 printf (" case %d: /* %s */\n", i, name);
450 else
451 printf (" case %d:\n", i);
454 for (i = 0; i < p->op_count; i++)
456 if (p->oplocs[i] == 0)
458 printf (" ro[%d] = const0_rtx;\n", i);
459 printf (" ro_loc[%d] = &junk;\n", i);
461 else
463 printf (" ro[%d] = *(ro_loc[%d] = &", i, i);
464 print_path (p->oplocs[i]);
465 printf (");\n");
469 for (i = 0; i < p->dup_count; i++)
471 printf (" recog_data.dup_loc[%d] = &", i);
472 print_path (p->duplocs[i]);
473 printf (";\n");
474 printf (" recog_data.dup_num[%d] = %d;\n", i, p->dupnums[i]);
477 printf (" break;\n\n");
480 /* This should never be reached. Note that we would also reach this abort
481 if we tried to extract something whose INSN_CODE was a DEFINE_EXPAND or
482 DEFINE_SPLIT, but that is correct. */
483 printf (" default:\n abort ();\n");
485 printf (" }\n}\n");
487 fflush (stdout);
488 return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
491 /* Define this so we can link with print-rtl.o to get debug_rtx function. */
492 const char *
493 get_insn_name (code)
494 int code ATTRIBUTE_UNUSED;
496 if (code < insn_name_ptr_size)
497 return insn_name_ptr[code];
498 else
499 return NULL;
502 static void
503 record_insn_name (code, name)
504 int code;
505 const char *name;
507 static const char *last_real_name = "insn";
508 static int last_real_code = 0;
509 char *new;
511 if (insn_name_ptr_size <= code)
513 int new_size;
514 new_size = (insn_name_ptr_size ? insn_name_ptr_size * 2 : 512);
515 insn_name_ptr =
516 (char **) xrealloc (insn_name_ptr, sizeof(char *) * new_size);
517 memset (insn_name_ptr + insn_name_ptr_size, 0,
518 sizeof(char *) * (new_size - insn_name_ptr_size));
519 insn_name_ptr_size = new_size;
522 if (!name || name[0] == '\0')
524 new = xmalloc (strlen (last_real_name) + 10);
525 sprintf (new, "%s+%d", last_real_name, code - last_real_code);
527 else
529 last_real_name = new = xstrdup (name);
530 last_real_code = code;
533 insn_name_ptr[code] = new;