xref: /netbsd-src/external/gpl3/gcc.old/dist/gcc/genextract.c (revision 87d689fb734c654d2486f87f7be32f1b53ecdbec)
1 /* Generate code from machine description to extract operands from insn as rtl.
2    Copyright (C) 1987-2015 Free Software Foundation, Inc.
3 
4 This file is part of GCC.
5 
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.
10 
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.
15 
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/>.  */
19 
20 
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"
30 
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.
34 
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.  */
40 
41 typedef char *locstr;
42 
43 struct extraction
44 {
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;
52 };
53 
54 /* Holds a single insn code that uses an extraction method.  */
55 struct code_ptr
56 {
57   int insn_code;
58   struct code_ptr *next;
59 };
60 
61 /* All extractions needed for this machine description.  */
62 static struct extraction *extractions;
63 
64 /* All insn codes for old-style peepholes.  */
65 static struct code_ptr *peepholes;
66 
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.  */
69 
70 
71 struct accum_extract
72 {
73   vec<locstr> oplocs;
74   vec<locstr> duplocs;
75   vec<int> dupnums;
76   vec<char> pathstr;
77 };
78 
79 int line_no;
80 
81 /* Forward declarations.  */
82 static void walk_rtx (rtx, struct accum_extract *);
83 
84 static void
85 gen_insn (rtx insn, int insn_code_number)
86 {
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;
92 
93   acc.oplocs.create (10);
94   acc.duplocs.create (10);
95   acc.dupnums.create (10);
96   acc.pathstr.create (20);
97 
98   /* Walk the insn's pattern, remembering at all times the path
99      down to the walking point.  */
100 
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--)
105       {
106 	acc.pathstr.safe_push ('a' + i);
107 	walk_rtx (XVECEXP (insn, 1, i), &acc);
108 	acc.pathstr.pop ();
109       }
110 
111   link = XNEW (struct code_ptr);
112   link->insn_code = insn_code_number;
113 
114   /* See if we find something that already had this extraction method.  */
115 
116   op_count = acc.oplocs.length ();
117   dup_count = acc.duplocs.length ();
118   gcc_assert (dup_count == acc.dupnums.length ());
119 
120   for (p = extractions; p; p = p->next)
121     {
122       if (p->op_count != op_count || p->dup_count != dup_count)
123 	continue;
124 
125       for (j = 0; j < op_count; j++)
126 	{
127 	  char *a = p->oplocs[j];
128 	  char *b = acc.oplocs[j];
129 	  if (a != b && (!a || !b || strcmp (a, b)))
130 	    break;
131 	}
132 
133       if (j != op_count)
134 	continue;
135 
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;
140 
141       if (j != dup_count)
142 	continue;
143 
144       /* This extraction is the same as ours.  Just link us in.  */
145       link->next = p->insns;
146       p->insns = link;
147       goto done;
148     }
149 
150   /* Otherwise, make a new extraction method.  We stash the arrays
151      after the extraction structure in memory.  */
152 
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;
163 
164   p->oplocs = (char **)((char *)p + sizeof (struct extraction));
165   p->duplocs = p->oplocs + op_count;
166   p->dupnums = (int *)(p->duplocs + dup_count);
167 
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));
171 
172  done:
173   acc.oplocs.release ();
174   acc.duplocs.release ();
175   acc.dupnums.release ();
176   acc.pathstr.release ();
177 }
178 
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)
185 {
186   if (ix < (*vp).length ())
187     {
188       if ((*vp)[ix])
189 	{
190 	  message_with_line (line_no, "repeated operand number %d", ix);
191 	  have_error = 1;
192 	}
193       else
194         (*vp)[ix] = str;
195     }
196   else
197     {
198       while (ix > (*vp).length ())
199 	vp->safe_push (NULL);
200       vp->safe_push (str);
201     }
202 }
203 
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)
208 {
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;
214 }
215 
216 static void
217 walk_rtx (rtx x, struct accum_extract *acc)
218 {
219   RTX_CODE code;
220   int i, len, base;
221   const char *fmt;
222 
223   if (x == 0)
224     return;
225 
226   code = GET_CODE (x);
227   switch (code)
228     {
229     case PC:
230     case CC0:
231     case CONST_INT:
232     case SYMBOL_REF:
233       return;
234 
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;
240 
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));
245 
246       base = (code == MATCH_OPERATOR ? '0' : 'a');
247       for (i = XVECLEN (x, 2) - 1; i >= 0; i--)
248 	{
249 	  acc->pathstr.safe_push (base + i);
250 	  walk_rtx (XVECEXP (x, 2, i), acc);
251 	  acc->pathstr.pop ();
252         }
253       return;
254 
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));
260 
261       if (code == MATCH_DUP)
262 	break;
263 
264       base = (code == MATCH_OP_DUP ? '0' : 'a');
265       for (i = XVECLEN (x, 1) - 1; i >= 0; i--)
266         {
267 	  acc->pathstr.safe_push (base + i);
268 	  walk_rtx (XVECEXP (x, 1, i), acc);
269 	  acc->pathstr.pop ();
270         }
271       return;
272 
273     default:
274       break;
275     }
276 
277   fmt = GET_RTX_FORMAT (code);
278   len = GET_RTX_LENGTH (code);
279   for (i = 0; i < len; i++)
280     {
281       if (fmt[i] == 'e' || fmt[i] == 'u')
282 	{
283 	  acc->pathstr.safe_push ('0' + i);
284 	  walk_rtx (XEXP (x, i), acc);
285 	  acc->pathstr.pop ();
286 	}
287       else if (fmt[i] == 'E')
288 	{
289 	  int j;
290 	  for (j = XVECLEN (x, i) - 1; j >= 0; j--)
291 	    {
292 	      acc->pathstr.safe_push ('a' + j);
293 	      walk_rtx (XVECEXP (x, i, j), acc);
294 	      acc->pathstr.pop ();
295 	    }
296 	}
297     }
298 }
299 
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.  */
303 
304 static void
305 print_path (const char *path)
306 {
307   int len = strlen (path);
308   int i;
309 
310   if (len == 0)
311     {
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;
316     }
317 
318   /* We first write out the operations (XEXP or XVECEXP) in reverse
319      order, then write "pat", then the indices in forward order.  */
320 
321   for (i = len - 1; i >= 0 ; i--)
322     {
323       if (ISLOWER (path[i]))
324 	fputs ("XVECEXP (", stdout);
325       else if (ISDIGIT (path[i]))
326 	fputs ("XEXP (", stdout);
327       else
328 	gcc_unreachable ();
329     }
330 
331   fputs ("pat", stdout);
332 
333   for (i = 0; i < len; i++)
334     {
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 ();
341     }
342 }
343 
344 static void
345 print_header (void)
346 {
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.  */
350 
351   puts ("\
352 /* Generated automatically by the program `genextract'\n\
353    from the machine description file `md'.  */\n\
354 \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\
363 \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");
367 
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\
375 \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");
380 
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");
393 }
394 
395 int
396 main (int argc, char **argv)
397 {
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;
404 
405   progname = "genextract";
406 
407   if (!init_rtx_reader_args (argc, argv))
408     return (FATAL_EXIT_CODE);
409 
410   /* Read the machine description.  */
411 
412   while ((desc = read_md_rtx (&line_no, &insn_code_number)) != NULL)
413     {
414        if (GET_CODE (desc) == DEFINE_INSN)
415 	 gen_insn (desc, insn_code_number);
416 
417       else if (GET_CODE (desc) == DEFINE_PEEPHOLE)
418 	{
419 	  struct code_ptr *link = XNEW (struct code_ptr);
420 
421 	  link->insn_code = insn_code_number;
422 	  link->next = peepholes;
423 	  peepholes = link;
424 	}
425     }
426 
427   if (have_error)
428     return FATAL_EXIT_CODE;
429 
430   print_header ();
431 
432   /* Write out code to handle peepholes and the insn_codes that it should
433      be called for.  */
434   if (peepholes)
435     {
436       for (link = peepholes; link; link = link->next)
437 	printf ("    case %d:\n", link->insn_code);
438 
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");
447     }
448 
449   /* Write out all the ways to extract insn operands.  */
450   for (p = extractions; p; p = p->next)
451     {
452       for (link = p->insns; link; link = link->next)
453 	{
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);
460 	}
461 
462       for (i = 0; i < p->op_count; i++)
463 	{
464 	  if (p->oplocs[i] == 0)
465 	    {
466 	      printf ("      ro[%d] = const0_rtx;\n", i);
467 	      printf ("      ro_loc[%d] = &junk;\n", i);
468 	    }
469 	  else
470 	    {
471 	      printf ("      ro[%d] = *(ro_loc[%d] = &", i, i);
472 	      print_path (p->oplocs[i]);
473 	      puts (");");
474 	    }
475 	}
476 
477       for (i = 0; i < p->dup_count; i++)
478 	{
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]);
483 	}
484 
485       puts ("      break;\n");
486     }
487 
488   puts ("    }\n}");
489   fflush (stdout);
490   return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
491 }
492