1 /* Generate code from to output assembler insns as recognized from rtl.
2 Copyright (C) 1987, 1988, 1992 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;
173 printf ("/* Generated automatically by the program `genoutput'\n\
174 from the machine description file `md'. */\n\n");
176 printf ("#include \"config.h\"\n");
177 printf ("#include \"rtl.h\"\n");
178 printf ("#include \"regs.h\"\n");
179 printf ("#include \"hard-reg-set.h\"\n");
180 printf ("#include \"real.h\"\n");
181 printf ("#include \"insn-config.h\"\n\n");
182 printf ("#include \"conditions.h\"\n");
183 printf ("#include \"insn-flags.h\"\n");
184 printf ("#include \"insn-attr.h\"\n\n");
185 printf ("#include \"insn-codes.h\"\n\n");
186 printf ("#include \"recog.h\"\n\n");
188 printf ("#include <stdio.h>\n");
189 printf ("#include \"output.h\"\n");
195 register struct data *d;
197 printf ("\nchar * const insn_template[] =\n {\n");
198 for (d = insn_data; d; d = d->next)
201 printf (" \"%s\",\n", d->template);
207 printf ("\nchar *(*const insn_outfun[])() =\n {\n");
208 for (d = insn_data; d; d = d->next)
211 printf (" output_%d,\n", d->code_number);
217 printf ("\nrtx (*const insn_gen_function[]) () =\n {\n");
218 for (d = insn_data; d; d = d->next)
221 printf (" gen_%s,\n", d->name);
227 printf ("\nchar *insn_name[] =\n {\n");
231 char * last_name = 0;
233 register struct data *n;
235 for (n = insn_data, next = 0; n; n = n->next, next++)
242 for (d = insn_data; d; d = d->next)
246 printf (" \"%s\",\n", d->name);
250 for (n = d->next, next = 1; n; n = n->next, next++)
260 if (next_name && (last_name == 0 || offset > next / 2))
261 printf (" \"%s-%d\",\n", next_name, next - offset);
263 printf (" \"%s+%d\",\n", last_name, offset);
268 printf ("char **insn_name_ptr = insn_name;\n");
270 printf ("\nconst int insn_n_operands[] =\n {\n");
271 for (d = insn_data; d; d = d->next)
272 printf (" %d,\n", d->n_operands);
275 printf ("\nconst int insn_n_dups[] =\n {\n");
276 for (d = insn_data; d; d = d->next)
277 printf (" %d,\n", d->n_dups);
280 if (have_constraints)
282 printf ("\nchar *const insn_operand_constraint[][MAX_RECOG_OPERANDS] =\n {\n");
283 for (d = insn_data; d; d = d->next)
287 for (i = 0; i < d->n_operands; i++)
289 if (d->constraints[i] == 0)
292 printf (" \"%s\",", d->constraints[i]);
294 if (d->n_operands == 0)
302 printf ("\nconst char insn_operand_address_p[][MAX_RECOG_OPERANDS] =\n {\n");
303 for (d = insn_data; d; d = d->next)
307 for (i = 0; i < d->n_operands; i++)
308 printf (" %d,", d->address_p[i]);
309 if (d->n_operands == 0)
316 printf ("\nconst enum machine_mode insn_operand_mode[][MAX_RECOG_OPERANDS] =\n {\n");
317 for (d = insn_data; d; d = d->next)
321 for (i = 0; i < d->n_operands; i++)
322 printf (" %smode,", GET_MODE_NAME (d->modes[i]));
323 if (d->n_operands == 0)
324 printf (" VOIDmode");
329 printf ("\nconst char insn_operand_strict_low[][MAX_RECOG_OPERANDS] =\n {\n");
330 for (d = insn_data; d; d = d->next)
334 for (i = 0; i < d->n_operands; i++)
335 printf (" %d,", d->strict_low[i]);
336 if (d->n_operands == 0)
343 /* We need to define all predicates used. Keep a list of those we
344 have defined so far. There normally aren't very many predicates used,
345 so a linked list should be fast enough. */
346 struct predicate { char *name; struct predicate *next; } *predicates = 0;
351 for (d = insn_data; d; d = d->next)
352 for (i = 0; i < d->n_operands; i++)
353 if (d->predicates[i] && d->predicates[i][0])
355 for (p = predicates; p; p = p->next)
356 if (! strcmp (p->name, d->predicates[i]))
361 printf ("extern int %s ();\n", d->predicates[i]);
362 p = (struct predicate *) alloca (sizeof (struct predicate));
363 p->name = d->predicates[i];
364 p->next = predicates;
369 printf ("\nint (*const insn_operand_predicate[][MAX_RECOG_OPERANDS])() =\n {\n");
370 for (d = insn_data; d; d = d->next)
373 for (i = 0; i < d->n_operands; i++)
374 printf (" %s,", ((d->predicates[i] && d->predicates[i][0])
375 ? d->predicates[i] : "0"));
376 if (d->n_operands == 0)
383 printf ("\nconst int insn_n_alternatives[] =\n {\n");
384 for (d = insn_data; d; d = d->next)
385 printf (" %d,\n", d->n_alternatives);
389 /* scan_operands (X) stores in max_opno the largest operand
390 number present in X, if that is larger than the previous
391 value of max_opno. It stores all the constraints in `constraints'
392 and all the machine modes in `modes'.
394 THIS_ADDRESS_P is nonzero if the containing rtx was an ADDRESS.
395 THIS_STRICT_LOW is nonzero if the containing rtx was a STRICT_LOW_PART. */
399 static char *constraints[MAX_MAX_OPERANDS];
400 static int op_n_alternatives[MAX_MAX_OPERANDS];
401 static char *predicates[MAX_MAX_OPERANDS];
402 static char address_p[MAX_MAX_OPERANDS];
403 static enum machine_mode modes[MAX_MAX_OPERANDS];
404 static char strict_low[MAX_MAX_OPERANDS];
405 static char seen[MAX_MAX_OPERANDS];
408 scan_operands (part, this_address_p, this_strict_low)
414 register char *format_ptr;
420 switch (GET_CODE (part))
423 opno = XINT (part, 0);
426 if (max_opno >= MAX_MAX_OPERANDS)
428 error ("Too many operands (%d) in definition %d.\n",
429 max_opno + 1, next_index_number);
433 error ("Definition %d specified operand number %d more than once.\n",
434 next_index_number, opno);
436 modes[opno] = GET_MODE (part);
437 strict_low[opno] = this_strict_low;
438 predicates[opno] = XSTR (part, 1);
439 constraints[opno] = XSTR (part, 2);
440 if (XSTR (part, 2) != 0 && *XSTR (part, 2) != 0)
442 op_n_alternatives[opno] = n_occurrences (',', XSTR (part, 2)) + 1;
443 have_constraints = 1;
445 address_p[opno] = this_address_p;
449 opno = XINT (part, 0);
452 if (max_opno >= MAX_MAX_OPERANDS)
454 error ("Too many operands (%d) in definition %d.\n",
455 max_opno + 1, next_index_number);
459 error ("Definition %d specified operand number %d more than once.\n",
460 next_index_number, opno);
462 modes[opno] = GET_MODE (part);
463 strict_low[opno] = 0;
464 predicates[opno] = "scratch_operand";
465 constraints[opno] = XSTR (part, 1);
466 if (XSTR (part, 1) != 0 && *XSTR (part, 1) != 0)
468 op_n_alternatives[opno] = n_occurrences (',', XSTR (part, 1)) + 1;
469 have_constraints = 1;
476 opno = XINT (part, 0);
479 if (max_opno >= MAX_MAX_OPERANDS)
481 error ("Too many operands (%d) in definition %d.\n",
482 max_opno + 1, next_index_number);
486 error ("Definition %d specified operand number %d more than once.\n",
487 next_index_number, opno);
489 modes[opno] = GET_MODE (part);
490 strict_low[opno] = 0;
491 predicates[opno] = XSTR (part, 1);
492 constraints[opno] = 0;
494 for (i = 0; i < XVECLEN (part, 2); i++)
495 scan_operands (XVECEXP (part, 2, i), 0, 0);
504 scan_operands (XEXP (part, 0), 1, 0);
507 case STRICT_LOW_PART:
508 scan_operands (XEXP (part, 0), 0, 1);
512 format_ptr = GET_RTX_FORMAT (GET_CODE (part));
514 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (part)); i++)
515 switch (*format_ptr++)
518 scan_operands (XEXP (part, i), 0, 0);
521 if (XVEC (part, i) != NULL)
522 for (j = 0; j < XVECLEN (part, i); j++)
523 scan_operands (XVECEXP (part, i, j), 0, 0);
528 /* Process an assembler template from a define_insn or a define_peephole.
529 It is either the assembler code template, a list of assembler code
530 templates, or C code to generate the assembler code template. */
533 process_template (d, template)
540 /* We need to consider only the instructions whose assembler code template
541 starts with a * or @. These are the ones where C code is run to decide
542 on a template to use. So for all others just return now. */
544 if (template[0] != '*' && template[0] != '@')
546 d->template = template;
554 printf ("\nstatic char *\n");
555 printf ("output_%d (operands, insn)\n", d->code_number);
556 printf (" rtx *operands;\n");
557 printf (" rtx insn;\n");
560 /* If the assembler code template starts with a @ it is a newline-separated
561 list of assembler code templates, one for each alternative. So produce
562 a routine to select the correct one. */
564 if (template[0] == '@')
567 printf (" static /*const*/ char *const strings_%d[] = {\n",
570 for (i = 0, cp = &template[1]; *cp; )
572 while (*cp == '\n' || *cp == ' ' || *cp== '\t')
576 while (*cp != '\n' && *cp != '\0')
584 printf (" return strings_%d[which_alternative];\n", d->code_number);
586 if (i != d->n_alternatives)
587 fatal ("Insn pattern %d has %d alternatives but %d assembler choices",
588 d->index_number, d->n_alternatives, i);
593 /* The following is done in a funny way to get around problems in
594 VAX-11 "C" on VMS. It is the equivalent of:
595 printf ("%s\n", &template[1])); */
597 while (*cp) putchar (*cp++);
604 /* Check insn D for consistency in number of constraint alternatives. */
607 validate_insn_alternatives (d)
610 register int n = 0, start;
611 /* Make sure all the operands have the same number of
612 alternatives in their constraints.
613 Let N be that number. */
614 for (start = 0; start < d->n_operands; start++)
615 if (d->op_n_alternatives[start] > 0)
618 n = d->op_n_alternatives[start];
619 else if (n != d->op_n_alternatives[start])
620 error ("wrong number of alternatives in operand %d of insn number %d",
621 start, d->index_number);
623 /* Record the insn's overall number of alternatives. */
624 d->n_alternatives = n;
627 /* Look at a define_insn just read. Assign its code number.
628 Record on insn_data the template and the number of arguments.
629 If the insn has a hairy output action, output a function for now. */
635 register struct data *d = (struct data *) xmalloc (sizeof (struct data));
638 d->code_number = next_code_number++;
639 d->index_number = next_index_number;
640 if (XSTR (insn, 0)[0])
641 d->name = XSTR (insn, 0);
645 /* Build up the list in the same order as the insns are seen
646 in the machine description. */
648 if (end_of_insn_data)
649 end_of_insn_data->next = d;
653 end_of_insn_data = d;
658 mybzero (constraints, sizeof constraints);
659 mybzero (op_n_alternatives, sizeof op_n_alternatives);
660 mybzero (predicates, sizeof predicates);
661 mybzero (address_p, sizeof address_p);
662 mybzero (modes, sizeof modes);
663 mybzero (strict_low, sizeof strict_low);
664 mybzero (seen, sizeof seen);
666 for (i = 0; i < XVECLEN (insn, 1); i++)
667 scan_operands (XVECEXP (insn, 1, i), 0, 0);
669 d->n_operands = max_opno + 1;
670 d->n_dups = num_dups;
672 mybcopy (constraints, d->constraints, sizeof constraints);
673 mybcopy (op_n_alternatives, d->op_n_alternatives, sizeof op_n_alternatives);
674 mybcopy (predicates, d->predicates, sizeof predicates);
675 mybcopy (address_p, d->address_p, sizeof address_p);
676 mybcopy (modes, d->modes, sizeof modes);
677 mybcopy (strict_low, d->strict_low, sizeof strict_low);
679 validate_insn_alternatives (d);
680 process_template (d, XSTR (insn, 3));
683 /* Look at a define_peephole just read. Assign its code number.
684 Record on insn_data the template and the number of arguments.
685 If the insn has a hairy output action, output it now. */
691 register struct data *d = (struct data *) xmalloc (sizeof (struct data));
694 d->code_number = next_code_number++;
695 d->index_number = next_index_number;
698 /* Build up the list in the same order as the insns are seen
699 in the machine description. */
701 if (end_of_insn_data)
702 end_of_insn_data->next = d;
706 end_of_insn_data = d;
709 mybzero (constraints, sizeof constraints);
710 mybzero (op_n_alternatives, sizeof op_n_alternatives);
711 mybzero (predicates, sizeof predicates);
712 mybzero (address_p, sizeof address_p);
713 mybzero (modes, sizeof modes);
714 mybzero (strict_low, sizeof strict_low);
715 mybzero (seen, sizeof seen);
717 /* Get the number of operands by scanning all the
718 patterns of the peephole optimizer.
719 But ignore all the rest of the information thus obtained. */
720 for (i = 0; i < XVECLEN (peep, 0); i++)
721 scan_operands (XVECEXP (peep, 0, i), 0, 0);
723 d->n_operands = max_opno + 1;
726 mybcopy (constraints, d->constraints, sizeof constraints);
727 mybcopy (op_n_alternatives, d->op_n_alternatives, sizeof op_n_alternatives);
728 mybzero (d->predicates, sizeof predicates);
729 mybzero (d->address_p, sizeof address_p);
730 mybzero (d->modes, sizeof modes);
731 mybzero (d->strict_low, sizeof strict_low);
733 validate_insn_alternatives (d);
734 process_template (d, XSTR (peep, 2));
737 /* Process a define_expand just read. Assign its code number,
738 only for the purposes of `insn_gen_function'. */
744 register struct data *d = (struct data *) xmalloc (sizeof (struct data));
747 d->code_number = next_code_number++;
748 d->index_number = next_index_number;
749 if (XSTR (insn, 0)[0])
750 d->name = XSTR (insn, 0);
754 /* Build up the list in the same order as the insns are seen
755 in the machine description. */
757 if (end_of_insn_data)
758 end_of_insn_data->next = d;
762 end_of_insn_data = d;
767 /* Scan the operands to get the specified predicates and modes,
768 since expand_binop needs to know them. */
770 mybzero (constraints, sizeof constraints);
771 mybzero (op_n_alternatives, sizeof op_n_alternatives);
772 mybzero (predicates, sizeof predicates);
773 mybzero (address_p, sizeof address_p);
774 mybzero (modes, sizeof modes);
775 mybzero (strict_low, sizeof strict_low);
776 mybzero (seen, sizeof seen);
779 for (i = 0; i < XVECLEN (insn, 1); i++)
780 scan_operands (XVECEXP (insn, 1, i), 0, 0);
782 d->n_operands = max_opno + 1;
783 d->n_dups = num_dups;
785 mybcopy (constraints, d->constraints, sizeof constraints);
786 mybcopy (op_n_alternatives, d->op_n_alternatives, sizeof op_n_alternatives);
787 mybcopy (predicates, d->predicates, sizeof predicates);
788 mybcopy (address_p, d->address_p, sizeof address_p);
789 mybcopy (modes, d->modes, sizeof modes);
790 mybcopy (strict_low, d->strict_low, sizeof strict_low);
794 validate_insn_alternatives (d);
797 /* Process a define_split just read. Assign its code number,
798 only for reasons of consistency and to simplify genrecog. */
805 register struct data *d = (struct data *) xmalloc (sizeof (struct data));
808 d->code_number = next_code_number++;
809 d->index_number = next_index_number;
812 /* Build up the list in the same order as the insns are seen
813 in the machine description. */
815 if (end_of_insn_data)
816 end_of_insn_data->next = d;
820 end_of_insn_data = d;
825 mybzero (constraints, sizeof constraints);
826 mybzero (op_n_alternatives, sizeof op_n_alternatives);
827 mybzero (predicates, sizeof predicates);
828 mybzero (address_p, sizeof address_p);
829 mybzero (modes, sizeof modes);
830 mybzero (strict_low, sizeof strict_low);
831 mybzero (seen, sizeof seen);
833 /* Get the number of operands by scanning all the
834 patterns of the split patterns.
835 But ignore all the rest of the information thus obtained. */
836 for (i = 0; i < XVECLEN (split, 0); i++)
837 scan_operands (XVECEXP (split, 0, i), 0, 0);
839 d->n_operands = max_opno + 1;
841 mybzero (d->constraints, sizeof constraints);
842 mybzero (d->op_n_alternatives, sizeof op_n_alternatives);
843 mybzero (d->predicates, sizeof predicates);
844 mybzero (d->address_p, sizeof address_p);
845 mybzero (d->modes, sizeof modes);
846 mybzero (d->strict_low, sizeof strict_low);
857 register char *val = (char *) malloc (size);
860 fatal ("virtual memory exhausted");
869 char *result = (char *) realloc (ptr, size);
871 fatal ("virtual memory exhausted");
878 register unsigned length;
885 mybcopy (b1, b2, length)
888 register unsigned length;
895 fatal (s, a1, a2, a3, a4)
898 fprintf (stderr, "genoutput: ");
899 fprintf (stderr, s, a1, a2, a3, a4);
900 fprintf (stderr, "\n");
901 exit (FATAL_EXIT_CODE);
904 /* More 'friendly' abort that prints the line and file.
905 config.h can #define abort fancy_abort if you like that sort of thing. */
910 fatal ("Internal gcc abort.");
917 fprintf (stderr, "genoutput: ");
918 fprintf (stderr, s, a1, a2);
919 fprintf (stderr, "\n");
931 obstack_init (rtl_obstack);
934 fatal ("No input file name.");
936 infile = fopen (argv[1], "r");
940 exit (FATAL_EXIT_CODE);
946 next_code_number = 0;
947 next_index_number = 0;
948 have_constraints = 0;
950 /* Read the machine description. */
954 c = read_skip_spaces (infile);
959 desc = read_rtx (infile);
960 if (GET_CODE (desc) == DEFINE_INSN)
962 if (GET_CODE (desc) == DEFINE_PEEPHOLE)
964 if (GET_CODE (desc) == DEFINE_EXPAND)
966 if (GET_CODE (desc) == DEFINE_SPLIT)
974 exit (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);