1 /* Generate code from to output assembler insns as recognized from rtl.
2 Copyright (C) 1987, 88, 92, 94, 95, 97, 1998 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, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
22 /* This program reads the machine description for the compiler target machine
23 and produces a file containing these things:
25 1. An array of strings `insn_template' which is indexed by insn code number
26 and contains the template for output of that insn,
28 2. An array of functions `insn_outfun' which, indexed by the insn code
29 number, gives the function that returns a template to use for output of
30 that insn. This is used only in the cases where the template is not
31 constant. These cases are specified by a * or @ at the beginning of the
32 template string in the machine description. They are identified for the
33 sake of other parts of the compiler by a zero element in `insn_template'.
35 3. An array of functions `insn_gen_function' which, indexed
36 by insn code number, gives the function to generate a body
37 for that pattern, given operands as arguments.
39 4. An array of strings `insn_name' which, indexed by insn code number,
40 gives the name for that pattern. Nameless patterns are given a name.
42 5. An array of ints `insn_n_operands' which is indexed by insn code number
43 and contains the number of distinct operands in the pattern for that insn,
45 6. An array of ints `insn_n_dups' which is indexed by insn code number
46 and contains the number of match_dup's that appear in the insn's pattern.
47 This says how many elements of `recog_dup_loc' are significant
48 after an insn has been recognized.
50 7. An array of arrays of operand constraint strings,
51 `insn_operand_constraint',
52 indexed first by insn code number and second by operand number,
53 containing the constraint for that operand.
55 This array is generated only if register constraints appear in
58 8. An array of arrays of chars which indicate which operands of
59 which insn patterns appear within ADDRESS rtx's. This array is
60 called `insn_operand_address_p' and is generated only if there
61 are *no* register constraints in the match_operand rtx's.
63 9. An array of arrays of machine modes, `insn_operand_mode',
64 indexed first by insn code number and second by operand number,
65 containing the machine mode that that operand is supposed to have.
66 Also `insn_operand_strict_low', which is nonzero for operands
67 contained in a STRICT_LOW_PART.
69 10. An array of arrays of int-valued functions, `insn_operand_predicate',
70 indexed first by insn code number and second by operand number,
71 containing the match_operand predicate for this operand.
73 11. An array of ints, `insn_n_alternatives', that gives the number
74 of alternatives in the constraints of each pattern.
76 The code number of an insn is simply its position in the machine description;
77 code numbers are assigned sequentially to entries in the description,
78 starting with code number 0.
80 Thus, the following entry in the machine description
83 [(set (match_operand:DF 0 "general_operand" "")
88 assuming it is the 25th entry present, would cause
89 insn_template[24] to be "clrd %0", and insn_n_operands[24] to be 1.
90 It would not make an case in output_insn_hairy because the template
91 given in the entry is a constant (it does not start with `*'). */
98 /* No instruction can have more operands than this.
99 Sorry for this arbitrary limit, but what machine will
100 have an instruction with this many operands? */
102 #define MAX_MAX_OPERANDS 40
104 static struct obstack obstack;
105 struct obstack *rtl_obstack = &obstack;
107 #define obstack_chunk_alloc xmalloc
108 #define obstack_chunk_free free
110 static void fatal PVPROTO ((char *, ...))
111 ATTRIBUTE_PRINTF_1 ATTRIBUTE_NORETURN;
112 void fancy_abort PROTO((void)) ATTRIBUTE_NORETURN;
113 static void error PVPROTO ((char *, ...)) ATTRIBUTE_PRINTF_1;
114 static void mybcopy ();
115 static void mybzero ();
116 static int n_occurrences PROTO((int, char *));
118 /* Define this so we can link with print-rtl.o to get debug_rtx function. */
119 char **insn_name_ptr = 0;
121 /* insns in the machine description are assigned sequential code numbers
122 that are used by insn-recog.c (produced by genrecog) to communicate
123 to insn-output.c (produced by this program). */
125 static int next_code_number;
127 /* This counts all definitions in the md file,
128 for the sake of error messages. */
130 static int next_index_number;
132 /* Record in this chain all information that we will output,
133 associated with the code number of the insn. */
140 char *template; /* string such as "movl %1,%0" */
141 int n_operands; /* Number of operands this insn recognizes */
142 int n_dups; /* Number times match_dup appears in pattern */
143 int n_alternatives; /* Number of alternatives in each constraint */
145 char *constraints[MAX_MAX_OPERANDS];
146 /* Number of alternatives in constraints of operand N. */
147 int op_n_alternatives[MAX_MAX_OPERANDS];
148 char *predicates[MAX_MAX_OPERANDS];
149 char address_p[MAX_MAX_OPERANDS];
150 enum machine_mode modes[MAX_MAX_OPERANDS];
151 char strict_low[MAX_MAX_OPERANDS];
152 char outfun; /* Nonzero means this has an output function */
155 /* This variable points to the first link in the chain. */
157 struct data *insn_data;
159 /* Pointer to the last link in the chain, so new elements
160 can be added at the end. */
162 struct data *end_of_insn_data;
164 /* Nonzero if any match_operand has a constraint string;
165 implies that REGISTER_CONSTRAINTS will be defined
166 for this machine description. */
168 int have_constraints;
170 /* Nonzero if some error has occurred. We will make all errors fatal, but
171 might as well continue until we see all of them. */
173 static int have_error;
175 static void output_prologue PROTO((void));
176 static void output_epilogue PROTO((void));
177 static void scan_operands PROTO((rtx, int, int));
178 static void process_template PROTO((struct data *, char *));
179 static void validate_insn_alternatives PROTO((struct data *));
180 static void gen_insn PROTO((rtx));
181 static void gen_peephole PROTO((rtx));
182 static void gen_expand PROTO((rtx));
183 static void gen_split PROTO((rtx));
184 static int n_occurrences PROTO((int, char *));
189 printf ("/* Generated automatically by the program `genoutput'\n\
190 from the machine description file `md'. */\n\n");
192 printf ("#include \"config.h\"\n");
193 printf ("#include \"system.h\"\n");
194 printf ("#include \"flags.h\"\n");
195 printf ("#include \"rtl.h\"\n");
196 printf ("#include \"regs.h\"\n");
197 printf ("#include \"hard-reg-set.h\"\n");
198 printf ("#include \"real.h\"\n");
199 printf ("#include \"insn-config.h\"\n\n");
200 printf ("#include \"conditions.h\"\n");
201 printf ("#include \"insn-flags.h\"\n");
202 printf ("#include \"insn-attr.h\"\n\n");
203 printf ("#include \"insn-codes.h\"\n\n");
204 printf ("#include \"recog.h\"\n\n");
206 printf ("#include \"output.h\"\n");
212 register struct data *d;
214 printf ("\nchar * const insn_template[] =\n {\n");
215 for (d = insn_data; d; d = d->next)
218 printf (" \"%s\",\n", d->template);
224 printf ("\nchar *(*const insn_outfun[])() =\n {\n");
225 for (d = insn_data; d; d = d->next)
228 printf (" output_%d,\n", d->code_number);
234 printf ("\nrtx (*const insn_gen_function[]) () =\n {\n");
235 for (d = insn_data; d; d = d->next)
237 if (d->name && d->name[0] != '*')
238 printf (" gen_%s,\n", d->name);
244 printf ("\nchar *insn_name[] =\n {\n");
248 char * last_name = 0;
249 char * next_name = 0;
250 register struct data *n;
252 for (n = insn_data, next = 1; n; n = n->next, next++)
259 for (d = insn_data; d; d = d->next)
263 printf (" \"%s\",\n", d->name);
267 for (n = d->next, next = 1; n; n = n->next, next++)
277 if (next_name && (last_name == 0 || offset > next / 2))
278 printf (" \"%s-%d\",\n", next_name, next - offset);
280 printf (" \"%s+%d\",\n", last_name, offset);
285 printf ("char **insn_name_ptr = insn_name;\n");
287 printf ("\nconst int insn_n_operands[] =\n {\n");
288 for (d = insn_data; d; d = d->next)
289 printf (" %d,\n", d->n_operands);
292 printf ("\nconst int insn_n_dups[] =\n {\n");
293 for (d = insn_data; d; d = d->next)
294 printf (" %d,\n", d->n_dups);
297 if (have_constraints)
299 printf ("\nchar *const insn_operand_constraint[][MAX_RECOG_OPERANDS] =\n {\n");
300 for (d = insn_data; d; d = d->next)
304 for (i = 0; i < d->n_operands; i++)
306 if (d->constraints[i] == 0)
309 printf (" \"%s\",", d->constraints[i]);
311 if (d->n_operands == 0)
319 printf ("\nconst char insn_operand_address_p[][MAX_RECOG_OPERANDS] =\n {\n");
320 for (d = insn_data; d; d = d->next)
324 for (i = 0; i < d->n_operands; i++)
325 printf (" %d,", d->address_p[i]);
326 if (d->n_operands == 0)
333 printf ("\nconst enum machine_mode insn_operand_mode[][MAX_RECOG_OPERANDS] =\n {\n");
334 for (d = insn_data; d; d = d->next)
338 for (i = 0; i < d->n_operands; i++)
339 printf (" %smode,", GET_MODE_NAME (d->modes[i]));
340 if (d->n_operands == 0)
341 printf (" VOIDmode");
346 printf ("\nconst char insn_operand_strict_low[][MAX_RECOG_OPERANDS] =\n {\n");
347 for (d = insn_data; d; d = d->next)
351 for (i = 0; i < d->n_operands; i++)
352 printf (" %d,", d->strict_low[i]);
353 if (d->n_operands == 0)
360 /* We need to define all predicates used. Keep a list of those we
361 have defined so far. There normally aren't very many predicates used,
362 so a linked list should be fast enough. */
363 struct predicate { char *name; struct predicate *next; } *predicates = 0;
368 for (d = insn_data; d; d = d->next)
369 for (i = 0; i < d->n_operands; i++)
370 if (d->predicates[i] && d->predicates[i][0])
372 for (p = predicates; p; p = p->next)
373 if (! strcmp (p->name, d->predicates[i]))
378 printf ("extern int %s ();\n", d->predicates[i]);
379 p = (struct predicate *) alloca (sizeof (struct predicate));
380 p->name = d->predicates[i];
381 p->next = predicates;
386 printf ("\nint (*const insn_operand_predicate[][MAX_RECOG_OPERANDS])() =\n {\n");
387 for (d = insn_data; d; d = d->next)
390 for (i = 0; i < d->n_operands; i++)
391 printf (" %s,", ((d->predicates[i] && d->predicates[i][0])
392 ? d->predicates[i] : "0"));
393 if (d->n_operands == 0)
400 printf ("\nconst int insn_n_alternatives[] =\n {\n");
401 for (d = insn_data; d; d = d->next)
402 printf (" %d,\n", d->n_alternatives);
406 /* scan_operands (X) stores in max_opno the largest operand
407 number present in X, if that is larger than the previous
408 value of max_opno. It stores all the constraints in `constraints'
409 and all the machine modes in `modes'.
411 THIS_ADDRESS_P is nonzero if the containing rtx was an ADDRESS.
412 THIS_STRICT_LOW is nonzero if the containing rtx was a STRICT_LOW_PART. */
416 static char *constraints[MAX_MAX_OPERANDS];
417 static int op_n_alternatives[MAX_MAX_OPERANDS];
418 static char *predicates[MAX_MAX_OPERANDS];
419 static char address_p[MAX_MAX_OPERANDS];
420 static enum machine_mode modes[MAX_MAX_OPERANDS];
421 static char strict_low[MAX_MAX_OPERANDS];
422 static char seen[MAX_MAX_OPERANDS];
425 scan_operands (part, this_address_p, this_strict_low)
431 register char *format_ptr;
437 switch (GET_CODE (part))
440 opno = XINT (part, 0);
443 if (max_opno >= MAX_MAX_OPERANDS)
445 error ("Too many operands (%d) in definition %d.\n",
446 max_opno + 1, next_index_number);
450 error ("Definition %d specified operand number %d more than once.\n",
451 next_index_number, opno);
453 modes[opno] = GET_MODE (part);
454 strict_low[opno] = this_strict_low;
455 predicates[opno] = XSTR (part, 1);
456 constraints[opno] = XSTR (part, 2);
457 if (XSTR (part, 2) != 0 && *XSTR (part, 2) != 0)
459 op_n_alternatives[opno] = n_occurrences (',', XSTR (part, 2)) + 1;
460 have_constraints = 1;
462 address_p[opno] = this_address_p;
466 opno = XINT (part, 0);
469 if (max_opno >= MAX_MAX_OPERANDS)
471 error ("Too many operands (%d) in definition %d.\n",
472 max_opno + 1, next_index_number);
476 error ("Definition %d specified operand number %d more than once.\n",
477 next_index_number, opno);
479 modes[opno] = GET_MODE (part);
480 strict_low[opno] = 0;
481 predicates[opno] = "scratch_operand";
482 constraints[opno] = XSTR (part, 1);
483 if (XSTR (part, 1) != 0 && *XSTR (part, 1) != 0)
485 op_n_alternatives[opno] = n_occurrences (',', XSTR (part, 1)) + 1;
486 have_constraints = 1;
493 opno = XINT (part, 0);
496 if (max_opno >= MAX_MAX_OPERANDS)
498 error ("Too many operands (%d) in definition %d.\n",
499 max_opno + 1, next_index_number);
503 error ("Definition %d specified operand number %d more than once.\n",
504 next_index_number, opno);
506 modes[opno] = GET_MODE (part);
507 strict_low[opno] = 0;
508 predicates[opno] = XSTR (part, 1);
509 constraints[opno] = 0;
511 for (i = 0; i < XVECLEN (part, 2); i++)
512 scan_operands (XVECEXP (part, 2, i), 0, 0);
522 scan_operands (XEXP (part, 0), 1, 0);
525 case STRICT_LOW_PART:
526 scan_operands (XEXP (part, 0), 0, 1);
533 format_ptr = GET_RTX_FORMAT (GET_CODE (part));
535 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (part)); i++)
536 switch (*format_ptr++)
540 scan_operands (XEXP (part, i), 0, 0);
543 if (XVEC (part, i) != NULL)
544 for (j = 0; j < XVECLEN (part, i); j++)
545 scan_operands (XVECEXP (part, i, j), 0, 0);
550 /* Process an assembler template from a define_insn or a define_peephole.
551 It is either the assembler code template, a list of assembler code
552 templates, or C code to generate the assembler code template. */
555 process_template (d, template)
562 /* We need to consider only the instructions whose assembler code template
563 starts with a * or @. These are the ones where C code is run to decide
564 on a template to use. So for all others just return now. */
566 if (template[0] != '*' && template[0] != '@')
568 d->template = template;
576 printf ("\nstatic char *\n");
577 printf ("output_%d (operands, insn)\n", d->code_number);
578 printf (" rtx *operands ATTRIBUTE_UNUSED;\n");
579 printf (" rtx insn ATTRIBUTE_UNUSED;\n");
582 /* If the assembler code template starts with a @ it is a newline-separated
583 list of assembler code templates, one for each alternative. So produce
584 a routine to select the correct one. */
586 if (template[0] == '@')
589 printf (" static /*const*/ char *const strings_%d[] = {\n",
592 for (i = 0, cp = &template[1]; *cp; )
594 while (*cp == '\n' || *cp == ' ' || *cp== '\t')
598 while (*cp != '\n' && *cp != '\0')
609 printf (" return strings_%d[which_alternative];\n", d->code_number);
611 if (i != d->n_alternatives)
612 fatal ("Insn pattern %d has %d alternatives but %d assembler choices",
613 d->index_number, d->n_alternatives, i);
618 /* The following is done in a funny way to get around problems in
619 VAX-11 "C" on VMS. It is the equivalent of:
620 printf ("%s\n", &template[1])); */
633 /* Check insn D for consistency in number of constraint alternatives. */
636 validate_insn_alternatives (d)
639 register int n = 0, start;
640 /* Make sure all the operands have the same number of
641 alternatives in their constraints.
642 Let N be that number. */
643 for (start = 0; start < d->n_operands; start++)
644 if (d->op_n_alternatives[start] > 0)
647 n = d->op_n_alternatives[start];
648 else if (n != d->op_n_alternatives[start])
649 error ("wrong number of alternatives in operand %d of insn number %d",
650 start, d->index_number);
652 /* Record the insn's overall number of alternatives. */
653 d->n_alternatives = n;
656 /* Look at a define_insn just read. Assign its code number.
657 Record on insn_data the template and the number of arguments.
658 If the insn has a hairy output action, output a function for now. */
664 register struct data *d = (struct data *) xmalloc (sizeof (struct data));
667 d->code_number = next_code_number++;
668 d->index_number = next_index_number;
669 if (XSTR (insn, 0)[0])
670 d->name = XSTR (insn, 0);
674 /* Build up the list in the same order as the insns are seen
675 in the machine description. */
677 if (end_of_insn_data)
678 end_of_insn_data->next = d;
682 end_of_insn_data = d;
687 mybzero (constraints, sizeof constraints);
688 mybzero (op_n_alternatives, sizeof op_n_alternatives);
689 mybzero (predicates, sizeof predicates);
690 mybzero (address_p, sizeof address_p);
691 mybzero (modes, sizeof modes);
692 mybzero (strict_low, sizeof strict_low);
693 mybzero (seen, sizeof seen);
695 for (i = 0; i < XVECLEN (insn, 1); i++)
696 scan_operands (XVECEXP (insn, 1, i), 0, 0);
698 d->n_operands = max_opno + 1;
699 d->n_dups = num_dups;
701 mybcopy (constraints, d->constraints, sizeof constraints);
702 mybcopy (op_n_alternatives, d->op_n_alternatives, sizeof op_n_alternatives);
703 mybcopy (predicates, d->predicates, sizeof predicates);
704 mybcopy (address_p, d->address_p, sizeof address_p);
705 mybcopy (modes, d->modes, sizeof modes);
706 mybcopy (strict_low, d->strict_low, sizeof strict_low);
708 validate_insn_alternatives (d);
709 process_template (d, XSTR (insn, 3));
712 /* Look at a define_peephole just read. Assign its code number.
713 Record on insn_data the template and the number of arguments.
714 If the insn has a hairy output action, output it now. */
720 register struct data *d = (struct data *) xmalloc (sizeof (struct data));
723 d->code_number = next_code_number++;
724 d->index_number = next_index_number;
727 /* Build up the list in the same order as the insns are seen
728 in the machine description. */
730 if (end_of_insn_data)
731 end_of_insn_data->next = d;
735 end_of_insn_data = d;
738 mybzero (constraints, sizeof constraints);
739 mybzero (op_n_alternatives, sizeof op_n_alternatives);
740 mybzero (predicates, sizeof predicates);
741 mybzero (address_p, sizeof address_p);
742 mybzero (modes, sizeof modes);
743 mybzero (strict_low, sizeof strict_low);
744 mybzero (seen, sizeof seen);
746 /* Get the number of operands by scanning all the
747 patterns of the peephole optimizer.
748 But ignore all the rest of the information thus obtained. */
749 for (i = 0; i < XVECLEN (peep, 0); i++)
750 scan_operands (XVECEXP (peep, 0, i), 0, 0);
752 d->n_operands = max_opno + 1;
755 mybcopy (constraints, d->constraints, sizeof constraints);
756 mybcopy (op_n_alternatives, d->op_n_alternatives, sizeof op_n_alternatives);
757 mybzero (d->predicates, sizeof predicates);
758 mybzero (d->address_p, sizeof address_p);
759 mybzero (d->modes, sizeof modes);
760 mybzero (d->strict_low, sizeof strict_low);
762 validate_insn_alternatives (d);
763 process_template (d, XSTR (peep, 2));
766 /* Process a define_expand just read. Assign its code number,
767 only for the purposes of `insn_gen_function'. */
773 register struct data *d = (struct data *) xmalloc (sizeof (struct data));
776 d->code_number = next_code_number++;
777 d->index_number = next_index_number;
778 if (XSTR (insn, 0)[0])
779 d->name = XSTR (insn, 0);
783 /* Build up the list in the same order as the insns are seen
784 in the machine description. */
786 if (end_of_insn_data)
787 end_of_insn_data->next = d;
791 end_of_insn_data = d;
796 /* Scan the operands to get the specified predicates and modes,
797 since expand_binop needs to know them. */
799 mybzero (constraints, sizeof constraints);
800 mybzero (op_n_alternatives, sizeof op_n_alternatives);
801 mybzero (predicates, sizeof predicates);
802 mybzero (address_p, sizeof address_p);
803 mybzero (modes, sizeof modes);
804 mybzero (strict_low, sizeof strict_low);
805 mybzero (seen, sizeof seen);
808 for (i = 0; i < XVECLEN (insn, 1); i++)
809 scan_operands (XVECEXP (insn, 1, i), 0, 0);
811 d->n_operands = max_opno + 1;
812 d->n_dups = num_dups;
814 mybcopy (constraints, d->constraints, sizeof constraints);
815 mybcopy (op_n_alternatives, d->op_n_alternatives, sizeof op_n_alternatives);
816 mybcopy (predicates, d->predicates, sizeof predicates);
817 mybcopy (address_p, d->address_p, sizeof address_p);
818 mybcopy (modes, d->modes, sizeof modes);
819 mybcopy (strict_low, d->strict_low, sizeof strict_low);
823 validate_insn_alternatives (d);
826 /* Process a define_split just read. Assign its code number,
827 only for reasons of consistency and to simplify genrecog. */
834 register struct data *d = (struct data *) xmalloc (sizeof (struct data));
837 d->code_number = next_code_number++;
838 d->index_number = next_index_number;
841 /* Build up the list in the same order as the insns are seen
842 in the machine description. */
844 if (end_of_insn_data)
845 end_of_insn_data->next = d;
849 end_of_insn_data = d;
854 mybzero (constraints, sizeof constraints);
855 mybzero (op_n_alternatives, sizeof op_n_alternatives);
856 mybzero (predicates, sizeof predicates);
857 mybzero (address_p, sizeof address_p);
858 mybzero (modes, sizeof modes);
859 mybzero (strict_low, sizeof strict_low);
860 mybzero (seen, sizeof seen);
862 /* Get the number of operands by scanning all the
863 patterns of the split patterns.
864 But ignore all the rest of the information thus obtained. */
865 for (i = 0; i < XVECLEN (split, 0); i++)
866 scan_operands (XVECEXP (split, 0, i), 0, 0);
868 d->n_operands = max_opno + 1;
870 mybzero (d->constraints, sizeof constraints);
871 mybzero (d->op_n_alternatives, sizeof op_n_alternatives);
872 mybzero (d->predicates, sizeof predicates);
873 mybzero (d->address_p, sizeof address_p);
874 mybzero (d->modes, sizeof modes);
875 mybzero (d->strict_low, sizeof strict_low);
878 d->n_alternatives = 0;
887 register PTR val = (PTR) malloc (size);
890 fatal ("virtual memory exhausted");
899 register PTR result = (PTR) realloc (ptr, size);
901 fatal ("virtual memory exhausted");
908 register unsigned length;
915 mybcopy (b1, b2, length)
918 register unsigned length;
925 fatal VPROTO ((char *format, ...))
927 #ifndef ANSI_PROTOTYPES
932 VA_START (ap, format);
934 #ifndef ANSI_PROTOTYPES
935 format = va_arg (ap, char *);
938 fprintf (stderr, "genoutput: ");
939 vfprintf (stderr, format, ap);
941 fprintf (stderr, "\n");
942 exit (FATAL_EXIT_CODE);
945 /* More 'friendly' abort that prints the line and file.
946 config.h can #define abort fancy_abort if you like that sort of thing. */
951 fatal ("Internal gcc abort.");
955 error VPROTO ((char *format, ...))
957 #ifndef ANSI_PROTOTYPES
962 VA_START (ap, format);
964 #ifndef ANSI_PROTOTYPES
965 format = va_arg (ap, char *);
968 fprintf (stderr, "genoutput: ");
969 vfprintf (stderr, format, ap);
971 fprintf (stderr, "\n");
985 obstack_init (rtl_obstack);
988 fatal ("No input file name.");
990 infile = fopen (argv[1], "r");
994 exit (FATAL_EXIT_CODE);
1000 next_code_number = 0;
1001 next_index_number = 0;
1002 have_constraints = 0;
1004 /* Read the machine description. */
1008 c = read_skip_spaces (infile);
1013 desc = read_rtx (infile);
1014 if (GET_CODE (desc) == DEFINE_INSN)
1016 if (GET_CODE (desc) == DEFINE_PEEPHOLE)
1017 gen_peephole (desc);
1018 if (GET_CODE (desc) == DEFINE_EXPAND)
1020 if (GET_CODE (desc) == DEFINE_SPLIT)
1022 next_index_number++;
1028 exit (ferror (stdout) != 0 || have_error
1029 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
1036 n_occurrences (c, s)