xref: /dragonfly/contrib/gcc-8.0/gcc/genoutput.c (revision 38fd1498)
1 /* Generate code from to output assembler insns as recognized from rtl.
2    Copyright (C) 1987-2018 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 /* This program reads the machine description for the compiler target machine
22    and produces a file containing these things:
23 
24    1. An array of `struct insn_data_d', which is indexed by insn code number,
25    which contains:
26 
27      a. `name' is the name for that pattern.  Nameless patterns are
28      given a name.
29 
30      b. `output' hold either the output template, an array of output
31      templates, or an output function.
32 
33      c. `genfun' is the function to generate a body for that pattern,
34      given operands as arguments.
35 
36      d. `n_operands' is the number of distinct operands in the pattern
37      for that insn,
38 
39      e. `n_dups' is the number of match_dup's that appear in the insn's
40      pattern.  This says how many elements of `recog_data.dup_loc' are
41      significant after an insn has been recognized.
42 
43      f. `n_alternatives' is the number of alternatives in the constraints
44      of each pattern.
45 
46      g. `output_format' tells what type of thing `output' is.
47 
48      h. `operand' is the base of an array of operand data for the insn.
49 
50    2. An array of `struct insn_operand data', used by `operand' above.
51 
52      a. `predicate', an int-valued function, is the match_operand predicate
53      for this operand.
54 
55      b. `constraint' is the constraint for this operand.
56 
57      c. `address_p' indicates that the operand appears within ADDRESS
58      rtx's.
59 
60      d. `mode' is the machine mode that that operand is supposed to have.
61 
62      e. `strict_low', is nonzero for operands contained in a STRICT_LOW_PART.
63 
64      f. `eliminable', is nonzero for operands that are matched normally by
65      MATCH_OPERAND; it is zero for operands that should not be changed during
66      register elimination such as MATCH_OPERATORs.
67 
68      g. `allows_mem', is true for operands that accept MEM rtxes.
69 
70   The code number of an insn is simply its position in the machine
71   description; code numbers are assigned sequentially to entries in
72   the description, starting with code number 0.
73 
74   Thus, the following entry in the machine description
75 
76     (define_insn "clrdf"
77       [(set (match_operand:DF 0 "general_operand" "")
78 	    (const_int 0))]
79       ""
80       "clrd %0")
81 
82   assuming it is the 25th entry present, would cause
83   insn_data[24].template to be "clrd %0", and
84   insn_data[24].n_operands to be 1.  */
85 
86 #include "bconfig.h"
87 #include "system.h"
88 #include "coretypes.h"
89 #include "tm.h"
90 #include "rtl.h"
91 #include "errors.h"
92 #include "read-md.h"
93 #include "gensupport.h"
94 
95 /* No instruction can have more operands than this.  Sorry for this
96    arbitrary limit, but what machine will have an instruction with
97    this many operands?  */
98 
99 #define MAX_MAX_OPERANDS 40
100 
101 static char general_mem[] = { TARGET_MEM_CONSTRAINT, 0 };
102 
103 static int n_occurrences		(int, const char *);
104 static const char *strip_whitespace	(const char *);
105 
106 /* This counts all operands used in the md file.  The first is null.  */
107 
108 static int next_operand_number = 1;
109 
110 /* Record in this chain all information about the operands we will output.  */
111 
112 struct operand_data
113 {
114   struct operand_data *next;
115   int index;
116   const char *predicate;
117   const char *constraint;
118   machine_mode mode;
119   unsigned char n_alternatives;
120   char address_p;
121   char strict_low;
122   char eliminable;
123   char seen;
124 };
125 
126 /* Begin with a null operand at index 0.  */
127 
128 static struct operand_data null_operand =
129 {
130   0, 0, "", "", E_VOIDmode, 0, 0, 0, 0, 0
131 };
132 
133 static struct operand_data *odata = &null_operand;
134 static struct operand_data **odata_end = &null_operand.next;
135 
136 /* Must match the constants in recog.h.  */
137 
138 #define INSN_OUTPUT_FORMAT_NONE         0       /* abort */
139 #define INSN_OUTPUT_FORMAT_SINGLE       1       /* const char * */
140 #define INSN_OUTPUT_FORMAT_MULTI        2       /* const char * const * */
141 #define INSN_OUTPUT_FORMAT_FUNCTION     3       /* const char * (*)(...) */
142 
143 /* Record in this chain all information that we will output,
144    associated with the code number of the insn.  */
145 
146 struct data
147 {
148   struct data *next;
149   const char *name;
150   const char *template_code;
151   file_location loc;
152   int code_number;
153   int n_generator_args;		/* Number of arguments passed to generator */
154   int n_operands;		/* Number of operands this insn recognizes */
155   int n_dups;			/* Number times match_dup appears in pattern */
156   int n_alternatives;		/* Number of alternatives in each constraint */
157   int operand_number;		/* Operand index in the big array.  */
158   int output_format;		/* INSN_OUTPUT_FORMAT_*.  */
159   struct operand_data operand[MAX_MAX_OPERANDS];
160 };
161 
162 /* This variable points to the first link in the insn chain.  */
163 static struct data *idata;
164 
165 /* This variable points to the end of the insn chain.  This is where
166    everything relevant from the machien description is appended to.  */
167 static struct data **idata_end;
168 
169 
170 static void output_prologue (void);
171 static void output_operand_data (void);
172 static void output_insn_data (void);
173 static void output_get_insn_name (void);
174 static void scan_operands (struct data *, rtx, int, int);
175 static int compare_operands (struct operand_data *,
176 			     struct operand_data *);
177 static void place_operands (struct data *);
178 static void process_template (struct data *, const char *);
179 static void validate_insn_alternatives (struct data *);
180 static void validate_insn_operands (struct data *);
181 
182 struct constraint_data
183 {
184   struct constraint_data *next_this_letter;
185   file_location loc;
186   unsigned int namelen;
187   char name[1];
188 };
189 
190 /* All machine-independent constraint characters (except digits) that
191    are handled outside the define*_constraint mechanism.  */
192 static const char indep_constraints[] = ",=+%*?!^$#&g";
193 
194 static struct constraint_data *
195 constraints_by_letter_table[1 << CHAR_BIT];
196 
197 static int mdep_constraint_len (const char *, file_location, int);
198 static void note_constraint (md_rtx_info *);
199 
200 static void
output_prologue(void)201 output_prologue (void)
202 {
203   printf ("/* Generated automatically by the program `genoutput'\n\
204    from the machine description file `md'.  */\n\n");
205 
206   printf ("#define IN_TARGET_CODE 1\n");
207   printf ("#include \"config.h\"\n");
208   printf ("#include \"system.h\"\n");
209   printf ("#include \"coretypes.h\"\n");
210   printf ("#include \"backend.h\"\n");
211   printf ("#include \"predict.h\"\n");
212   printf ("#include \"tree.h\"\n");
213   printf ("#include \"rtl.h\"\n");
214   printf ("#include \"flags.h\"\n");
215   printf ("#include \"alias.h\"\n");
216   printf ("#include \"varasm.h\"\n");
217   printf ("#include \"stor-layout.h\"\n");
218   printf ("#include \"calls.h\"\n");
219   printf ("#include \"insn-config.h\"\n");
220   printf ("#include \"expmed.h\"\n");
221   printf ("#include \"dojump.h\"\n");
222   printf ("#include \"explow.h\"\n");
223   printf ("#include \"memmodel.h\"\n");
224   printf ("#include \"emit-rtl.h\"\n");
225   printf ("#include \"stmt.h\"\n");
226   printf ("#include \"expr.h\"\n");
227   printf ("#include \"insn-codes.h\"\n");
228   printf ("#include \"tm_p.h\"\n");
229   printf ("#include \"regs.h\"\n");
230   printf ("#include \"conditions.h\"\n");
231   printf ("#include \"insn-attr.h\"\n\n");
232   printf ("#include \"recog.h\"\n\n");
233   printf ("#include \"diagnostic-core.h\"\n");
234   printf ("#include \"output.h\"\n");
235   printf ("#include \"target.h\"\n");
236   printf ("#include \"tm-constrs.h\"\n");
237 }
238 
239 static void
output_operand_data(void)240 output_operand_data (void)
241 {
242   struct operand_data *d;
243 
244   printf ("\nstatic const struct insn_operand_data operand_data[] = \n{\n");
245 
246   for (d = odata; d; d = d->next)
247     {
248       struct pred_data *pred;
249 
250       printf ("  {\n");
251 
252       printf ("    %s,\n",
253 	      d->predicate && d->predicate[0] ? d->predicate : "0");
254 
255       printf ("    \"%s\",\n", d->constraint ? d->constraint : "");
256 
257       printf ("    E_%smode,\n", GET_MODE_NAME (d->mode));
258 
259       printf ("    %d,\n", d->strict_low);
260 
261       printf ("    %d,\n", d->constraint == NULL ? 1 : 0);
262 
263       printf ("    %d,\n", d->eliminable);
264 
265       pred = NULL;
266       if (d->predicate)
267 	pred = lookup_predicate (d->predicate);
268       printf ("    %d\n", pred && pred->codes[MEM]);
269 
270       printf ("  },\n");
271     }
272   printf ("};\n\n\n");
273 }
274 
275 static void
output_insn_data(void)276 output_insn_data (void)
277 {
278   struct data *d;
279   int name_offset = 0;
280   int next_name_offset;
281   const char * last_name = 0;
282   const char * next_name = 0;
283   struct data *n;
284 
285   for (n = idata, next_name_offset = 1; n; n = n->next, next_name_offset++)
286     if (n->name)
287       {
288 	next_name = n->name;
289 	break;
290       }
291 
292   printf ("#if GCC_VERSION >= 2007\n__extension__\n#endif\n");
293   printf ("\nconst struct insn_data_d insn_data[] = \n{\n");
294 
295   for (d = idata; d; d = d->next)
296     {
297       printf ("  /* %s:%d */\n", d->loc.filename, d->loc.lineno);
298       printf ("  {\n");
299 
300       if (d->name)
301 	{
302 	  printf ("    \"%s\",\n", d->name);
303 	  name_offset = 0;
304 	  last_name = d->name;
305 	  next_name = 0;
306 	  for (n = d->next, next_name_offset = 1; n;
307 	       n = n->next, next_name_offset++)
308 	    {
309 	      if (n->name)
310 		{
311 		  next_name = n->name;
312 		  break;
313 		}
314 	    }
315 	}
316       else
317 	{
318 	  name_offset++;
319 	  if (next_name && (last_name == 0
320 			    || name_offset > next_name_offset / 2))
321 	    printf ("    \"%s-%d\",\n", next_name,
322 		    next_name_offset - name_offset);
323 	  else
324 	    printf ("    \"%s+%d\",\n", last_name, name_offset);
325 	}
326 
327       switch (d->output_format)
328 	{
329 	case INSN_OUTPUT_FORMAT_NONE:
330 	  printf ("#if HAVE_DESIGNATED_UNION_INITIALIZERS\n");
331 	  printf ("    { 0 },\n");
332 	  printf ("#else\n");
333 	  printf ("    { 0, 0, 0 },\n");
334 	  printf ("#endif\n");
335 	  break;
336 	case INSN_OUTPUT_FORMAT_SINGLE:
337 	  {
338 	    const char *p = d->template_code;
339 	    char prev = 0;
340 
341 	    printf ("#if HAVE_DESIGNATED_UNION_INITIALIZERS\n");
342 	    printf ("    { .single =\n");
343 	    printf ("#else\n");
344 	    printf ("    {\n");
345 	    printf ("#endif\n");
346 	    printf ("    \"");
347 	    while (*p)
348 	      {
349 		if (IS_VSPACE (*p) && prev != '\\')
350 		  {
351 		    /* Preserve two consecutive \n's or \r's, but treat \r\n
352 		       as a single newline.  */
353 		    if (*p == '\n' && prev != '\r')
354 		      printf ("\\n\\\n");
355 		  }
356 		else
357 		  putchar (*p);
358 		prev = *p;
359 		++p;
360 	      }
361 	    printf ("\",\n");
362 	    printf ("#if HAVE_DESIGNATED_UNION_INITIALIZERS\n");
363 	    printf ("    },\n");
364 	    printf ("#else\n");
365 	    printf ("    0, 0 },\n");
366 	    printf ("#endif\n");
367 	  }
368 	  break;
369 	case INSN_OUTPUT_FORMAT_MULTI:
370 	  printf ("#if HAVE_DESIGNATED_UNION_INITIALIZERS\n");
371 	  printf ("    { .multi = output_%d },\n", d->code_number);
372 	  printf ("#else\n");
373 	  printf ("    { 0, output_%d, 0 },\n", d->code_number);
374 	  printf ("#endif\n");
375 	  break;
376 	case INSN_OUTPUT_FORMAT_FUNCTION:
377 	  printf ("#if HAVE_DESIGNATED_UNION_INITIALIZERS\n");
378 	  printf ("    { .function = output_%d },\n", d->code_number);
379 	  printf ("#else\n");
380 	  printf ("    { 0, 0, output_%d },\n", d->code_number);
381 	  printf ("#endif\n");
382 	  break;
383 	default:
384 	  gcc_unreachable ();
385 	}
386 
387       if (d->name && d->name[0] != '*')
388 	printf ("    { (insn_gen_fn::stored_funcptr) gen_%s },\n", d->name);
389       else
390 	printf ("    { 0 },\n");
391 
392       printf ("    &operand_data[%d],\n", d->operand_number);
393       printf ("    %d,\n", d->n_generator_args);
394       printf ("    %d,\n", d->n_operands);
395       printf ("    %d,\n", d->n_dups);
396       printf ("    %d,\n", d->n_alternatives);
397       printf ("    %d\n", d->output_format);
398 
399       printf ("  },\n");
400     }
401   printf ("};\n\n\n");
402 }
403 
404 static void
output_get_insn_name(void)405 output_get_insn_name (void)
406 {
407   printf ("const char *\n");
408   printf ("get_insn_name (int code)\n");
409   printf ("{\n");
410   printf ("  if (code == NOOP_MOVE_INSN_CODE)\n");
411   printf ("    return \"NOOP_MOVE\";\n");
412   printf ("  else\n");
413   printf ("    return insn_data[code].name;\n");
414   printf ("}\n");
415 }
416 
417 
418 /* Stores the operand data into `d->operand[i]'.
419 
420    THIS_ADDRESS_P is nonzero if the containing rtx was an ADDRESS.
421    THIS_STRICT_LOW is nonzero if the containing rtx was a STRICT_LOW_PART.  */
422 
423 static void
scan_operands(struct data * d,rtx part,int this_address_p,int this_strict_low)424 scan_operands (struct data *d, rtx part, int this_address_p,
425 	       int this_strict_low)
426 {
427   int i, j;
428   const char *format_ptr;
429   int opno;
430 
431   if (part == 0)
432     return;
433 
434   switch (GET_CODE (part))
435     {
436     case MATCH_OPERAND:
437       opno = XINT (part, 0);
438       if (opno >= MAX_MAX_OPERANDS)
439 	{
440 	  error_at (d->loc, "maximum number of operands exceeded");
441 	  return;
442 	}
443       if (d->operand[opno].seen)
444 	error_at (d->loc, "repeated operand number %d\n", opno);
445 
446       d->operand[opno].seen = 1;
447       d->operand[opno].mode = GET_MODE (part);
448       d->operand[opno].strict_low = this_strict_low;
449       d->operand[opno].predicate = XSTR (part, 1);
450       d->operand[opno].constraint = strip_whitespace (XSTR (part, 2));
451       d->operand[opno].n_alternatives
452 	= n_occurrences (',', d->operand[opno].constraint) + 1;
453       d->operand[opno].address_p = this_address_p;
454       d->operand[opno].eliminable = 1;
455       return;
456 
457     case MATCH_SCRATCH:
458       opno = XINT (part, 0);
459       if (opno >= MAX_MAX_OPERANDS)
460 	{
461 	  error_at (d->loc, "maximum number of operands exceeded");
462 	  return;
463 	}
464       if (d->operand[opno].seen)
465 	error_at (d->loc, "repeated operand number %d\n", opno);
466 
467       d->operand[opno].seen = 1;
468       d->operand[opno].mode = GET_MODE (part);
469       d->operand[opno].strict_low = 0;
470       d->operand[opno].predicate = "scratch_operand";
471       d->operand[opno].constraint = strip_whitespace (XSTR (part, 1));
472       d->operand[opno].n_alternatives
473 	= n_occurrences (',', d->operand[opno].constraint) + 1;
474       d->operand[opno].address_p = 0;
475       d->operand[opno].eliminable = 0;
476       return;
477 
478     case MATCH_OPERATOR:
479     case MATCH_PARALLEL:
480       opno = XINT (part, 0);
481       if (opno >= MAX_MAX_OPERANDS)
482 	{
483 	  error_at (d->loc, "maximum number of operands exceeded");
484 	  return;
485 	}
486       if (d->operand[opno].seen)
487 	error_at (d->loc, "repeated operand number %d\n", opno);
488 
489       d->operand[opno].seen = 1;
490       d->operand[opno].mode = GET_MODE (part);
491       d->operand[opno].strict_low = 0;
492       d->operand[opno].predicate = XSTR (part, 1);
493       d->operand[opno].constraint = 0;
494       d->operand[opno].address_p = 0;
495       d->operand[opno].eliminable = 0;
496       for (i = 0; i < XVECLEN (part, 2); i++)
497 	scan_operands (d, XVECEXP (part, 2, i), 0, 0);
498       return;
499 
500     case STRICT_LOW_PART:
501       scan_operands (d, XEXP (part, 0), 0, 1);
502       return;
503 
504     default:
505       break;
506     }
507 
508   format_ptr = GET_RTX_FORMAT (GET_CODE (part));
509 
510   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (part)); i++)
511     switch (*format_ptr++)
512       {
513       case 'e':
514       case 'u':
515 	scan_operands (d, XEXP (part, i), 0, 0);
516 	break;
517       case 'E':
518 	if (XVEC (part, i) != NULL)
519 	  for (j = 0; j < XVECLEN (part, i); j++)
520 	    scan_operands (d, XVECEXP (part, i, j), 0, 0);
521 	break;
522       }
523 }
524 
525 /* Compare two operands for content equality.  */
526 
527 static int
compare_operands(struct operand_data * d0,struct operand_data * d1)528 compare_operands (struct operand_data *d0, struct operand_data *d1)
529 {
530   const char *p0, *p1;
531 
532   p0 = d0->predicate;
533   if (!p0)
534     p0 = "";
535   p1 = d1->predicate;
536   if (!p1)
537     p1 = "";
538   if (strcmp (p0, p1) != 0)
539     return 0;
540 
541   p0 = d0->constraint;
542   if (!p0)
543     p0 = "";
544   p1 = d1->constraint;
545   if (!p1)
546     p1 = "";
547   if (strcmp (p0, p1) != 0)
548     return 0;
549 
550   if (d0->mode != d1->mode)
551     return 0;
552 
553   if (d0->strict_low != d1->strict_low)
554     return 0;
555 
556   if (d0->eliminable != d1->eliminable)
557     return 0;
558 
559   return 1;
560 }
561 
562 /* Scan the list of operands we've already committed to output and either
563    find a subsequence that is the same, or allocate a new one at the end.  */
564 
565 static void
place_operands(struct data * d)566 place_operands (struct data *d)
567 {
568   struct operand_data *od, *od2;
569   int i;
570 
571   if (d->n_operands == 0)
572     {
573       d->operand_number = 0;
574       return;
575     }
576 
577   /* Brute force substring search.  */
578   for (od = odata, i = 0; od; od = od->next, i = 0)
579     if (compare_operands (od, &d->operand[0]))
580       {
581 	od2 = od->next;
582 	i = 1;
583 	while (1)
584 	  {
585 	    if (i == d->n_operands)
586 	      goto full_match;
587 	    if (od2 == NULL)
588 	      goto partial_match;
589 	    if (! compare_operands (od2, &d->operand[i]))
590 	      break;
591 	    ++i, od2 = od2->next;
592 	  }
593       }
594 
595   /* Either partial match at the end of the list, or no match.  In either
596      case, we tack on what operands are remaining to the end of the list.  */
597  partial_match:
598   d->operand_number = next_operand_number - i;
599   for (; i < d->n_operands; ++i)
600     {
601       od2 = &d->operand[i];
602       *odata_end = od2;
603       odata_end = &od2->next;
604       od2->index = next_operand_number++;
605     }
606   *odata_end = NULL;
607   return;
608 
609  full_match:
610   d->operand_number = od->index;
611   return;
612 }
613 
614 
615 /* Process an assembler template from a define_insn or a define_peephole.
616    It is either the assembler code template, a list of assembler code
617    templates, or C code to generate the assembler code template.  */
618 
619 static void
process_template(struct data * d,const char * template_code)620 process_template (struct data *d, const char *template_code)
621 {
622   const char *cp;
623   int i;
624 
625   /* Templates starting with * contain straight code to be run.  */
626   if (template_code[0] == '*')
627     {
628       d->template_code = 0;
629       d->output_format = INSN_OUTPUT_FORMAT_FUNCTION;
630 
631       puts ("\nstatic const char *");
632       printf ("output_%d (rtx *operands ATTRIBUTE_UNUSED, rtx_insn *insn ATTRIBUTE_UNUSED)\n",
633 	      d->code_number);
634       puts ("{");
635       rtx_reader_ptr->print_md_ptr_loc (template_code);
636       puts (template_code + 1);
637       puts ("}");
638     }
639 
640   /* If the assembler code template starts with a @ it is a newline-separated
641      list of assembler code templates, one for each alternative.  */
642   else if (template_code[0] == '@')
643     {
644       int found_star = 0;
645 
646       for (cp = &template_code[1]; *cp; )
647 	{
648 	  while (ISSPACE (*cp))
649 	    cp++;
650 	  if (*cp == '*')
651 	    found_star = 1;
652 	  while (!IS_VSPACE (*cp) && *cp != '\0')
653 	    ++cp;
654 	}
655       d->template_code = 0;
656       if (found_star)
657 	{
658 	  d->output_format = INSN_OUTPUT_FORMAT_FUNCTION;
659 	  puts ("\nstatic const char *");
660 	  printf ("output_%d (rtx *operands ATTRIBUTE_UNUSED, "
661 		  "rtx_insn *insn ATTRIBUTE_UNUSED)\n", d->code_number);
662 	  puts ("{");
663 	  puts ("  switch (which_alternative)\n    {");
664 	}
665       else
666 	{
667 	  d->output_format = INSN_OUTPUT_FORMAT_MULTI;
668 	  printf ("\nstatic const char * const output_%d[] = {\n",
669 		  d->code_number);
670 	}
671 
672       for (i = 0, cp = &template_code[1]; *cp; )
673 	{
674 	  const char *ep, *sp, *bp;
675 
676 	  while (ISSPACE (*cp))
677 	    cp++;
678 
679 	  bp = cp;
680 	  if (found_star)
681 	    {
682 	      printf ("    case %d:", i);
683 	      if (*cp == '*')
684 		{
685 		  printf ("\n      ");
686 		  cp++;
687 		}
688 	      else
689 		printf (" return \"");
690 	    }
691 	  else
692 	    printf ("  \"");
693 
694 	  for (ep = sp = cp; !IS_VSPACE (*ep) && *ep != '\0'; ++ep)
695 	    if (!ISSPACE (*ep))
696 	      sp = ep + 1;
697 
698 	  if (sp != ep)
699 	    message_at (d->loc, "trailing whitespace in output template");
700 
701 	  while (cp < sp)
702 	    {
703 	      putchar (*cp);
704 	      cp++;
705 	    }
706 
707 	  if (!found_star)
708 	    puts ("\",");
709 	  else if (*bp != '*')
710 	    puts ("\";");
711 	  else
712 	    {
713 	      /* The usual action will end with a return.
714 		 If there is neither break or return at the end, this is
715 		 assumed to be intentional; this allows to have multiple
716 		 consecutive alternatives share some code.  */
717 	      puts ("");
718 	    }
719 	  i++;
720 	}
721       if (i == 1)
722 	message_at (d->loc, "'@' is redundant for output template with"
723 		    " single alternative");
724       if (i != d->n_alternatives)
725 	error_at (d->loc, "wrong number of alternatives in the output"
726 		  " template");
727 
728       if (found_star)
729 	puts ("      default: gcc_unreachable ();\n    }\n}");
730       else
731 	printf ("};\n");
732     }
733   else
734     {
735       d->template_code = template_code;
736       d->output_format = INSN_OUTPUT_FORMAT_SINGLE;
737     }
738 }
739 
740 /* Check insn D for consistency in number of constraint alternatives.  */
741 
742 static void
validate_insn_alternatives(struct data * d)743 validate_insn_alternatives (struct data *d)
744 {
745   int n = 0, start;
746 
747   /* Make sure all the operands have the same number of alternatives
748      in their constraints.  Let N be that number.  */
749   for (start = 0; start < d->n_operands; start++)
750     if (d->operand[start].n_alternatives > 0)
751       {
752 	int len, i;
753 	const char *p;
754 	char c;
755 	int which_alternative = 0;
756 	int alternative_count_unsure = 0;
757 	bool seen_write = false;
758 
759 	for (p = d->operand[start].constraint; (c = *p); p += len)
760 	  {
761 	    if ((c == '%' || c == '=' || c == '+')
762 		&& p != d->operand[start].constraint)
763 	      error_at (d->loc, "character '%c' can only be used at the"
764 			" beginning of a constraint string", c);
765 
766 	    if (c == '=' || c == '+')
767 	      seen_write = true;
768 
769 	    /* Earlyclobber operands must always be marked write-only
770 	       or read/write.  */
771 	    if (!seen_write && c == '&')
772 	      error_at (d->loc, "earlyclobber operands may not be"
773 			" read-only in alternative %d", which_alternative);
774 
775 	    if (ISSPACE (c) || strchr (indep_constraints, c))
776 	      len = 1;
777 	    else if (ISDIGIT (c))
778 	      {
779 		const char *q = p;
780 		do
781 		  q++;
782 		while (ISDIGIT (*q));
783 		len = q - p;
784 	      }
785 	    else
786 	      len = mdep_constraint_len (p, d->loc, start);
787 
788 	    if (c == ',')
789 	      {
790 	        which_alternative++;
791 		continue;
792 	      }
793 
794 	    for (i = 1; i < len; i++)
795 	      if (p[i] == '\0')
796 		{
797 		  error_at (d->loc, "NUL in alternative %d of operand %d",
798 			    which_alternative, start);
799 		  alternative_count_unsure = 1;
800 		  break;
801 		}
802 	      else if (strchr (",#*", p[i]))
803 		{
804 		  error_at (d->loc, "'%c' in alternative %d of operand %d",
805 			    p[i], which_alternative, start);
806 		  alternative_count_unsure = 1;
807 		}
808 	  }
809 	if (!alternative_count_unsure)
810 	  {
811 	    if (n == 0)
812 	      n = d->operand[start].n_alternatives;
813 	    else if (n != d->operand[start].n_alternatives)
814 	      error_at (d->loc, "wrong number of alternatives in operand %d",
815 			start);
816 	  }
817       }
818 
819   /* Record the insn's overall number of alternatives.  */
820   d->n_alternatives = n;
821 }
822 
823 /* Verify that there are no gaps in operand numbers for INSNs.  */
824 
825 static void
validate_insn_operands(struct data * d)826 validate_insn_operands (struct data *d)
827 {
828   int i;
829 
830   for (i = 0; i < d->n_operands; ++i)
831     if (d->operand[i].seen == 0)
832       error_at (d->loc, "missing operand %d", i);
833 }
834 
835 static void
validate_optab_operands(struct data * d)836 validate_optab_operands (struct data *d)
837 {
838   if (!d->name || d->name[0] == '\0' || d->name[0] == '*')
839     return;
840 
841   /* Miscellaneous tests.  */
842   if (strncmp (d->name, "cstore", 6) == 0
843       && d->name[strlen (d->name) - 1] == '4'
844       && d->operand[0].mode == VOIDmode)
845     {
846       message_at (d->loc, "missing mode for operand 0 of cstore");
847       have_error = 1;
848     }
849 }
850 
851 /* Look at a define_insn just read.  Assign its code number.  Record
852    on idata the template and the number of arguments.  If the insn has
853    a hairy output action, output a function for now.  */
854 
855 static void
gen_insn(md_rtx_info * info)856 gen_insn (md_rtx_info *info)
857 {
858   struct pattern_stats stats;
859   rtx insn = info->def;
860   data *d = new data;
861   int i;
862 
863   d->code_number = info->index;
864   d->loc = info->loc;
865   if (XSTR (insn, 0)[0])
866     d->name = XSTR (insn, 0);
867   else
868     d->name = 0;
869 
870   /* Build up the list in the same order as the insns are seen
871      in the machine description.  */
872   d->next = 0;
873   *idata_end = d;
874   idata_end = &d->next;
875 
876   memset (d->operand, 0, sizeof (d->operand));
877 
878   for (i = 0; i < XVECLEN (insn, 1); i++)
879     scan_operands (d, XVECEXP (insn, 1, i), 0, 0);
880 
881   get_pattern_stats (&stats, XVEC (insn, 1));
882   d->n_generator_args = stats.num_generator_args;
883   d->n_operands = stats.num_insn_operands;
884   d->n_dups = stats.num_dups;
885 
886   validate_insn_operands (d);
887   validate_insn_alternatives (d);
888   validate_optab_operands (d);
889   place_operands (d);
890   process_template (d, XTMPL (insn, 3));
891 }
892 
893 /* Look at a define_peephole just read.  Assign its code number.
894    Record on idata the template and the number of arguments.
895    If the insn has a hairy output action, output it now.  */
896 
897 static void
gen_peephole(md_rtx_info * info)898 gen_peephole (md_rtx_info *info)
899 {
900   struct pattern_stats stats;
901   data *d = new data;
902   int i;
903 
904   d->code_number = info->index;
905   d->loc = info->loc;
906   d->name = 0;
907 
908   /* Build up the list in the same order as the insns are seen
909      in the machine description.  */
910   d->next = 0;
911   *idata_end = d;
912   idata_end = &d->next;
913 
914   memset (d->operand, 0, sizeof (d->operand));
915 
916   /* Get the number of operands by scanning all the patterns of the
917      peephole optimizer.  But ignore all the rest of the information
918      thus obtained.  */
919   rtx peep = info->def;
920   for (i = 0; i < XVECLEN (peep, 0); i++)
921     scan_operands (d, XVECEXP (peep, 0, i), 0, 0);
922 
923   get_pattern_stats (&stats, XVEC (peep, 0));
924   d->n_generator_args = 0;
925   d->n_operands = stats.num_insn_operands;
926   d->n_dups = 0;
927 
928   validate_insn_alternatives (d);
929   place_operands (d);
930   process_template (d, XTMPL (peep, 2));
931 }
932 
933 /* Process a define_expand just read.  Assign its code number,
934    only for the purposes of `insn_gen_function'.  */
935 
936 static void
gen_expand(md_rtx_info * info)937 gen_expand (md_rtx_info *info)
938 {
939   struct pattern_stats stats;
940   rtx insn = info->def;
941   data *d = new data;
942   int i;
943 
944   d->code_number = info->index;
945   d->loc = info->loc;
946   if (XSTR (insn, 0)[0])
947     d->name = XSTR (insn, 0);
948   else
949     d->name = 0;
950 
951   /* Build up the list in the same order as the insns are seen
952      in the machine description.  */
953   d->next = 0;
954   *idata_end = d;
955   idata_end = &d->next;
956 
957   memset (d->operand, 0, sizeof (d->operand));
958 
959   /* Scan the operands to get the specified predicates and modes,
960      since expand_binop needs to know them.  */
961 
962   if (XVEC (insn, 1))
963     for (i = 0; i < XVECLEN (insn, 1); i++)
964       scan_operands (d, XVECEXP (insn, 1, i), 0, 0);
965 
966   get_pattern_stats (&stats, XVEC (insn, 1));
967   d->n_generator_args = stats.num_generator_args;
968   d->n_operands = stats.num_insn_operands;
969   d->n_dups = stats.num_dups;
970   d->template_code = 0;
971   d->output_format = INSN_OUTPUT_FORMAT_NONE;
972 
973   validate_insn_alternatives (d);
974   validate_optab_operands (d);
975   place_operands (d);
976 }
977 
978 static void
init_insn_for_nothing(void)979 init_insn_for_nothing (void)
980 {
981   idata = XCNEW (struct data);
982   new (idata) data ();
983   idata->name = "*placeholder_for_nothing";
984   idata->loc = file_location ("<internal>", 0, 0);
985   idata_end = &idata->next;
986 }
987 
988 extern int main (int, const char **);
989 
990 int
main(int argc,const char ** argv)991 main (int argc, const char **argv)
992 {
993   progname = "genoutput";
994 
995   init_insn_for_nothing ();
996 
997   if (!init_rtx_reader_args (argc, argv))
998     return (FATAL_EXIT_CODE);
999 
1000   output_prologue ();
1001 
1002   /* Read the machine description.  */
1003 
1004   md_rtx_info info;
1005   while (read_md_rtx (&info))
1006     switch (GET_CODE (info.def))
1007       {
1008       case DEFINE_INSN:
1009 	gen_insn (&info);
1010 	break;
1011 
1012       case DEFINE_PEEPHOLE:
1013 	gen_peephole (&info);
1014 	break;
1015 
1016       case DEFINE_EXPAND:
1017 	gen_expand (&info);
1018 	break;
1019 
1020       case DEFINE_CONSTRAINT:
1021       case DEFINE_REGISTER_CONSTRAINT:
1022       case DEFINE_ADDRESS_CONSTRAINT:
1023       case DEFINE_MEMORY_CONSTRAINT:
1024       case DEFINE_SPECIAL_MEMORY_CONSTRAINT:
1025 	note_constraint (&info);
1026 	break;
1027 
1028       default:
1029 	break;
1030       }
1031 
1032   printf ("\n\n");
1033   output_operand_data ();
1034   output_insn_data ();
1035   output_get_insn_name ();
1036 
1037   fflush (stdout);
1038   return (ferror (stdout) != 0 || have_error
1039 	? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
1040 }
1041 
1042 /* Return the number of occurrences of character C in string S or
1043    -1 if S is the null string.  */
1044 
1045 static int
n_occurrences(int c,const char * s)1046 n_occurrences (int c, const char *s)
1047 {
1048   int n = 0;
1049 
1050   if (s == 0 || *s == '\0')
1051     return -1;
1052 
1053   while (*s)
1054     n += (*s++ == c);
1055 
1056   return n;
1057 }
1058 
1059 /* Remove whitespace in `s' by moving up characters until the end.
1060    Return a new string.  */
1061 
1062 static const char *
strip_whitespace(const char * s)1063 strip_whitespace (const char *s)
1064 {
1065   char *p, *q;
1066   char ch;
1067 
1068   if (s == 0)
1069     return 0;
1070 
1071   p = q = XNEWVEC (char, strlen (s) + 1);
1072   while ((ch = *s++) != '\0')
1073     if (! ISSPACE (ch))
1074       *p++ = ch;
1075 
1076   *p = '\0';
1077   return q;
1078 }
1079 
1080 /* Record just enough information about the constraint in *INFO to allow
1081    checking of operand constraint strings above, in validate_insn_alternatives.
1082    Does not validate most properties of the constraint itself; does enforce
1083    no duplicate names, no overlap with MI constraints, and no prefixes.  */
1084 static void
note_constraint(md_rtx_info * info)1085 note_constraint (md_rtx_info *info)
1086 {
1087   rtx exp = info->def;
1088   const char *name = XSTR (exp, 0);
1089   struct constraint_data **iter, **slot, *new_cdata;
1090 
1091   if (strcmp (name, "TARGET_MEM_CONSTRAINT") == 0)
1092     name = general_mem;
1093   unsigned int namelen = strlen (name);
1094 
1095   if (strchr (indep_constraints, name[0]))
1096     {
1097       if (name[1] == '\0')
1098 	error_at (info->loc, "constraint letter '%s' cannot be "
1099 		  "redefined by the machine description", name);
1100       else
1101 	error_at (info->loc, "constraint name '%s' cannot be defined by "
1102 		  "the machine description, as it begins with '%c'",
1103 		  name, name[0]);
1104       return;
1105     }
1106 
1107   slot = &constraints_by_letter_table[(unsigned int)name[0]];
1108   for (iter = slot; *iter; iter = &(*iter)->next_this_letter)
1109     {
1110       /* This causes slot to end up pointing to the
1111 	 next_this_letter field of the last constraint with a name
1112 	 of equal or greater length than the new constraint; hence
1113 	 the new constraint will be inserted after all previous
1114 	 constraints with names of the same length.  */
1115       if ((*iter)->namelen >= namelen)
1116 	slot = iter;
1117 
1118       if (!strcmp ((*iter)->name, name))
1119 	{
1120 	  error_at (info->loc, "redefinition of constraint '%s'", name);
1121 	  message_at ((*iter)->loc, "previous definition is here");
1122 	  return;
1123 	}
1124       else if (!strncmp ((*iter)->name, name, (*iter)->namelen))
1125 	{
1126 	  error_at (info->loc, "defining constraint '%s' here", name);
1127 	  message_at ((*iter)->loc, "renders constraint '%s' "
1128 		      "(defined here) a prefix", (*iter)->name);
1129 	  return;
1130 	}
1131       else if (!strncmp ((*iter)->name, name, namelen))
1132 	{
1133 	  error_at (info->loc, "constraint '%s' is a prefix", name);
1134 	  message_at ((*iter)->loc, "of constraint '%s' "
1135 		      "(defined here)", (*iter)->name);
1136 	  return;
1137 	}
1138     }
1139   new_cdata = XNEWVAR (struct constraint_data,
1140 		       sizeof (struct constraint_data) + namelen);
1141   new (new_cdata) constraint_data ();
1142   strcpy (CONST_CAST (char *, new_cdata->name), name);
1143   new_cdata->namelen = namelen;
1144   new_cdata->loc = info->loc;
1145   new_cdata->next_this_letter = *slot;
1146   *slot = new_cdata;
1147 }
1148 
1149 /* Return the length of the constraint name beginning at position S
1150    of an operand constraint string, or issue an error message if there
1151    is no such constraint.  Does not expect to be called for generic
1152    constraints.  */
1153 static int
mdep_constraint_len(const char * s,file_location loc,int opno)1154 mdep_constraint_len (const char *s, file_location loc, int opno)
1155 {
1156   struct constraint_data *p;
1157 
1158   p = constraints_by_letter_table[(unsigned int)s[0]];
1159 
1160   if (p)
1161     for (; p; p = p->next_this_letter)
1162       if (!strncmp (s, p->name, p->namelen))
1163 	return p->namelen;
1164 
1165   error_at (loc, "error: undefined machine-specific constraint "
1166 	    "at this point: \"%s\"", s);
1167   message_at (loc, "note:  in operand %d", opno);
1168   return 1; /* safe */
1169 }
1170