1 /* Generate code from to output assembler insns as recognized from rtl.
2 Copyright (C) 1987, 1988, 1992, 1994 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
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 strings `insn_template' which is indexed by insn code number
25 and contains the template for output of that insn,
27 2. An array of functions `insn_outfun' which, indexed by the insn code
28 number, gives the function that returns a template to use for output of
29 that insn. This is used only in the cases where the template is not
30 constant. These cases are specified by a * or @ at the beginning of the
31 template string in the machine description. They are identified for the
32 sake of other parts of the compiler by a zero element in `insn_template'.
34 3. An array of functions `insn_gen_function' which, indexed
35 by insn code number, gives the function to generate a body
36 for that pattern, given operands as arguments.
38 4. An array of strings `insn_name' which, indexed by insn code number,
39 gives the name for that pattern. Nameless patterns are given a name.
41 5. An array of ints `insn_n_operands' which is indexed by insn code number
42 and contains the number of distinct operands in the pattern for that insn,
44 6. An array of ints `insn_n_dups' which is indexed by insn code number
45 and contains the number of match_dup's that appear in the insn's pattern.
46 This says how many elements of `recog_dup_loc' are significant
47 after an insn has been recognized.
49 7. An array of arrays of operand constraint strings,
50 `insn_operand_constraint',
51 indexed first by insn code number and second by operand number,
52 containing the constraint for that operand.
54 This array is generated only if register constraints appear in
57 8. An array of arrays of chars which indicate which operands of
58 which insn patterns appear within ADDRESS rtx's. This array is
59 called `insn_operand_address_p' and is generated only if there
60 are *no* register constraints in the match_operand rtx's.
62 9. An array of arrays of machine modes, `insn_operand_mode',
63 indexed first by insn code number and second by operand number,
64 containing the machine mode that that operand is supposed to have.
65 Also `insn_operand_strict_low', which is nonzero for operands
66 contained in a STRICT_LOW_PART.
68 10. An array of arrays of int-valued functions, `insn_operand_predicate',
69 indexed first by insn code number and second by operand number,
70 containing the match_operand predicate for this operand.
72 11. An array of ints, `insn_n_alternatives', that gives the number
73 of alternatives in the constraints of each pattern.
75 The code number of an insn is simply its position in the machine description;
76 code numbers are assigned sequentially to entries in the description,
77 starting with code number 0.
79 Thus, the following entry in the machine description
82 [(set (match_operand:DF 0 "general_operand" "")
87 assuming it is the 25th entry present, would cause
88 insn_template[24] to be "clrd %0", and insn_n_operands[24] to be 1.
89 It would not make an case in output_insn_hairy because the template
90 given in the entry is a constant (it does not start with `*'). */
97 /* No instruction can have more operands than this.
98 Sorry for this arbitrary limit, but what machine will
99 have an instruction with this many operands? */
101 #define MAX_MAX_OPERANDS 40
103 static struct obstack obstack;
104 struct obstack *rtl_obstack = &obstack;
106 #define obstack_chunk_alloc xmalloc
107 #define obstack_chunk_free free
110 extern rtx read_rtx ();
113 static void fatal ();
115 static void error ();
116 static void mybcopy ();
117 static void mybzero ();
118 static int n_occurrences ();
120 /* insns in the machine description are assigned sequential code numbers
121 that are used by insn-recog.c (produced by genrecog) to communicate
122 to insn-output.c (produced by this program). */
124 static int next_code_number;
126 /* This counts all definitions in the md file,
127 for the sake of error messages. */
129 static int next_index_number;
131 /* Record in this chain all information that we will output,
132 associated with the code number of the insn. */
139 char *template; /* string such as "movl %1,%0" */
140 int n_operands; /* Number of operands this insn recognizes */
141 int n_dups; /* Number times match_dup appears in pattern */
142 int n_alternatives; /* Number of alternatives in each constraint */
144 char *constraints[MAX_MAX_OPERANDS];
145 /* Number of alternatives in constraints of operand N. */
146 int op_n_alternatives[MAX_MAX_OPERANDS];
147 char *predicates[MAX_MAX_OPERANDS];
148 char address_p[MAX_MAX_OPERANDS];
149 enum machine_mode modes[MAX_MAX_OPERANDS];
150 char strict_low[MAX_MAX_OPERANDS];
151 char outfun; /* Nonzero means this has an output function */
154 /* This variable points to the first link in the chain. */
156 struct data *insn_data;
158 /* Pointer to the last link in the chain, so new elements
159 can be added at the end. */
161 struct data *end_of_insn_data;
163 /* Nonzero if any match_operand has a constraint string;
164 implies that REGISTER_CONSTRAINTS will be defined
165 for this machine description. */
167 int have_constraints;
169 /* Nonzero if some error has occurred. We will make all errors fatal, but
170 might as well continue until we see all of them. */
172 static int have_error;
178 printf ("/* Generated automatically by the program `genoutput'\n\
179 from the machine description file `md'. */\n\n");
181 printf ("#include \"config.h\"\n");
182 printf ("#include \"rtl.h\"\n");
183 printf ("#include \"regs.h\"\n");
184 printf ("#include \"hard-reg-set.h\"\n");
185 printf ("#include \"real.h\"\n");
186 printf ("#include \"insn-config.h\"\n\n");
187 printf ("#include \"conditions.h\"\n");
188 printf ("#include \"insn-flags.h\"\n");
189 printf ("#include \"insn-attr.h\"\n\n");
190 printf ("#include \"insn-codes.h\"\n\n");
191 printf ("#include \"recog.h\"\n\n");
193 printf ("#include <stdio.h>\n");
194 printf ("#include \"output.h\"\n");
200 register struct data *d;
202 printf ("\nchar * const insn_template[] =\n {\n");
203 for (d = insn_data; d; d = d->next)
206 printf (" \"%s\",\n", d->template);
212 printf ("\nchar *(*const insn_outfun[])() =\n {\n");
213 for (d = insn_data; d; d = d->next)
216 printf (" output_%d,\n", d->code_number);
222 printf ("\nrtx (*const insn_gen_function[]) () =\n {\n");
223 for (d = insn_data; d; d = d->next)
226 printf (" gen_%s,\n", d->name);
232 printf ("\nchar *insn_name[] =\n {\n");
236 char * last_name = 0;
238 register struct data *n;
240 for (n = insn_data, next = 1; n; n = n->next, next++)
247 for (d = insn_data; d; d = d->next)
251 printf (" \"%s\",\n", d->name);
255 for (n = d->next, next = 1; n; n = n->next, next++)
265 if (next_name && (last_name == 0 || offset > next / 2))
266 printf (" \"%s-%d\",\n", next_name, next - offset);
268 printf (" \"%s+%d\",\n", last_name, offset);
273 printf ("char **insn_name_ptr = insn_name;\n");
275 printf ("\nconst int insn_n_operands[] =\n {\n");
276 for (d = insn_data; d; d = d->next)
277 printf (" %d,\n", d->n_operands);
280 printf ("\nconst int insn_n_dups[] =\n {\n");
281 for (d = insn_data; d; d = d->next)
282 printf (" %d,\n", d->n_dups);
285 if (have_constraints)
287 printf ("\nchar *const insn_operand_constraint[][MAX_RECOG_OPERANDS] =\n {\n");
288 for (d = insn_data; d; d = d->next)
292 for (i = 0; i < d->n_operands; i++)
294 if (d->constraints[i] == 0)
297 printf (" \"%s\",", d->constraints[i]);
299 if (d->n_operands == 0)
307 printf ("\nconst char insn_operand_address_p[][MAX_RECOG_OPERANDS] =\n {\n");
308 for (d = insn_data; d; d = d->next)
312 for (i = 0; i < d->n_operands; i++)
313 printf (" %d,", d->address_p[i]);
314 if (d->n_operands == 0)
321 printf ("\nconst enum machine_mode insn_operand_mode[][MAX_RECOG_OPERANDS] =\n {\n");
322 for (d = insn_data; d; d = d->next)
326 for (i = 0; i < d->n_operands; i++)
327 printf (" %smode,", GET_MODE_NAME (d->modes[i]));
328 if (d->n_operands == 0)
329 printf (" VOIDmode");
334 printf ("\nconst char insn_operand_strict_low[][MAX_RECOG_OPERANDS] =\n {\n");
335 for (d = insn_data; d; d = d->next)
339 for (i = 0; i < d->n_operands; i++)
340 printf (" %d,", d->strict_low[i]);
341 if (d->n_operands == 0)
348 /* We need to define all predicates used. Keep a list of those we
349 have defined so far. There normally aren't very many predicates used,
350 so a linked list should be fast enough. */
351 struct predicate { char *name; struct predicate *next; } *predicates = 0;
356 for (d = insn_data; d; d = d->next)
357 for (i = 0; i < d->n_operands; i++)
358 if (d->predicates[i] && d->predicates[i][0])
360 for (p = predicates; p; p = p->next)
361 if (! strcmp (p->name, d->predicates[i]))
366 printf ("extern int %s ();\n", d->predicates[i]);
367 p = (struct predicate *) alloca (sizeof (struct predicate));
368 p->name = d->predicates[i];
369 p->next = predicates;
374 printf ("\nint (*const insn_operand_predicate[][MAX_RECOG_OPERANDS])() =\n {\n");
375 for (d = insn_data; d; d = d->next)
378 for (i = 0; i < d->n_operands; i++)
379 printf (" %s,", ((d->predicates[i] && d->predicates[i][0])
380 ? d->predicates[i] : "0"));
381 if (d->n_operands == 0)
388 printf ("\nconst int insn_n_alternatives[] =\n {\n");
389 for (d = insn_data; d; d = d->next)
390 printf (" %d,\n", d->n_alternatives);
394 /* scan_operands (X) stores in max_opno the largest operand
395 number present in X, if that is larger than the previous
396 value of max_opno. It stores all the constraints in `constraints'
397 and all the machine modes in `modes'.
399 THIS_ADDRESS_P is nonzero if the containing rtx was an ADDRESS.
400 THIS_STRICT_LOW is nonzero if the containing rtx was a STRICT_LOW_PART. */
404 static char *constraints[MAX_MAX_OPERANDS];
405 static int op_n_alternatives[MAX_MAX_OPERANDS];
406 static char *predicates[MAX_MAX_OPERANDS];
407 static char address_p[MAX_MAX_OPERANDS];
408 static enum machine_mode modes[MAX_MAX_OPERANDS];
409 static char strict_low[MAX_MAX_OPERANDS];
410 static char seen[MAX_MAX_OPERANDS];
413 scan_operands (part, this_address_p, this_strict_low)
419 register char *format_ptr;
425 switch (GET_CODE (part))
428 opno = XINT (part, 0);
431 if (max_opno >= MAX_MAX_OPERANDS)
433 error ("Too many operands (%d) in definition %d.\n",
434 max_opno + 1, next_index_number);
438 error ("Definition %d specified operand number %d more than once.\n",
439 next_index_number, opno);
441 modes[opno] = GET_MODE (part);
442 strict_low[opno] = this_strict_low;
443 predicates[opno] = XSTR (part, 1);
444 constraints[opno] = XSTR (part, 2);
445 if (XSTR (part, 2) != 0 && *XSTR (part, 2) != 0)
447 op_n_alternatives[opno] = n_occurrences (',', XSTR (part, 2)) + 1;
448 have_constraints = 1;
450 address_p[opno] = this_address_p;
454 opno = XINT (part, 0);
457 if (max_opno >= MAX_MAX_OPERANDS)
459 error ("Too many operands (%d) in definition %d.\n",
460 max_opno + 1, next_index_number);
464 error ("Definition %d specified operand number %d more than once.\n",
465 next_index_number, opno);
467 modes[opno] = GET_MODE (part);
468 strict_low[opno] = 0;
469 predicates[opno] = "scratch_operand";
470 constraints[opno] = XSTR (part, 1);
471 if (XSTR (part, 1) != 0 && *XSTR (part, 1) != 0)
473 op_n_alternatives[opno] = n_occurrences (',', XSTR (part, 1)) + 1;
474 have_constraints = 1;
481 opno = XINT (part, 0);
484 if (max_opno >= MAX_MAX_OPERANDS)
486 error ("Too many operands (%d) in definition %d.\n",
487 max_opno + 1, next_index_number);
491 error ("Definition %d specified operand number %d more than once.\n",
492 next_index_number, opno);
494 modes[opno] = GET_MODE (part);
495 strict_low[opno] = 0;
496 predicates[opno] = XSTR (part, 1);
497 constraints[opno] = 0;
499 for (i = 0; i < XVECLEN (part, 2); i++)
500 scan_operands (XVECEXP (part, 2, i), 0, 0);
510 scan_operands (XEXP (part, 0), 1, 0);
513 case STRICT_LOW_PART:
514 scan_operands (XEXP (part, 0), 0, 1);
518 format_ptr = GET_RTX_FORMAT (GET_CODE (part));
520 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (part)); i++)
521 switch (*format_ptr++)
524 scan_operands (XEXP (part, i), 0, 0);
527 if (XVEC (part, i) != NULL)
528 for (j = 0; j < XVECLEN (part, i); j++)
529 scan_operands (XVECEXP (part, i, j), 0, 0);
534 /* Process an assembler template from a define_insn or a define_peephole.
535 It is either the assembler code template, a list of assembler code
536 templates, or C code to generate the assembler code template. */
539 process_template (d, template)
546 /* We need to consider only the instructions whose assembler code template
547 starts with a * or @. These are the ones where C code is run to decide
548 on a template to use. So for all others just return now. */
550 if (template[0] != '*' && template[0] != '@')
552 d->template = template;
560 printf ("\nstatic char *\n");
561 printf ("output_%d (operands, insn)\n", d->code_number);
562 printf (" rtx *operands;\n");
563 printf (" rtx insn;\n");
566 /* If the assembler code template starts with a @ it is a newline-separated
567 list of assembler code templates, one for each alternative. So produce
568 a routine to select the correct one. */
570 if (template[0] == '@')
573 printf (" static /*const*/ char *const strings_%d[] = {\n",
576 for (i = 0, cp = &template[1]; *cp; )
578 while (*cp == '\n' || *cp == ' ' || *cp== '\t')
582 while (*cp != '\n' && *cp != '\0')
590 printf (" return strings_%d[which_alternative];\n", d->code_number);
592 if (i != d->n_alternatives)
593 fatal ("Insn pattern %d has %d alternatives but %d assembler choices",
594 d->index_number, d->n_alternatives, i);
599 /* The following is done in a funny way to get around problems in
600 VAX-11 "C" on VMS. It is the equivalent of:
601 printf ("%s\n", &template[1])); */
603 while (*cp) putchar (*cp++);
610 /* Check insn D for consistency in number of constraint alternatives. */
613 validate_insn_alternatives (d)
616 register int n = 0, start;
617 /* Make sure all the operands have the same number of
618 alternatives in their constraints.
619 Let N be that number. */
620 for (start = 0; start < d->n_operands; start++)
621 if (d->op_n_alternatives[start] > 0)
624 n = d->op_n_alternatives[start];
625 else if (n != d->op_n_alternatives[start])
626 error ("wrong number of alternatives in operand %d of insn number %d",
627 start, d->index_number);
629 /* Record the insn's overall number of alternatives. */
630 d->n_alternatives = n;
633 /* Look at a define_insn just read. Assign its code number.
634 Record on insn_data the template and the number of arguments.
635 If the insn has a hairy output action, output a function for now. */
641 register struct data *d = (struct data *) xmalloc (sizeof (struct data));
644 d->code_number = next_code_number++;
645 d->index_number = next_index_number;
646 if (XSTR (insn, 0)[0])
647 d->name = XSTR (insn, 0);
651 /* Build up the list in the same order as the insns are seen
652 in the machine description. */
654 if (end_of_insn_data)
655 end_of_insn_data->next = d;
659 end_of_insn_data = d;
664 mybzero (constraints, sizeof constraints);
665 mybzero (op_n_alternatives, sizeof op_n_alternatives);
666 mybzero (predicates, sizeof predicates);
667 mybzero (address_p, sizeof address_p);
668 mybzero (modes, sizeof modes);
669 mybzero (strict_low, sizeof strict_low);
670 mybzero (seen, sizeof seen);
672 for (i = 0; i < XVECLEN (insn, 1); i++)
673 scan_operands (XVECEXP (insn, 1, i), 0, 0);
675 d->n_operands = max_opno + 1;
676 d->n_dups = num_dups;
678 mybcopy (constraints, d->constraints, sizeof constraints);
679 mybcopy (op_n_alternatives, d->op_n_alternatives, sizeof op_n_alternatives);
680 mybcopy (predicates, d->predicates, sizeof predicates);
681 mybcopy (address_p, d->address_p, sizeof address_p);
682 mybcopy (modes, d->modes, sizeof modes);
683 mybcopy (strict_low, d->strict_low, sizeof strict_low);
685 validate_insn_alternatives (d);
686 process_template (d, XSTR (insn, 3));
689 /* Look at a define_peephole just read. Assign its code number.
690 Record on insn_data the template and the number of arguments.
691 If the insn has a hairy output action, output it now. */
697 register struct data *d = (struct data *) xmalloc (sizeof (struct data));
700 d->code_number = next_code_number++;
701 d->index_number = next_index_number;
704 /* Build up the list in the same order as the insns are seen
705 in the machine description. */
707 if (end_of_insn_data)
708 end_of_insn_data->next = d;
712 end_of_insn_data = d;
715 mybzero (constraints, sizeof constraints);
716 mybzero (op_n_alternatives, sizeof op_n_alternatives);
717 mybzero (predicates, sizeof predicates);
718 mybzero (address_p, sizeof address_p);
719 mybzero (modes, sizeof modes);
720 mybzero (strict_low, sizeof strict_low);
721 mybzero (seen, sizeof seen);
723 /* Get the number of operands by scanning all the
724 patterns of the peephole optimizer.
725 But ignore all the rest of the information thus obtained. */
726 for (i = 0; i < XVECLEN (peep, 0); i++)
727 scan_operands (XVECEXP (peep, 0, i), 0, 0);
729 d->n_operands = max_opno + 1;
732 mybcopy (constraints, d->constraints, sizeof constraints);
733 mybcopy (op_n_alternatives, d->op_n_alternatives, sizeof op_n_alternatives);
734 mybzero (d->predicates, sizeof predicates);
735 mybzero (d->address_p, sizeof address_p);
736 mybzero (d->modes, sizeof modes);
737 mybzero (d->strict_low, sizeof strict_low);
739 validate_insn_alternatives (d);
740 process_template (d, XSTR (peep, 2));
743 /* Process a define_expand just read. Assign its code number,
744 only for the purposes of `insn_gen_function'. */
750 register struct data *d = (struct data *) xmalloc (sizeof (struct data));
753 d->code_number = next_code_number++;
754 d->index_number = next_index_number;
755 if (XSTR (insn, 0)[0])
756 d->name = XSTR (insn, 0);
760 /* Build up the list in the same order as the insns are seen
761 in the machine description. */
763 if (end_of_insn_data)
764 end_of_insn_data->next = d;
768 end_of_insn_data = d;
773 /* Scan the operands to get the specified predicates and modes,
774 since expand_binop needs to know them. */
776 mybzero (constraints, sizeof constraints);
777 mybzero (op_n_alternatives, sizeof op_n_alternatives);
778 mybzero (predicates, sizeof predicates);
779 mybzero (address_p, sizeof address_p);
780 mybzero (modes, sizeof modes);
781 mybzero (strict_low, sizeof strict_low);
782 mybzero (seen, sizeof seen);
785 for (i = 0; i < XVECLEN (insn, 1); i++)
786 scan_operands (XVECEXP (insn, 1, i), 0, 0);
788 d->n_operands = max_opno + 1;
789 d->n_dups = num_dups;
791 mybcopy (constraints, d->constraints, sizeof constraints);
792 mybcopy (op_n_alternatives, d->op_n_alternatives, sizeof op_n_alternatives);
793 mybcopy (predicates, d->predicates, sizeof predicates);
794 mybcopy (address_p, d->address_p, sizeof address_p);
795 mybcopy (modes, d->modes, sizeof modes);
796 mybcopy (strict_low, d->strict_low, sizeof strict_low);
800 validate_insn_alternatives (d);
803 /* Process a define_split just read. Assign its code number,
804 only for reasons of consistency and to simplify genrecog. */
811 register struct data *d = (struct data *) xmalloc (sizeof (struct data));
814 d->code_number = next_code_number++;
815 d->index_number = next_index_number;
818 /* Build up the list in the same order as the insns are seen
819 in the machine description. */
821 if (end_of_insn_data)
822 end_of_insn_data->next = d;
826 end_of_insn_data = d;
831 mybzero (constraints, sizeof constraints);
832 mybzero (op_n_alternatives, sizeof op_n_alternatives);
833 mybzero (predicates, sizeof predicates);
834 mybzero (address_p, sizeof address_p);
835 mybzero (modes, sizeof modes);
836 mybzero (strict_low, sizeof strict_low);
837 mybzero (seen, sizeof seen);
839 /* Get the number of operands by scanning all the
840 patterns of the split patterns.
841 But ignore all the rest of the information thus obtained. */
842 for (i = 0; i < XVECLEN (split, 0); i++)
843 scan_operands (XVECEXP (split, 0, i), 0, 0);
845 d->n_operands = max_opno + 1;
847 mybzero (d->constraints, sizeof constraints);
848 mybzero (d->op_n_alternatives, sizeof op_n_alternatives);
849 mybzero (d->predicates, sizeof predicates);
850 mybzero (d->address_p, sizeof address_p);
851 mybzero (d->modes, sizeof modes);
852 mybzero (d->strict_low, sizeof strict_low);
855 d->n_alternatives = 0;
864 register char *val = (char *) malloc (size);
867 fatal ("virtual memory exhausted");
876 char *result = (char *) realloc (ptr, size);
878 fatal ("virtual memory exhausted");
885 register unsigned length;
892 mybcopy (b1, b2, length)
895 register unsigned length;
902 fatal (s, a1, a2, a3, a4)
905 fprintf (stderr, "genoutput: ");
906 fprintf (stderr, s, a1, a2, a3, a4);
907 fprintf (stderr, "\n");
908 exit (FATAL_EXIT_CODE);
911 /* More 'friendly' abort that prints the line and file.
912 config.h can #define abort fancy_abort if you like that sort of thing. */
917 fatal ("Internal gcc abort.");
924 fprintf (stderr, "genoutput: ");
925 fprintf (stderr, s, a1, a2);
926 fprintf (stderr, "\n");
940 obstack_init (rtl_obstack);
943 fatal ("No input file name.");
945 infile = fopen (argv[1], "r");
949 exit (FATAL_EXIT_CODE);
955 next_code_number = 0;
956 next_index_number = 0;
957 have_constraints = 0;
959 /* Read the machine description. */
963 c = read_skip_spaces (infile);
968 desc = read_rtx (infile);
969 if (GET_CODE (desc) == DEFINE_INSN)
971 if (GET_CODE (desc) == DEFINE_PEEPHOLE)
973 if (GET_CODE (desc) == DEFINE_EXPAND)
975 if (GET_CODE (desc) == DEFINE_SPLIT)
983 exit (ferror (stdout) != 0 || have_error
984 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);