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 char *xmalloc
PROTO((unsigned));
111 static void fatal ();
112 void fancy_abort
PROTO((void));
113 static void error ();
114 static void mybcopy ();
115 static void mybzero ();
116 static int n_occurrences
PROTO((int, char *));
118 /* insns in the machine description are assigned sequential code numbers
119 that are used by insn-recog.c (produced by genrecog) to communicate
120 to insn-output.c (produced by this program). */
122 static int next_code_number
;
124 /* This counts all definitions in the md file,
125 for the sake of error messages. */
127 static int next_index_number
;
129 /* Record in this chain all information that we will output,
130 associated with the code number of the insn. */
137 char *template; /* string such as "movl %1,%0" */
138 int n_operands
; /* Number of operands this insn recognizes */
139 int n_dups
; /* Number times match_dup appears in pattern */
140 int n_alternatives
; /* Number of alternatives in each constraint */
142 char *constraints
[MAX_MAX_OPERANDS
];
143 /* Number of alternatives in constraints of operand N. */
144 int op_n_alternatives
[MAX_MAX_OPERANDS
];
145 char *predicates
[MAX_MAX_OPERANDS
];
146 char address_p
[MAX_MAX_OPERANDS
];
147 enum machine_mode modes
[MAX_MAX_OPERANDS
];
148 char strict_low
[MAX_MAX_OPERANDS
];
149 char outfun
; /* Nonzero means this has an output function */
152 /* This variable points to the first link in the chain. */
154 struct data
*insn_data
;
156 /* Pointer to the last link in the chain, so new elements
157 can be added at the end. */
159 struct data
*end_of_insn_data
;
161 /* Nonzero if any match_operand has a constraint string;
162 implies that REGISTER_CONSTRAINTS will be defined
163 for this machine description. */
165 int have_constraints
;
167 /* Nonzero if some error has occurred. We will make all errors fatal, but
168 might as well continue until we see all of them. */
170 static int have_error
;
172 static void output_prologue
PROTO((void));
173 static void output_epilogue
PROTO((void));
174 static void scan_operands
PROTO((rtx
, int, int));
175 static void process_template
PROTO((struct data
*, char *));
176 static void validate_insn_alternatives
PROTO((struct data
*));
177 static void gen_insn
PROTO((rtx
));
178 static void gen_peephole
PROTO((rtx
));
179 static void gen_expand
PROTO((rtx
));
180 static void gen_split
PROTO((rtx
));
181 static int n_occurrences
PROTO((int, char *));
186 printf ("/* Generated automatically by the program `genoutput'\n\
187 from the machine description file `md'. */\n\n");
189 printf ("#include \"config.h\"\n");
190 printf ("#include \"system.h\"\n");
191 printf ("#include \"flags.h\"\n");
192 printf ("#include \"rtl.h\"\n");
193 printf ("#include \"regs.h\"\n");
194 printf ("#include \"hard-reg-set.h\"\n");
195 printf ("#include \"real.h\"\n");
196 printf ("#include \"insn-config.h\"\n\n");
197 printf ("#include \"conditions.h\"\n");
198 printf ("#include \"insn-flags.h\"\n");
199 printf ("#include \"insn-attr.h\"\n\n");
200 printf ("#include \"insn-codes.h\"\n\n");
201 printf ("#include \"recog.h\"\n\n");
203 printf ("#include \"output.h\"\n");
209 register struct data
*d
;
211 printf ("\nchar * const insn_template[] =\n {\n");
212 for (d
= insn_data
; d
; d
= d
->next
)
215 printf (" \"%s\",\n", d
->template);
221 printf ("\nchar *(*const insn_outfun[])() =\n {\n");
222 for (d
= insn_data
; d
; d
= d
->next
)
225 printf (" output_%d,\n", d
->code_number
);
231 printf ("\nrtx (*const insn_gen_function[]) () =\n {\n");
232 for (d
= insn_data
; d
; d
= d
->next
)
234 if (d
->name
&& d
->name
[0] != '*')
235 printf (" gen_%s,\n", d
->name
);
241 printf ("\nchar *insn_name[] =\n {\n");
245 char * last_name
= 0;
246 char * next_name
= 0;
247 register struct data
*n
;
249 for (n
= insn_data
, next
= 1; n
; n
= n
->next
, next
++)
256 for (d
= insn_data
; d
; d
= d
->next
)
260 printf (" \"%s\",\n", d
->name
);
264 for (n
= d
->next
, next
= 1; n
; n
= n
->next
, next
++)
274 if (next_name
&& (last_name
== 0 || offset
> next
/ 2))
275 printf (" \"%s-%d\",\n", next_name
, next
- offset
);
277 printf (" \"%s+%d\",\n", last_name
, offset
);
282 printf ("char **insn_name_ptr = insn_name;\n");
284 printf ("\nconst int insn_n_operands[] =\n {\n");
285 for (d
= insn_data
; d
; d
= d
->next
)
286 printf (" %d,\n", d
->n_operands
);
289 printf ("\nconst int insn_n_dups[] =\n {\n");
290 for (d
= insn_data
; d
; d
= d
->next
)
291 printf (" %d,\n", d
->n_dups
);
294 if (have_constraints
)
296 printf ("\nchar *const insn_operand_constraint[][MAX_RECOG_OPERANDS] =\n {\n");
297 for (d
= insn_data
; d
; d
= d
->next
)
301 for (i
= 0; i
< d
->n_operands
; i
++)
303 if (d
->constraints
[i
] == 0)
306 printf (" \"%s\",", d
->constraints
[i
]);
308 if (d
->n_operands
== 0)
316 printf ("\nconst char insn_operand_address_p[][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 (" %d,", d
->address_p
[i
]);
323 if (d
->n_operands
== 0)
330 printf ("\nconst enum machine_mode insn_operand_mode[][MAX_RECOG_OPERANDS] =\n {\n");
331 for (d
= insn_data
; d
; d
= d
->next
)
335 for (i
= 0; i
< d
->n_operands
; i
++)
336 printf (" %smode,", GET_MODE_NAME (d
->modes
[i
]));
337 if (d
->n_operands
== 0)
338 printf (" VOIDmode");
343 printf ("\nconst char insn_operand_strict_low[][MAX_RECOG_OPERANDS] =\n {\n");
344 for (d
= insn_data
; d
; d
= d
->next
)
348 for (i
= 0; i
< d
->n_operands
; i
++)
349 printf (" %d,", d
->strict_low
[i
]);
350 if (d
->n_operands
== 0)
357 /* We need to define all predicates used. Keep a list of those we
358 have defined so far. There normally aren't very many predicates used,
359 so a linked list should be fast enough. */
360 struct predicate
{ char *name
; struct predicate
*next
; } *predicates
= 0;
365 for (d
= insn_data
; d
; d
= d
->next
)
366 for (i
= 0; i
< d
->n_operands
; i
++)
367 if (d
->predicates
[i
] && d
->predicates
[i
][0])
369 for (p
= predicates
; p
; p
= p
->next
)
370 if (! strcmp (p
->name
, d
->predicates
[i
]))
375 printf ("extern int %s ();\n", d
->predicates
[i
]);
376 p
= (struct predicate
*) alloca (sizeof (struct predicate
));
377 p
->name
= d
->predicates
[i
];
378 p
->next
= predicates
;
383 printf ("\nint (*const insn_operand_predicate[][MAX_RECOG_OPERANDS])() =\n {\n");
384 for (d
= insn_data
; d
; d
= d
->next
)
387 for (i
= 0; i
< d
->n_operands
; i
++)
388 printf (" %s,", ((d
->predicates
[i
] && d
->predicates
[i
][0])
389 ? d
->predicates
[i
] : "0"));
390 if (d
->n_operands
== 0)
397 printf ("\nconst int insn_n_alternatives[] =\n {\n");
398 for (d
= insn_data
; d
; d
= d
->next
)
399 printf (" %d,\n", d
->n_alternatives
);
403 /* scan_operands (X) stores in max_opno the largest operand
404 number present in X, if that is larger than the previous
405 value of max_opno. It stores all the constraints in `constraints'
406 and all the machine modes in `modes'.
408 THIS_ADDRESS_P is nonzero if the containing rtx was an ADDRESS.
409 THIS_STRICT_LOW is nonzero if the containing rtx was a STRICT_LOW_PART. */
413 static char *constraints
[MAX_MAX_OPERANDS
];
414 static int op_n_alternatives
[MAX_MAX_OPERANDS
];
415 static char *predicates
[MAX_MAX_OPERANDS
];
416 static char address_p
[MAX_MAX_OPERANDS
];
417 static enum machine_mode modes
[MAX_MAX_OPERANDS
];
418 static char strict_low
[MAX_MAX_OPERANDS
];
419 static char seen
[MAX_MAX_OPERANDS
];
422 scan_operands (part
, this_address_p
, this_strict_low
)
428 register char *format_ptr
;
434 switch (GET_CODE (part
))
437 opno
= XINT (part
, 0);
440 if (max_opno
>= MAX_MAX_OPERANDS
)
442 error ("Too many operands (%d) in definition %d.\n",
443 max_opno
+ 1, next_index_number
);
447 error ("Definition %d specified operand number %d more than once.\n",
448 next_index_number
, opno
);
450 modes
[opno
] = GET_MODE (part
);
451 strict_low
[opno
] = this_strict_low
;
452 predicates
[opno
] = XSTR (part
, 1);
453 constraints
[opno
] = XSTR (part
, 2);
454 if (XSTR (part
, 2) != 0 && *XSTR (part
, 2) != 0)
456 op_n_alternatives
[opno
] = n_occurrences (',', XSTR (part
, 2)) + 1;
457 have_constraints
= 1;
459 address_p
[opno
] = this_address_p
;
463 opno
= XINT (part
, 0);
466 if (max_opno
>= MAX_MAX_OPERANDS
)
468 error ("Too many operands (%d) in definition %d.\n",
469 max_opno
+ 1, next_index_number
);
473 error ("Definition %d specified operand number %d more than once.\n",
474 next_index_number
, opno
);
476 modes
[opno
] = GET_MODE (part
);
477 strict_low
[opno
] = 0;
478 predicates
[opno
] = "scratch_operand";
479 constraints
[opno
] = XSTR (part
, 1);
480 if (XSTR (part
, 1) != 0 && *XSTR (part
, 1) != 0)
482 op_n_alternatives
[opno
] = n_occurrences (',', XSTR (part
, 1)) + 1;
483 have_constraints
= 1;
490 opno
= XINT (part
, 0);
493 if (max_opno
>= MAX_MAX_OPERANDS
)
495 error ("Too many operands (%d) in definition %d.\n",
496 max_opno
+ 1, next_index_number
);
500 error ("Definition %d specified operand number %d more than once.\n",
501 next_index_number
, opno
);
503 modes
[opno
] = GET_MODE (part
);
504 strict_low
[opno
] = 0;
505 predicates
[opno
] = XSTR (part
, 1);
506 constraints
[opno
] = 0;
508 for (i
= 0; i
< XVECLEN (part
, 2); i
++)
509 scan_operands (XVECEXP (part
, 2, i
), 0, 0);
519 scan_operands (XEXP (part
, 0), 1, 0);
522 case STRICT_LOW_PART
:
523 scan_operands (XEXP (part
, 0), 0, 1);
530 format_ptr
= GET_RTX_FORMAT (GET_CODE (part
));
532 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (part
)); i
++)
533 switch (*format_ptr
++)
537 scan_operands (XEXP (part
, i
), 0, 0);
540 if (XVEC (part
, i
) != NULL
)
541 for (j
= 0; j
< XVECLEN (part
, i
); j
++)
542 scan_operands (XVECEXP (part
, i
, j
), 0, 0);
547 /* Process an assembler template from a define_insn or a define_peephole.
548 It is either the assembler code template, a list of assembler code
549 templates, or C code to generate the assembler code template. */
552 process_template (d
, template)
559 /* We need to consider only the instructions whose assembler code template
560 starts with a * or @. These are the ones where C code is run to decide
561 on a template to use. So for all others just return now. */
563 if (template[0] != '*' && template[0] != '@')
565 d
->template = template;
573 printf ("\nstatic char *\n");
574 printf ("output_%d (operands, insn)\n", d
->code_number
);
575 printf (" rtx *operands ATTRIBUTE_UNUSED;\n");
576 printf (" rtx insn ATTRIBUTE_UNUSED;\n");
579 /* If the assembler code template starts with a @ it is a newline-separated
580 list of assembler code templates, one for each alternative. So produce
581 a routine to select the correct one. */
583 if (template[0] == '@')
586 printf (" static /*const*/ char *const strings_%d[] = {\n",
589 for (i
= 0, cp
= &template[1]; *cp
; )
591 while (*cp
== '\n' || *cp
== ' ' || *cp
== '\t')
595 while (*cp
!= '\n' && *cp
!= '\0')
606 printf (" return strings_%d[which_alternative];\n", d
->code_number
);
608 if (i
!= d
->n_alternatives
)
609 fatal ("Insn pattern %d has %d alternatives but %d assembler choices",
610 d
->index_number
, d
->n_alternatives
, i
);
615 /* The following is done in a funny way to get around problems in
616 VAX-11 "C" on VMS. It is the equivalent of:
617 printf ("%s\n", &template[1])); */
630 /* Check insn D for consistency in number of constraint alternatives. */
633 validate_insn_alternatives (d
)
636 register int n
= 0, start
;
637 /* Make sure all the operands have the same number of
638 alternatives in their constraints.
639 Let N be that number. */
640 for (start
= 0; start
< d
->n_operands
; start
++)
641 if (d
->op_n_alternatives
[start
] > 0)
644 n
= d
->op_n_alternatives
[start
];
645 else if (n
!= d
->op_n_alternatives
[start
])
646 error ("wrong number of alternatives in operand %d of insn number %d",
647 start
, d
->index_number
);
649 /* Record the insn's overall number of alternatives. */
650 d
->n_alternatives
= n
;
653 /* Look at a define_insn just read. Assign its code number.
654 Record on insn_data the template and the number of arguments.
655 If the insn has a hairy output action, output a function for now. */
661 register struct data
*d
= (struct data
*) xmalloc (sizeof (struct data
));
664 d
->code_number
= next_code_number
++;
665 d
->index_number
= next_index_number
;
666 if (XSTR (insn
, 0)[0])
667 d
->name
= XSTR (insn
, 0);
671 /* Build up the list in the same order as the insns are seen
672 in the machine description. */
674 if (end_of_insn_data
)
675 end_of_insn_data
->next
= d
;
679 end_of_insn_data
= d
;
684 mybzero (constraints
, sizeof constraints
);
685 mybzero (op_n_alternatives
, sizeof op_n_alternatives
);
686 mybzero (predicates
, sizeof predicates
);
687 mybzero (address_p
, sizeof address_p
);
688 mybzero (modes
, sizeof modes
);
689 mybzero (strict_low
, sizeof strict_low
);
690 mybzero (seen
, sizeof seen
);
692 for (i
= 0; i
< XVECLEN (insn
, 1); i
++)
693 scan_operands (XVECEXP (insn
, 1, i
), 0, 0);
695 d
->n_operands
= max_opno
+ 1;
696 d
->n_dups
= num_dups
;
698 mybcopy (constraints
, d
->constraints
, sizeof constraints
);
699 mybcopy (op_n_alternatives
, d
->op_n_alternatives
, sizeof op_n_alternatives
);
700 mybcopy (predicates
, d
->predicates
, sizeof predicates
);
701 mybcopy (address_p
, d
->address_p
, sizeof address_p
);
702 mybcopy (modes
, d
->modes
, sizeof modes
);
703 mybcopy (strict_low
, d
->strict_low
, sizeof strict_low
);
705 validate_insn_alternatives (d
);
706 process_template (d
, XSTR (insn
, 3));
709 /* Look at a define_peephole just read. Assign its code number.
710 Record on insn_data the template and the number of arguments.
711 If the insn has a hairy output action, output it now. */
717 register struct data
*d
= (struct data
*) xmalloc (sizeof (struct data
));
720 d
->code_number
= next_code_number
++;
721 d
->index_number
= next_index_number
;
724 /* Build up the list in the same order as the insns are seen
725 in the machine description. */
727 if (end_of_insn_data
)
728 end_of_insn_data
->next
= d
;
732 end_of_insn_data
= d
;
735 mybzero (constraints
, sizeof constraints
);
736 mybzero (op_n_alternatives
, sizeof op_n_alternatives
);
737 mybzero (predicates
, sizeof predicates
);
738 mybzero (address_p
, sizeof address_p
);
739 mybzero (modes
, sizeof modes
);
740 mybzero (strict_low
, sizeof strict_low
);
741 mybzero (seen
, sizeof seen
);
743 /* Get the number of operands by scanning all the
744 patterns of the peephole optimizer.
745 But ignore all the rest of the information thus obtained. */
746 for (i
= 0; i
< XVECLEN (peep
, 0); i
++)
747 scan_operands (XVECEXP (peep
, 0, i
), 0, 0);
749 d
->n_operands
= max_opno
+ 1;
752 mybcopy (constraints
, d
->constraints
, sizeof constraints
);
753 mybcopy (op_n_alternatives
, d
->op_n_alternatives
, sizeof op_n_alternatives
);
754 mybzero (d
->predicates
, sizeof predicates
);
755 mybzero (d
->address_p
, sizeof address_p
);
756 mybzero (d
->modes
, sizeof modes
);
757 mybzero (d
->strict_low
, sizeof strict_low
);
759 validate_insn_alternatives (d
);
760 process_template (d
, XSTR (peep
, 2));
763 /* Process a define_expand just read. Assign its code number,
764 only for the purposes of `insn_gen_function'. */
770 register struct data
*d
= (struct data
*) xmalloc (sizeof (struct data
));
773 d
->code_number
= next_code_number
++;
774 d
->index_number
= next_index_number
;
775 if (XSTR (insn
, 0)[0])
776 d
->name
= XSTR (insn
, 0);
780 /* Build up the list in the same order as the insns are seen
781 in the machine description. */
783 if (end_of_insn_data
)
784 end_of_insn_data
->next
= d
;
788 end_of_insn_data
= d
;
793 /* Scan the operands to get the specified predicates and modes,
794 since expand_binop needs to know them. */
796 mybzero (constraints
, sizeof constraints
);
797 mybzero (op_n_alternatives
, sizeof op_n_alternatives
);
798 mybzero (predicates
, sizeof predicates
);
799 mybzero (address_p
, sizeof address_p
);
800 mybzero (modes
, sizeof modes
);
801 mybzero (strict_low
, sizeof strict_low
);
802 mybzero (seen
, sizeof seen
);
805 for (i
= 0; i
< XVECLEN (insn
, 1); i
++)
806 scan_operands (XVECEXP (insn
, 1, i
), 0, 0);
808 d
->n_operands
= max_opno
+ 1;
809 d
->n_dups
= num_dups
;
811 mybcopy (constraints
, d
->constraints
, sizeof constraints
);
812 mybcopy (op_n_alternatives
, d
->op_n_alternatives
, sizeof op_n_alternatives
);
813 mybcopy (predicates
, d
->predicates
, sizeof predicates
);
814 mybcopy (address_p
, d
->address_p
, sizeof address_p
);
815 mybcopy (modes
, d
->modes
, sizeof modes
);
816 mybcopy (strict_low
, d
->strict_low
, sizeof strict_low
);
820 validate_insn_alternatives (d
);
823 /* Process a define_split just read. Assign its code number,
824 only for reasons of consistency and to simplify genrecog. */
831 register struct data
*d
= (struct data
*) xmalloc (sizeof (struct data
));
834 d
->code_number
= next_code_number
++;
835 d
->index_number
= next_index_number
;
838 /* Build up the list in the same order as the insns are seen
839 in the machine description. */
841 if (end_of_insn_data
)
842 end_of_insn_data
->next
= d
;
846 end_of_insn_data
= d
;
851 mybzero (constraints
, sizeof constraints
);
852 mybzero (op_n_alternatives
, sizeof op_n_alternatives
);
853 mybzero (predicates
, sizeof predicates
);
854 mybzero (address_p
, sizeof address_p
);
855 mybzero (modes
, sizeof modes
);
856 mybzero (strict_low
, sizeof strict_low
);
857 mybzero (seen
, sizeof seen
);
859 /* Get the number of operands by scanning all the
860 patterns of the split patterns.
861 But ignore all the rest of the information thus obtained. */
862 for (i
= 0; i
< XVECLEN (split
, 0); i
++)
863 scan_operands (XVECEXP (split
, 0, i
), 0, 0);
865 d
->n_operands
= max_opno
+ 1;
867 mybzero (d
->constraints
, sizeof constraints
);
868 mybzero (d
->op_n_alternatives
, sizeof op_n_alternatives
);
869 mybzero (d
->predicates
, sizeof predicates
);
870 mybzero (d
->address_p
, sizeof address_p
);
871 mybzero (d
->modes
, sizeof modes
);
872 mybzero (d
->strict_low
, sizeof strict_low
);
875 d
->n_alternatives
= 0;
884 register char *val
= (char *) malloc (size
);
887 fatal ("virtual memory exhausted");
896 char *result
= (char *) realloc (ptr
, size
);
898 fatal ("virtual memory exhausted");
905 register unsigned length
;
912 mybcopy (b1
, b2
, length
)
915 register unsigned length
;
922 fatal (s
, a1
, a2
, a3
, a4
)
925 fprintf (stderr
, "genoutput: ");
926 fprintf (stderr
, s
, a1
, a2
, a3
, a4
);
927 fprintf (stderr
, "\n");
928 exit (FATAL_EXIT_CODE
);
931 /* More 'friendly' abort that prints the line and file.
932 config.h can #define abort fancy_abort if you like that sort of thing. */
937 fatal ("Internal gcc abort.");
944 fprintf (stderr
, "genoutput: ");
945 fprintf (stderr
, s
, a1
, a2
);
946 fprintf (stderr
, "\n");
960 obstack_init (rtl_obstack
);
963 fatal ("No input file name.");
965 infile
= fopen (argv
[1], "r");
969 exit (FATAL_EXIT_CODE
);
975 next_code_number
= 0;
976 next_index_number
= 0;
977 have_constraints
= 0;
979 /* Read the machine description. */
983 c
= read_skip_spaces (infile
);
988 desc
= read_rtx (infile
);
989 if (GET_CODE (desc
) == DEFINE_INSN
)
991 if (GET_CODE (desc
) == DEFINE_PEEPHOLE
)
993 if (GET_CODE (desc
) == DEFINE_EXPAND
)
995 if (GET_CODE (desc
) == DEFINE_SPLIT
)
1003 exit (ferror (stdout
) != 0 || have_error
1004 ? FATAL_EXIT_CODE
: SUCCESS_EXIT_CODE
);
1011 n_occurrences (c
, s
)