2014-04-15 Richard Biener <rguenther@suse.de>
[official-gcc.git] / gcc / genoutput.c
blob26fb1acfde72c04b2be38c12af64433d8cdcbdd5
1 /* Generate code from to output assembler insns as recognized from rtl.
2 Copyright (C) 1987-2014 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 /* This program reads the machine description for the compiler target machine
22 and produces a file containing these things:
24 1. An array of `struct insn_data_d', which is indexed by insn code number,
25 which contains:
27 a. `name' is the name for that pattern. Nameless patterns are
28 given a name.
30 b. `output' hold either the output template, an array of output
31 templates, or an output function.
33 c. `genfun' is the function to generate a body for that pattern,
34 given operands as arguments.
36 d. `n_operands' is the number of distinct operands in the pattern
37 for that insn,
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.
43 f. `n_alternatives' is the number of alternatives in the constraints
44 of each pattern.
46 g. `output_format' tells what type of thing `output' is.
48 h. `operand' is the base of an array of operand data for the insn.
50 2. An array of `struct insn_operand data', used by `operand' above.
52 a. `predicate', an int-valued function, is the match_operand predicate
53 for this operand.
55 b. `constraint' is the constraint for this operand.
57 c. `address_p' indicates that the operand appears within ADDRESS
58 rtx's.
60 d. `mode' is the machine mode that that operand is supposed to have.
62 e. `strict_low', is nonzero for operands contained in a STRICT_LOW_PART.
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.
68 g. `allows_mem', is true for operands that accept MEM rtxes.
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.
74 Thus, the following entry in the machine description
76 (define_insn "clrdf"
77 [(set (match_operand:DF 0 "general_operand" "")
78 (const_int 0))]
80 "clrd %0")
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. */
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"
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? */
99 #define MAX_MAX_OPERANDS 40
101 static int n_occurrences (int, const char *);
102 static const char *strip_whitespace (const char *);
104 /* insns in the machine description are assigned sequential code numbers
105 that are used by insn-recog.c (produced by genrecog) to communicate
106 to insn-output.c (produced by this program). */
108 static int next_code_number;
110 /* This counts all definitions in the md file,
111 for the sake of error messages. */
113 static int next_index_number;
115 /* This counts all operands used in the md file. The first is null. */
117 static int next_operand_number = 1;
119 /* Record in this chain all information about the operands we will output. */
121 struct operand_data
123 struct operand_data *next;
124 int index;
125 const char *predicate;
126 const char *constraint;
127 enum machine_mode mode;
128 unsigned char n_alternatives;
129 char address_p;
130 char strict_low;
131 char eliminable;
132 char seen;
135 /* Begin with a null operand at index 0. */
137 static struct operand_data null_operand =
139 0, 0, "", "", VOIDmode, 0, 0, 0, 0, 0
142 static struct operand_data *odata = &null_operand;
143 static struct operand_data **odata_end = &null_operand.next;
145 /* Must match the constants in recog.h. */
147 #define INSN_OUTPUT_FORMAT_NONE 0 /* abort */
148 #define INSN_OUTPUT_FORMAT_SINGLE 1 /* const char * */
149 #define INSN_OUTPUT_FORMAT_MULTI 2 /* const char * const * */
150 #define INSN_OUTPUT_FORMAT_FUNCTION 3 /* const char * (*)(...) */
152 /* Record in this chain all information that we will output,
153 associated with the code number of the insn. */
155 struct data
157 struct data *next;
158 const char *name;
159 const char *template_code;
160 int code_number;
161 int index_number;
162 const char *filename;
163 int lineno;
164 int n_generator_args; /* Number of arguments passed to generator */
165 int n_operands; /* Number of operands this insn recognizes */
166 int n_dups; /* Number times match_dup appears in pattern */
167 int n_alternatives; /* Number of alternatives in each constraint */
168 int operand_number; /* Operand index in the big array. */
169 int output_format; /* INSN_OUTPUT_FORMAT_*. */
170 struct operand_data operand[MAX_MAX_OPERANDS];
173 /* A dummy insn, for CODE_FOR_nothing. */
174 static struct data nothing;
176 /* This variable points to the first link in the insn chain. */
177 static struct data *idata = &nothing;
179 /* This variable points to the end of the insn chain. This is where
180 everything relevant from the machien description is appended to. */
181 static struct data **idata_end = &nothing.next;
184 static void output_prologue (void);
185 static void output_operand_data (void);
186 static void output_insn_data (void);
187 static void output_get_insn_name (void);
188 static void scan_operands (struct data *, rtx, int, int);
189 static int compare_operands (struct operand_data *,
190 struct operand_data *);
191 static void place_operands (struct data *);
192 static void process_template (struct data *, const char *);
193 static void validate_insn_alternatives (struct data *);
194 static void validate_insn_operands (struct data *);
195 static void gen_insn (rtx, int);
196 static void gen_peephole (rtx, int);
197 static void gen_expand (rtx, int);
198 static void gen_split (rtx, int);
200 #ifdef USE_MD_CONSTRAINTS
202 struct constraint_data
204 struct constraint_data *next_this_letter;
205 int lineno;
206 unsigned int namelen;
207 const char name[1];
210 /* This is a complete list (unlike the one in genpreds.c) of constraint
211 letters and modifiers with machine-independent meaning. The only
212 omission is digits, as these are handled specially. */
213 static const char indep_constraints[] = ",=+%*?!#&<>EFVXgimnoprs";
215 static struct constraint_data *
216 constraints_by_letter_table[1 << CHAR_BIT];
218 static int mdep_constraint_len (const char *, int, int);
219 static void note_constraint (rtx, int);
221 #else /* !USE_MD_CONSTRAINTS */
223 static void check_constraint_len (void);
224 static int constraint_len (const char *, int);
226 #endif /* !USE_MD_CONSTRAINTS */
229 static void
230 output_prologue (void)
232 printf ("/* Generated automatically by the program `genoutput'\n\
233 from the machine description file `md'. */\n\n");
235 printf ("#include \"config.h\"\n");
236 printf ("#include \"system.h\"\n");
237 printf ("#include \"coretypes.h\"\n");
238 printf ("#include \"tm.h\"\n");
239 printf ("#include \"flags.h\"\n");
240 printf ("#include \"ggc.h\"\n");
241 printf ("#include \"tree.h\"\n");
242 printf ("#include \"varasm.h\"\n");
243 printf ("#include \"stor-layout.h\"\n");
244 printf ("#include \"calls.h\"\n");
245 printf ("#include \"rtl.h\"\n");
246 printf ("#include \"expr.h\"\n");
247 printf ("#include \"insn-codes.h\"\n");
248 printf ("#include \"tm_p.h\"\n");
249 printf ("#include \"function.h\"\n");
250 printf ("#include \"regs.h\"\n");
251 printf ("#include \"hard-reg-set.h\"\n");
252 printf ("#include \"insn-config.h\"\n\n");
253 printf ("#include \"conditions.h\"\n");
254 printf ("#include \"insn-attr.h\"\n\n");
255 printf ("#include \"recog.h\"\n\n");
256 printf ("#include \"diagnostic-core.h\"\n");
257 printf ("#include \"output.h\"\n");
258 printf ("#include \"target.h\"\n");
259 printf ("#include \"tm-constrs.h\"\n");
262 static void
263 output_operand_data (void)
265 struct operand_data *d;
267 printf ("\nstatic const struct insn_operand_data operand_data[] = \n{\n");
269 for (d = odata; d; d = d->next)
271 struct pred_data *pred;
273 printf (" {\n");
275 printf (" %s,\n",
276 d->predicate && d->predicate[0] ? d->predicate : "0");
278 printf (" \"%s\",\n", d->constraint ? d->constraint : "");
280 printf (" %smode,\n", GET_MODE_NAME (d->mode));
282 printf (" %d,\n", d->strict_low);
284 printf (" %d,\n", d->constraint == NULL ? 1 : 0);
286 printf (" %d,\n", d->eliminable);
288 pred = NULL;
289 if (d->predicate)
290 pred = lookup_predicate (d->predicate);
291 printf (" %d\n", pred && pred->codes[MEM]);
293 printf (" },\n");
295 printf ("};\n\n\n");
298 static void
299 output_insn_data (void)
301 struct data *d;
302 int name_offset = 0;
303 int next_name_offset;
304 const char * last_name = 0;
305 const char * next_name = 0;
306 struct data *n;
308 for (n = idata, next_name_offset = 1; n; n = n->next, next_name_offset++)
309 if (n->name)
311 next_name = n->name;
312 break;
315 printf ("#if GCC_VERSION >= 2007\n__extension__\n#endif\n");
316 printf ("\nconst struct insn_data_d insn_data[] = \n{\n");
318 for (d = idata; d; d = d->next)
320 printf (" /* %s:%d */\n", d->filename, d->lineno);
321 printf (" {\n");
323 if (d->name)
325 printf (" \"%s\",\n", d->name);
326 name_offset = 0;
327 last_name = d->name;
328 next_name = 0;
329 for (n = d->next, next_name_offset = 1; n;
330 n = n->next, next_name_offset++)
332 if (n->name)
334 next_name = n->name;
335 break;
339 else
341 name_offset++;
342 if (next_name && (last_name == 0
343 || name_offset > next_name_offset / 2))
344 printf (" \"%s-%d\",\n", next_name,
345 next_name_offset - name_offset);
346 else
347 printf (" \"%s+%d\",\n", last_name, name_offset);
350 switch (d->output_format)
352 case INSN_OUTPUT_FORMAT_NONE:
353 printf ("#if HAVE_DESIGNATED_UNION_INITIALIZERS\n");
354 printf (" { 0 },\n");
355 printf ("#else\n");
356 printf (" { 0, 0, 0 },\n");
357 printf ("#endif\n");
358 break;
359 case INSN_OUTPUT_FORMAT_SINGLE:
361 const char *p = d->template_code;
362 char prev = 0;
364 printf ("#if HAVE_DESIGNATED_UNION_INITIALIZERS\n");
365 printf (" { .single =\n");
366 printf ("#else\n");
367 printf (" {\n");
368 printf ("#endif\n");
369 printf (" \"");
370 while (*p)
372 if (IS_VSPACE (*p) && prev != '\\')
374 /* Preserve two consecutive \n's or \r's, but treat \r\n
375 as a single newline. */
376 if (*p == '\n' && prev != '\r')
377 printf ("\\n\\\n");
379 else
380 putchar (*p);
381 prev = *p;
382 ++p;
384 printf ("\",\n");
385 printf ("#if HAVE_DESIGNATED_UNION_INITIALIZERS\n");
386 printf (" },\n");
387 printf ("#else\n");
388 printf (" 0, 0 },\n");
389 printf ("#endif\n");
391 break;
392 case INSN_OUTPUT_FORMAT_MULTI:
393 printf ("#if HAVE_DESIGNATED_UNION_INITIALIZERS\n");
394 printf (" { .multi = output_%d },\n", d->code_number);
395 printf ("#else\n");
396 printf (" { 0, output_%d, 0 },\n", d->code_number);
397 printf ("#endif\n");
398 break;
399 case INSN_OUTPUT_FORMAT_FUNCTION:
400 printf ("#if HAVE_DESIGNATED_UNION_INITIALIZERS\n");
401 printf (" { .function = output_%d },\n", d->code_number);
402 printf ("#else\n");
403 printf (" { 0, 0, output_%d },\n", d->code_number);
404 printf ("#endif\n");
405 break;
406 default:
407 gcc_unreachable ();
410 if (d->name && d->name[0] != '*')
411 printf (" { (insn_gen_fn::stored_funcptr) gen_%s },\n", d->name);
412 else
413 printf (" { 0 },\n");
415 printf (" &operand_data[%d],\n", d->operand_number);
416 printf (" %d,\n", d->n_generator_args);
417 printf (" %d,\n", d->n_operands);
418 printf (" %d,\n", d->n_dups);
419 printf (" %d,\n", d->n_alternatives);
420 printf (" %d\n", d->output_format);
422 printf (" },\n");
424 printf ("};\n\n\n");
427 static void
428 output_get_insn_name (void)
430 printf ("const char *\n");
431 printf ("get_insn_name (int code)\n");
432 printf ("{\n");
433 printf (" if (code == NOOP_MOVE_INSN_CODE)\n");
434 printf (" return \"NOOP_MOVE\";\n");
435 printf (" else\n");
436 printf (" return insn_data[code].name;\n");
437 printf ("}\n");
441 /* Stores the operand data into `d->operand[i]'.
443 THIS_ADDRESS_P is nonzero if the containing rtx was an ADDRESS.
444 THIS_STRICT_LOW is nonzero if the containing rtx was a STRICT_LOW_PART. */
446 static void
447 scan_operands (struct data *d, rtx part, int this_address_p,
448 int this_strict_low)
450 int i, j;
451 const char *format_ptr;
452 int opno;
454 if (part == 0)
455 return;
457 switch (GET_CODE (part))
459 case MATCH_OPERAND:
460 opno = XINT (part, 0);
461 if (opno >= MAX_MAX_OPERANDS)
463 error_with_line (d->lineno, "maximum number of operands exceeded");
464 return;
466 if (d->operand[opno].seen)
467 error_with_line (d->lineno, "repeated operand number %d\n", opno);
469 d->operand[opno].seen = 1;
470 d->operand[opno].mode = GET_MODE (part);
471 d->operand[opno].strict_low = this_strict_low;
472 d->operand[opno].predicate = XSTR (part, 1);
473 d->operand[opno].constraint = strip_whitespace (XSTR (part, 2));
474 d->operand[opno].n_alternatives
475 = n_occurrences (',', d->operand[opno].constraint) + 1;
476 d->operand[opno].address_p = this_address_p;
477 d->operand[opno].eliminable = 1;
478 return;
480 case MATCH_SCRATCH:
481 opno = XINT (part, 0);
482 if (opno >= MAX_MAX_OPERANDS)
484 error_with_line (d->lineno, "maximum number of operands exceeded");
485 return;
487 if (d->operand[opno].seen)
488 error_with_line (d->lineno, "repeated operand number %d\n", opno);
490 d->operand[opno].seen = 1;
491 d->operand[opno].mode = GET_MODE (part);
492 d->operand[opno].strict_low = 0;
493 d->operand[opno].predicate = "scratch_operand";
494 d->operand[opno].constraint = strip_whitespace (XSTR (part, 1));
495 d->operand[opno].n_alternatives
496 = n_occurrences (',', d->operand[opno].constraint) + 1;
497 d->operand[opno].address_p = 0;
498 d->operand[opno].eliminable = 0;
499 return;
501 case MATCH_OPERATOR:
502 case MATCH_PARALLEL:
503 opno = XINT (part, 0);
504 if (opno >= MAX_MAX_OPERANDS)
506 error_with_line (d->lineno, "maximum number of operands exceeded");
507 return;
509 if (d->operand[opno].seen)
510 error_with_line (d->lineno, "repeated operand number %d\n", opno);
512 d->operand[opno].seen = 1;
513 d->operand[opno].mode = GET_MODE (part);
514 d->operand[opno].strict_low = 0;
515 d->operand[opno].predicate = XSTR (part, 1);
516 d->operand[opno].constraint = 0;
517 d->operand[opno].address_p = 0;
518 d->operand[opno].eliminable = 0;
519 for (i = 0; i < XVECLEN (part, 2); i++)
520 scan_operands (d, XVECEXP (part, 2, i), 0, 0);
521 return;
523 case STRICT_LOW_PART:
524 scan_operands (d, XEXP (part, 0), 0, 1);
525 return;
527 default:
528 break;
531 format_ptr = GET_RTX_FORMAT (GET_CODE (part));
533 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (part)); i++)
534 switch (*format_ptr++)
536 case 'e':
537 case 'u':
538 scan_operands (d, XEXP (part, i), 0, 0);
539 break;
540 case 'E':
541 if (XVEC (part, i) != NULL)
542 for (j = 0; j < XVECLEN (part, i); j++)
543 scan_operands (d, XVECEXP (part, i, j), 0, 0);
544 break;
548 /* Compare two operands for content equality. */
550 static int
551 compare_operands (struct operand_data *d0, struct operand_data *d1)
553 const char *p0, *p1;
555 p0 = d0->predicate;
556 if (!p0)
557 p0 = "";
558 p1 = d1->predicate;
559 if (!p1)
560 p1 = "";
561 if (strcmp (p0, p1) != 0)
562 return 0;
564 p0 = d0->constraint;
565 if (!p0)
566 p0 = "";
567 p1 = d1->constraint;
568 if (!p1)
569 p1 = "";
570 if (strcmp (p0, p1) != 0)
571 return 0;
573 if (d0->mode != d1->mode)
574 return 0;
576 if (d0->strict_low != d1->strict_low)
577 return 0;
579 if (d0->eliminable != d1->eliminable)
580 return 0;
582 return 1;
585 /* Scan the list of operands we've already committed to output and either
586 find a subsequence that is the same, or allocate a new one at the end. */
588 static void
589 place_operands (struct data *d)
591 struct operand_data *od, *od2;
592 int i;
594 if (d->n_operands == 0)
596 d->operand_number = 0;
597 return;
600 /* Brute force substring search. */
601 for (od = odata, i = 0; od; od = od->next, i = 0)
602 if (compare_operands (od, &d->operand[0]))
604 od2 = od->next;
605 i = 1;
606 while (1)
608 if (i == d->n_operands)
609 goto full_match;
610 if (od2 == NULL)
611 goto partial_match;
612 if (! compare_operands (od2, &d->operand[i]))
613 break;
614 ++i, od2 = od2->next;
618 /* Either partial match at the end of the list, or no match. In either
619 case, we tack on what operands are remaining to the end of the list. */
620 partial_match:
621 d->operand_number = next_operand_number - i;
622 for (; i < d->n_operands; ++i)
624 od2 = &d->operand[i];
625 *odata_end = od2;
626 odata_end = &od2->next;
627 od2->index = next_operand_number++;
629 *odata_end = NULL;
630 return;
632 full_match:
633 d->operand_number = od->index;
634 return;
638 /* Process an assembler template from a define_insn or a define_peephole.
639 It is either the assembler code template, a list of assembler code
640 templates, or C code to generate the assembler code template. */
642 static void
643 process_template (struct data *d, const char *template_code)
645 const char *cp;
646 int i;
648 /* Templates starting with * contain straight code to be run. */
649 if (template_code[0] == '*')
651 d->template_code = 0;
652 d->output_format = INSN_OUTPUT_FORMAT_FUNCTION;
654 puts ("\nstatic const char *");
655 printf ("output_%d (rtx *operands ATTRIBUTE_UNUSED, rtx insn ATTRIBUTE_UNUSED)\n",
656 d->code_number);
657 puts ("{");
658 print_md_ptr_loc (template_code);
659 puts (template_code + 1);
660 puts ("}");
663 /* If the assembler code template starts with a @ it is a newline-separated
664 list of assembler code templates, one for each alternative. */
665 else if (template_code[0] == '@')
667 int found_star = 0;
669 for (cp = &template_code[1]; *cp; )
671 while (ISSPACE (*cp))
672 cp++;
673 if (*cp == '*')
674 found_star = 1;
675 while (!IS_VSPACE (*cp) && *cp != '\0')
676 ++cp;
678 d->template_code = 0;
679 if (found_star)
681 d->output_format = INSN_OUTPUT_FORMAT_FUNCTION;
682 puts ("\nstatic const char *");
683 printf ("output_%d (rtx *operands ATTRIBUTE_UNUSED, "
684 "rtx insn ATTRIBUTE_UNUSED)\n", d->code_number);
685 puts ("{");
686 puts (" switch (which_alternative)\n {");
688 else
690 d->output_format = INSN_OUTPUT_FORMAT_MULTI;
691 printf ("\nstatic const char * const output_%d[] = {\n",
692 d->code_number);
695 for (i = 0, cp = &template_code[1]; *cp; )
697 const char *ep, *sp, *bp;
699 while (ISSPACE (*cp))
700 cp++;
702 bp = cp;
703 if (found_star)
705 printf (" case %d:", i);
706 if (*cp == '*')
708 printf ("\n ");
709 cp++;
711 else
712 printf (" return \"");
714 else
715 printf (" \"");
717 for (ep = sp = cp; !IS_VSPACE (*ep) && *ep != '\0'; ++ep)
718 if (!ISSPACE (*ep))
719 sp = ep + 1;
721 if (sp != ep)
722 message_with_line (d->lineno,
723 "trailing whitespace in output template");
725 while (cp < sp)
727 putchar (*cp);
728 cp++;
731 if (!found_star)
732 puts ("\",");
733 else if (*bp != '*')
734 puts ("\";");
735 else
737 /* The usual action will end with a return.
738 If there is neither break or return at the end, this is
739 assumed to be intentional; this allows to have multiple
740 consecutive alternatives share some code. */
741 puts ("");
743 i++;
745 if (i == 1)
746 message_with_line (d->lineno,
747 "'@' is redundant for output template with single alternative");
748 if (i != d->n_alternatives)
749 error_with_line (d->lineno,
750 "wrong number of alternatives in the output template");
752 if (found_star)
753 puts (" default: gcc_unreachable ();\n }\n}");
754 else
755 printf ("};\n");
757 else
759 d->template_code = template_code;
760 d->output_format = INSN_OUTPUT_FORMAT_SINGLE;
764 /* Check insn D for consistency in number of constraint alternatives. */
766 static void
767 validate_insn_alternatives (struct data *d)
769 int n = 0, start;
771 /* Make sure all the operands have the same number of alternatives
772 in their constraints. Let N be that number. */
773 for (start = 0; start < d->n_operands; start++)
774 if (d->operand[start].n_alternatives > 0)
776 int len, i;
777 const char *p;
778 char c;
779 int which_alternative = 0;
780 int alternative_count_unsure = 0;
782 for (p = d->operand[start].constraint; (c = *p); p += len)
784 #ifdef USE_MD_CONSTRAINTS
785 if (ISSPACE (c) || strchr (indep_constraints, c))
786 len = 1;
787 else if (ISDIGIT (c))
789 const char *q = p;
791 q++;
792 while (ISDIGIT (*q));
793 len = q - p;
795 else
796 len = mdep_constraint_len (p, d->lineno, start);
797 #else
798 len = CONSTRAINT_LEN (c, p);
800 if (len < 1 || (len > 1 && strchr (",#*+=&%!0123456789", c)))
802 error_with_line (d->lineno,
803 "invalid length %d for char '%c' in"
804 " alternative %d of operand %d",
805 len, c, which_alternative, start);
806 len = 1;
808 #endif
810 if (c == ',')
812 which_alternative++;
813 continue;
816 for (i = 1; i < len; i++)
817 if (p[i] == '\0')
819 error_with_line (d->lineno,
820 "NUL in alternative %d of operand %d",
821 which_alternative, start);
822 alternative_count_unsure = 1;
823 break;
825 else if (strchr (",#*", p[i]))
827 error_with_line (d->lineno,
828 "'%c' in alternative %d of operand %d",
829 p[i], which_alternative, start);
830 alternative_count_unsure = 1;
833 if (!alternative_count_unsure)
835 if (n == 0)
836 n = d->operand[start].n_alternatives;
837 else if (n != d->operand[start].n_alternatives)
838 error_with_line (d->lineno,
839 "wrong number of alternatives in operand %d",
840 start);
844 /* Record the insn's overall number of alternatives. */
845 d->n_alternatives = n;
848 /* Verify that there are no gaps in operand numbers for INSNs. */
850 static void
851 validate_insn_operands (struct data *d)
853 int i;
855 for (i = 0; i < d->n_operands; ++i)
856 if (d->operand[i].seen == 0)
857 error_with_line (d->lineno, "missing operand %d", i);
860 static void
861 validate_optab_operands (struct data *d)
863 if (!d->name || d->name[0] == '\0' || d->name[0] == '*')
864 return;
866 /* Miscellaneous tests. */
867 if (strncmp (d->name, "cstore", 6) == 0
868 && d->name[strlen (d->name) - 1] == '4'
869 && d->operand[0].mode == VOIDmode)
871 message_with_line (d->lineno, "missing mode for operand 0 of cstore");
872 have_error = 1;
876 /* Look at a define_insn just read. Assign its code number. Record
877 on idata the template and the number of arguments. If the insn has
878 a hairy output action, output a function for now. */
880 static void
881 gen_insn (rtx insn, int lineno)
883 struct pattern_stats stats;
884 struct data *d = XNEW (struct data);
885 int i;
887 d->code_number = next_code_number;
888 d->index_number = next_index_number;
889 d->filename = read_md_filename;
890 d->lineno = lineno;
891 if (XSTR (insn, 0)[0])
892 d->name = XSTR (insn, 0);
893 else
894 d->name = 0;
896 /* Build up the list in the same order as the insns are seen
897 in the machine description. */
898 d->next = 0;
899 *idata_end = d;
900 idata_end = &d->next;
902 memset (d->operand, 0, sizeof (d->operand));
904 for (i = 0; i < XVECLEN (insn, 1); i++)
905 scan_operands (d, XVECEXP (insn, 1, i), 0, 0);
907 get_pattern_stats (&stats, XVEC (insn, 1));
908 d->n_generator_args = stats.num_generator_args;
909 d->n_operands = stats.num_insn_operands;
910 d->n_dups = stats.num_dups;
912 #ifndef USE_MD_CONSTRAINTS
913 check_constraint_len ();
914 #endif
915 validate_insn_operands (d);
916 validate_insn_alternatives (d);
917 validate_optab_operands (d);
918 place_operands (d);
919 process_template (d, XTMPL (insn, 3));
922 /* Look at a define_peephole just read. Assign its code number.
923 Record on idata the template and the number of arguments.
924 If the insn has a hairy output action, output it now. */
926 static void
927 gen_peephole (rtx peep, int lineno)
929 struct pattern_stats stats;
930 struct data *d = XNEW (struct data);
931 int i;
933 d->code_number = next_code_number;
934 d->index_number = next_index_number;
935 d->filename = read_md_filename;
936 d->lineno = lineno;
937 d->name = 0;
939 /* Build up the list in the same order as the insns are seen
940 in the machine description. */
941 d->next = 0;
942 *idata_end = d;
943 idata_end = &d->next;
945 memset (d->operand, 0, sizeof (d->operand));
947 /* Get the number of operands by scanning all the patterns of the
948 peephole optimizer. But ignore all the rest of the information
949 thus obtained. */
950 for (i = 0; i < XVECLEN (peep, 0); i++)
951 scan_operands (d, XVECEXP (peep, 0, i), 0, 0);
953 get_pattern_stats (&stats, XVEC (peep, 0));
954 d->n_generator_args = 0;
955 d->n_operands = stats.num_insn_operands;
956 d->n_dups = 0;
958 validate_insn_alternatives (d);
959 place_operands (d);
960 process_template (d, XTMPL (peep, 2));
963 /* Process a define_expand just read. Assign its code number,
964 only for the purposes of `insn_gen_function'. */
966 static void
967 gen_expand (rtx insn, int lineno)
969 struct pattern_stats stats;
970 struct data *d = XNEW (struct data);
971 int i;
973 d->code_number = next_code_number;
974 d->index_number = next_index_number;
975 d->filename = read_md_filename;
976 d->lineno = lineno;
977 if (XSTR (insn, 0)[0])
978 d->name = XSTR (insn, 0);
979 else
980 d->name = 0;
982 /* Build up the list in the same order as the insns are seen
983 in the machine description. */
984 d->next = 0;
985 *idata_end = d;
986 idata_end = &d->next;
988 memset (d->operand, 0, sizeof (d->operand));
990 /* Scan the operands to get the specified predicates and modes,
991 since expand_binop needs to know them. */
993 if (XVEC (insn, 1))
994 for (i = 0; i < XVECLEN (insn, 1); i++)
995 scan_operands (d, XVECEXP (insn, 1, i), 0, 0);
997 get_pattern_stats (&stats, XVEC (insn, 1));
998 d->n_generator_args = stats.num_generator_args;
999 d->n_operands = stats.num_insn_operands;
1000 d->n_dups = stats.num_dups;
1001 d->template_code = 0;
1002 d->output_format = INSN_OUTPUT_FORMAT_NONE;
1004 validate_insn_alternatives (d);
1005 validate_optab_operands (d);
1006 place_operands (d);
1009 /* Process a define_split just read. Assign its code number,
1010 only for reasons of consistency and to simplify genrecog. */
1012 static void
1013 gen_split (rtx split, int lineno)
1015 struct pattern_stats stats;
1016 struct data *d = XNEW (struct data);
1017 int i;
1019 d->code_number = next_code_number;
1020 d->index_number = next_index_number;
1021 d->filename = read_md_filename;
1022 d->lineno = lineno;
1023 d->name = 0;
1025 /* Build up the list in the same order as the insns are seen
1026 in the machine description. */
1027 d->next = 0;
1028 *idata_end = d;
1029 idata_end = &d->next;
1031 memset (d->operand, 0, sizeof (d->operand));
1033 /* Get the number of operands by scanning all the patterns of the
1034 split patterns. But ignore all the rest of the information thus
1035 obtained. */
1036 for (i = 0; i < XVECLEN (split, 0); i++)
1037 scan_operands (d, XVECEXP (split, 0, i), 0, 0);
1039 get_pattern_stats (&stats, XVEC (split, 0));
1040 d->n_generator_args = 0;
1041 d->n_operands = stats.num_insn_operands;
1042 d->n_dups = 0;
1043 d->n_alternatives = 0;
1044 d->template_code = 0;
1045 d->output_format = INSN_OUTPUT_FORMAT_NONE;
1047 place_operands (d);
1050 static void
1051 init_insn_for_nothing (void)
1053 memset (&nothing, 0, sizeof (nothing));
1054 nothing.name = "*placeholder_for_nothing";
1055 nothing.filename = "<internal>";
1058 extern int main (int, char **);
1061 main (int argc, char **argv)
1063 rtx desc;
1065 progname = "genoutput";
1067 init_insn_for_nothing ();
1069 if (!init_rtx_reader_args (argc, argv))
1070 return (FATAL_EXIT_CODE);
1072 output_prologue ();
1073 next_index_number = 0;
1075 /* Read the machine description. */
1077 while (1)
1079 int line_no;
1081 desc = read_md_rtx (&line_no, &next_code_number);
1082 if (desc == NULL)
1083 break;
1085 switch (GET_CODE (desc))
1087 case DEFINE_INSN:
1088 gen_insn (desc, line_no);
1089 break;
1091 case DEFINE_PEEPHOLE:
1092 gen_peephole (desc, line_no);
1093 break;
1095 case DEFINE_EXPAND:
1096 gen_expand (desc, line_no);
1097 break;
1099 case DEFINE_SPLIT:
1100 case DEFINE_PEEPHOLE2:
1101 gen_split (desc, line_no);
1102 break;
1104 #ifdef USE_MD_CONSTRAINTS
1105 case DEFINE_CONSTRAINT:
1106 case DEFINE_REGISTER_CONSTRAINT:
1107 case DEFINE_ADDRESS_CONSTRAINT:
1108 case DEFINE_MEMORY_CONSTRAINT:
1109 note_constraint (desc, line_no);
1110 break;
1111 #endif
1113 default:
1114 break;
1116 next_index_number++;
1119 printf ("\n\n");
1120 output_operand_data ();
1121 output_insn_data ();
1122 output_get_insn_name ();
1124 fflush (stdout);
1125 return (ferror (stdout) != 0 || have_error
1126 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
1129 /* Return the number of occurrences of character C in string S or
1130 -1 if S is the null string. */
1132 static int
1133 n_occurrences (int c, const char *s)
1135 int n = 0;
1137 if (s == 0 || *s == '\0')
1138 return -1;
1140 while (*s)
1141 n += (*s++ == c);
1143 return n;
1146 /* Remove whitespace in `s' by moving up characters until the end.
1147 Return a new string. */
1149 static const char *
1150 strip_whitespace (const char *s)
1152 char *p, *q;
1153 char ch;
1155 if (s == 0)
1156 return 0;
1158 p = q = XNEWVEC (char, strlen (s) + 1);
1159 while ((ch = *s++) != '\0')
1160 if (! ISSPACE (ch))
1161 *p++ = ch;
1163 *p = '\0';
1164 return q;
1167 #ifdef USE_MD_CONSTRAINTS
1169 /* Record just enough information about a constraint to allow checking
1170 of operand constraint strings above, in validate_insn_alternatives.
1171 Does not validate most properties of the constraint itself; does
1172 enforce no duplicate names, no overlap with MI constraints, and no
1173 prefixes. EXP is the define_*constraint form, LINENO the line number
1174 reported by the reader. */
1175 static void
1176 note_constraint (rtx exp, int lineno)
1178 const char *name = XSTR (exp, 0);
1179 unsigned int namelen = strlen (name);
1180 struct constraint_data **iter, **slot, *new_cdata;
1182 /* The 'm' constraint is special here since that constraint letter
1183 can be overridden by the back end by defining the
1184 TARGET_MEM_CONSTRAINT macro. */
1185 if (strchr (indep_constraints, name[0]) && name[0] != 'm')
1187 if (name[1] == '\0')
1188 error_with_line (lineno, "constraint letter '%s' cannot be "
1189 "redefined by the machine description", name);
1190 else
1191 error_with_line (lineno, "constraint name '%s' cannot be defined by "
1192 "the machine description, as it begins with '%c'",
1193 name, name[0]);
1194 return;
1197 slot = &constraints_by_letter_table[(unsigned int)name[0]];
1198 for (iter = slot; *iter; iter = &(*iter)->next_this_letter)
1200 /* This causes slot to end up pointing to the
1201 next_this_letter field of the last constraint with a name
1202 of equal or greater length than the new constraint; hence
1203 the new constraint will be inserted after all previous
1204 constraints with names of the same length. */
1205 if ((*iter)->namelen >= namelen)
1206 slot = iter;
1208 if (!strcmp ((*iter)->name, name))
1210 error_with_line (lineno, "redefinition of constraint '%s'", name);
1211 message_with_line ((*iter)->lineno, "previous definition is here");
1212 return;
1214 else if (!strncmp ((*iter)->name, name, (*iter)->namelen))
1216 error_with_line (lineno, "defining constraint '%s' here", name);
1217 message_with_line ((*iter)->lineno, "renders constraint '%s' "
1218 "(defined here) a prefix", (*iter)->name);
1219 return;
1221 else if (!strncmp ((*iter)->name, name, namelen))
1223 error_with_line (lineno, "constraint '%s' is a prefix", name);
1224 message_with_line ((*iter)->lineno, "of constraint '%s' "
1225 "(defined here)", (*iter)->name);
1226 return;
1229 new_cdata = XNEWVAR (struct constraint_data, sizeof (struct constraint_data) + namelen);
1230 strcpy (CONST_CAST (char *, new_cdata->name), name);
1231 new_cdata->namelen = namelen;
1232 new_cdata->lineno = lineno;
1233 new_cdata->next_this_letter = *slot;
1234 *slot = new_cdata;
1237 /* Return the length of the constraint name beginning at position S
1238 of an operand constraint string, or issue an error message if there
1239 is no such constraint. Does not expect to be called for generic
1240 constraints. */
1241 static int
1242 mdep_constraint_len (const char *s, int lineno, int opno)
1244 struct constraint_data *p;
1246 p = constraints_by_letter_table[(unsigned int)s[0]];
1248 if (p)
1249 for (; p; p = p->next_this_letter)
1250 if (!strncmp (s, p->name, p->namelen))
1251 return p->namelen;
1253 error_with_line (lineno,
1254 "error: undefined machine-specific constraint "
1255 "at this point: \"%s\"", s);
1256 message_with_line (lineno, "note: in operand %d", opno);
1257 return 1; /* safe */
1260 #else
1261 /* Verify that DEFAULT_CONSTRAINT_LEN is used properly and not
1262 tampered with. This isn't bullet-proof, but it should catch
1263 most genuine mistakes. */
1264 static void
1265 check_constraint_len (void)
1267 const char *p;
1268 int d;
1270 for (p = ",#*+=&%!1234567890"; *p; p++)
1271 for (d = -9; d < 9; d++)
1272 gcc_assert (constraint_len (p, d) == d);
1275 static int
1276 constraint_len (const char *p, int genoutput_default_constraint_len)
1278 /* Check that we still match defaults.h . First we do a generation-time
1279 check that fails if the value is not the expected one... */
1280 gcc_assert (DEFAULT_CONSTRAINT_LEN (*p, p) == 1);
1281 /* And now a compile-time check that should give a diagnostic if the
1282 definition doesn't exactly match. */
1283 #define DEFAULT_CONSTRAINT_LEN(C,STR) 1
1284 /* Now re-define DEFAULT_CONSTRAINT_LEN so that we can verify it is
1285 being used. */
1286 #undef DEFAULT_CONSTRAINT_LEN
1287 #define DEFAULT_CONSTRAINT_LEN(C,STR) \
1288 ((C) != *p || STR != p ? -1 : genoutput_default_constraint_len)
1289 return CONSTRAINT_LEN (*p, p);
1290 /* And set it back. */
1291 #undef DEFAULT_CONSTRAINT_LEN
1292 #define DEFAULT_CONSTRAINT_LEN(C,STR) 1
1294 #endif