1 /* Generate code from to output assembler insns as recognized from rtl.
2 Copyright (C) 1987, 1988, 1992, 1994, 1995, 1997, 1998, 1999, 2000, 2002,
3 2003 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
23 /* This program reads the machine description for the compiler target machine
24 and produces a file containing these things:
26 1. An array of `struct insn_data', which is indexed by insn code number,
29 a. `name' is the name for that pattern. Nameless patterns are
32 b. `output' hold either the output template, an array of output
33 templates, or an output function.
35 c. `genfun' is the function to generate a body for that pattern,
36 given operands as arguments.
38 d. `n_operands' is the number of distinct operands in the pattern
41 e. `n_dups' is the number of match_dup's that appear in the insn's
42 pattern. This says how many elements of `recog_data.dup_loc' are
43 significant after an insn has been recognized.
45 f. `n_alternatives' is the number of alternatives in the constraints
48 g. `output_format' tells what type of thing `output' is.
50 h. `operand' is the base of an array of operand data for the insn.
52 2. An array of `struct insn_operand data', used by `operand' above.
54 a. `predicate', an int-valued function, is the match_operand predicate
57 b. `constraint' is the constraint for this operand. This exists
58 only if register constraints appear in match_operand rtx's.
60 c. `address_p' indicates that the operand appears within ADDRESS
61 rtx's. This exists only if there are *no* register constraints
62 in the match_operand rtx's.
64 d. `mode' is the machine mode that that operand is supposed to have.
66 e. `strict_low', is nonzero for operands contained in a STRICT_LOW_PART.
68 f. `eliminable', is nonzero for operands that are matched normally by
69 MATCH_OPERAND; it is zero for operands that should not be changed during
70 register elimination such as MATCH_OPERATORs.
72 The code number of an insn is simply its position in the machine
73 description; code numbers are assigned sequentially to entries in
74 the description, starting with code number 0.
76 Thus, the following entry in the machine description
79 [(set (match_operand:DF 0 "general_operand" "")
84 assuming it is the 25th entry present, would cause
85 insn_data[24].template to be "clrd %0", and
86 insn_data[24].n_operands to be 1. */
90 #include "coretypes.h"
94 #include "gensupport.h"
96 /* No instruction can have more operands than this. Sorry for this
97 arbitrary limit, but what machine will have an instruction with
98 this many operands? */
100 #define MAX_MAX_OPERANDS 40
102 static int n_occurrences (int, const char *);
103 static const char *strip_whitespace (const char *);
105 /* insns in the machine description are assigned sequential code numbers
106 that are used by insn-recog.c (produced by genrecog) to communicate
107 to insn-output.c (produced by this program). */
109 static int next_code_number
;
111 /* This counts all definitions in the md file,
112 for the sake of error messages. */
114 static int next_index_number
;
116 /* This counts all operands used in the md file. The first is null. */
118 static int next_operand_number
= 1;
120 /* Record in this chain all information about the operands we will output. */
124 struct operand_data
*next
;
126 const char *predicate
;
127 const char *constraint
;
128 enum machine_mode mode
;
129 unsigned char n_alternatives
;
136 /* Begin with a null operand at index 0. */
138 static struct operand_data null_operand
=
140 0, 0, "", "", VOIDmode
, 0, 0, 0, 0, 0
143 static struct operand_data
*odata
= &null_operand
;
144 static struct operand_data
**odata_end
= &null_operand
.next
;
146 /* Must match the constants in recog.h. */
148 #define INSN_OUTPUT_FORMAT_NONE 0 /* abort */
149 #define INSN_OUTPUT_FORMAT_SINGLE 1 /* const char * */
150 #define INSN_OUTPUT_FORMAT_MULTI 2 /* const char * const * */
151 #define INSN_OUTPUT_FORMAT_FUNCTION 3 /* const char * (*)(...) */
153 /* Record in this chain all information that we will output,
154 associated with the code number of the insn. */
160 const char *template;
164 int n_operands
; /* Number of operands this insn recognizes */
165 int n_dups
; /* Number times match_dup appears in pattern */
166 int n_alternatives
; /* Number of alternatives in each constraint */
167 int operand_number
; /* Operand index in the big array. */
168 int output_format
; /* INSN_OUTPUT_FORMAT_*. */
169 struct operand_data operand
[MAX_MAX_OPERANDS
];
172 /* This variable points to the first link in the insn chain. */
174 static struct data
*idata
, **idata_end
= &idata
;
176 static void output_prologue (void);
177 static void output_predicate_decls (void);
178 static void output_operand_data (void);
179 static void output_insn_data (void);
180 static void output_get_insn_name (void);
181 static void scan_operands (struct data
*, rtx
, int, int);
182 static int compare_operands (struct operand_data
*,
183 struct operand_data
*);
184 static void place_operands (struct data
*);
185 static void process_template (struct data
*, const char *);
186 static void validate_insn_alternatives (struct data
*);
187 static void validate_insn_operands (struct data
*);
188 static void gen_insn (rtx
, int);
189 static void gen_peephole (rtx
, int);
190 static void gen_expand (rtx
, int);
191 static void gen_split (rtx
, int);
192 static void check_constraint_len (void);
193 static int constraint_len (const char *, int);
196 get_insn_name (int index
)
198 static char buf
[100];
200 struct data
*i
, *last_named
= NULL
;
201 for (i
= idata
; i
; i
= i
->next
)
203 if (i
->index_number
== index
)
210 sprintf(buf
, "%s+%d", last_named
->name
, index
- last_named
->index_number
);
212 sprintf(buf
, "insn %d", index
);
218 output_prologue (void)
220 printf ("/* Generated automatically by the program `genoutput'\n\
221 from the machine description file `md'. */\n\n");
223 printf ("#include \"config.h\"\n");
224 printf ("#include \"system.h\"\n");
225 printf ("#include \"coretypes.h\"\n");
226 printf ("#include \"tm.h\"\n");
227 printf ("#include \"flags.h\"\n");
228 printf ("#include \"ggc.h\"\n");
229 printf ("#include \"rtl.h\"\n");
230 printf ("#include \"expr.h\"\n");
231 printf ("#include \"insn-codes.h\"\n");
232 printf ("#include \"tm_p.h\"\n");
233 printf ("#include \"function.h\"\n");
234 printf ("#include \"regs.h\"\n");
235 printf ("#include \"hard-reg-set.h\"\n");
236 printf ("#include \"real.h\"\n");
237 printf ("#include \"insn-config.h\"\n\n");
238 printf ("#include \"conditions.h\"\n");
239 printf ("#include \"insn-attr.h\"\n\n");
240 printf ("#include \"recog.h\"\n\n");
241 printf ("#include \"toplev.h\"\n");
242 printf ("#include \"output.h\"\n");
243 printf ("#include \"target.h\"\n");
247 /* We need to define all predicates used. Keep a list of those we
248 have defined so far. There normally aren't very many predicates
249 used, so a linked list should be fast enough. */
250 struct predicate
{ const char *name
; struct predicate
*next
; };
253 output_predicate_decls (void)
255 struct predicate
*predicates
= 0;
256 struct operand_data
*d
;
257 struct predicate
*p
, *next
;
259 for (d
= odata
; d
; d
= d
->next
)
260 if (d
->predicate
&& d
->predicate
[0])
262 for (p
= predicates
; p
; p
= p
->next
)
263 if (strcmp (p
->name
, d
->predicate
) == 0)
268 printf ("extern int %s (rtx, enum machine_mode);\n",
270 p
= (struct predicate
*) xmalloc (sizeof (struct predicate
));
271 p
->name
= d
->predicate
;
272 p
->next
= predicates
;
278 for (p
= predicates
; p
; p
= next
)
286 output_operand_data (void)
288 struct operand_data
*d
;
290 printf ("\nstatic const struct insn_operand_data operand_data[] = \n{\n");
292 for (d
= odata
; d
; d
= d
->next
)
297 d
->predicate
&& d
->predicate
[0] ? d
->predicate
: "0");
299 printf (" \"%s\",\n", d
->constraint
? d
->constraint
: "");
301 printf (" %smode,\n", GET_MODE_NAME (d
->mode
));
303 printf (" %d,\n", d
->strict_low
);
305 printf (" %d\n", d
->eliminable
);
313 output_insn_data (void)
317 int next_name_offset
;
318 const char * last_name
= 0;
319 const char * next_name
= 0;
322 for (n
= idata
, next_name_offset
= 1; n
; n
= n
->next
, next_name_offset
++)
329 printf ("\nconst struct insn_data insn_data[] = \n{\n");
331 for (d
= idata
; d
; d
= d
->next
)
337 printf (" \"%s\",\n", d
->name
);
341 for (n
= d
->next
, next_name_offset
= 1; n
;
342 n
= n
->next
, next_name_offset
++)
354 if (next_name
&& (last_name
== 0
355 || name_offset
> next_name_offset
/ 2))
356 printf (" \"%s-%d\",\n", next_name
,
357 next_name_offset
- name_offset
);
359 printf (" \"%s+%d\",\n", last_name
, name_offset
);
362 switch (d
->output_format
)
364 case INSN_OUTPUT_FORMAT_NONE
:
367 case INSN_OUTPUT_FORMAT_SINGLE
:
369 const char *p
= d
->template;
375 if (IS_VSPACE (*p
) && prev
!= '\\')
377 /* Preserve two consecutive \n's or \r's, but treat \r\n
378 as a single newline. */
379 if (*p
== '\n' && prev
!= '\r')
390 case INSN_OUTPUT_FORMAT_MULTI
:
391 case INSN_OUTPUT_FORMAT_FUNCTION
:
392 printf (" (const PTR) output_%d,\n", d
->code_number
);
398 if (d
->name
&& d
->name
[0] != '*')
399 printf (" (insn_gen_fn) gen_%s,\n", d
->name
);
403 printf (" &operand_data[%d],\n", d
->operand_number
);
404 printf (" %d,\n", d
->n_operands
);
405 printf (" %d,\n", d
->n_dups
);
406 printf (" %d,\n", d
->n_alternatives
);
407 printf (" %d\n", d
->output_format
);
415 output_get_insn_name (void)
417 printf ("const char *\n");
418 printf ("get_insn_name (code)\n");
419 printf (" int code;\n");
421 printf (" if (code == NOOP_MOVE_INSN_CODE)\n");
422 printf (" return \"NOOP_MOVE\";\n");
424 printf (" return insn_data[code].name;\n");
429 /* Stores in max_opno the largest operand number present in `part', if
430 that is larger than the previous value of max_opno, and the rest of
431 the operand data into `d->operand[i]'.
433 THIS_ADDRESS_P is nonzero if the containing rtx was an ADDRESS.
434 THIS_STRICT_LOW is nonzero if the containing rtx was a STRICT_LOW_PART. */
440 scan_operands (struct data
*d
, rtx part
, int this_address_p
,
444 const char *format_ptr
;
450 switch (GET_CODE (part
))
453 opno
= XINT (part
, 0);
456 if (max_opno
>= MAX_MAX_OPERANDS
)
458 message_with_line (d
->lineno
,
459 "maximum number of operands exceeded");
463 if (d
->operand
[opno
].seen
)
465 message_with_line (d
->lineno
,
466 "repeated operand number %d\n", opno
);
470 d
->operand
[opno
].seen
= 1;
471 d
->operand
[opno
].mode
= GET_MODE (part
);
472 d
->operand
[opno
].strict_low
= this_strict_low
;
473 d
->operand
[opno
].predicate
= XSTR (part
, 1);
474 d
->operand
[opno
].constraint
= strip_whitespace (XSTR (part
, 2));
475 d
->operand
[opno
].n_alternatives
476 = n_occurrences (',', d
->operand
[opno
].constraint
) + 1;
477 d
->operand
[opno
].address_p
= this_address_p
;
478 d
->operand
[opno
].eliminable
= 1;
482 opno
= XINT (part
, 0);
485 if (max_opno
>= MAX_MAX_OPERANDS
)
487 message_with_line (d
->lineno
,
488 "maximum number of operands exceeded");
492 if (d
->operand
[opno
].seen
)
494 message_with_line (d
->lineno
,
495 "repeated operand number %d\n", opno
);
499 d
->operand
[opno
].seen
= 1;
500 d
->operand
[opno
].mode
= GET_MODE (part
);
501 d
->operand
[opno
].strict_low
= 0;
502 d
->operand
[opno
].predicate
= "scratch_operand";
503 d
->operand
[opno
].constraint
= strip_whitespace (XSTR (part
, 1));
504 d
->operand
[opno
].n_alternatives
505 = n_occurrences (',', d
->operand
[opno
].constraint
) + 1;
506 d
->operand
[opno
].address_p
= 0;
507 d
->operand
[opno
].eliminable
= 0;
512 opno
= XINT (part
, 0);
515 if (max_opno
>= MAX_MAX_OPERANDS
)
517 message_with_line (d
->lineno
,
518 "maximum number of operands exceeded");
522 if (d
->operand
[opno
].seen
)
524 message_with_line (d
->lineno
,
525 "repeated operand number %d\n", opno
);
529 d
->operand
[opno
].seen
= 1;
530 d
->operand
[opno
].mode
= GET_MODE (part
);
531 d
->operand
[opno
].strict_low
= 0;
532 d
->operand
[opno
].predicate
= XSTR (part
, 1);
533 d
->operand
[opno
].constraint
= 0;
534 d
->operand
[opno
].address_p
= 0;
535 d
->operand
[opno
].eliminable
= 0;
536 for (i
= 0; i
< XVECLEN (part
, 2); i
++)
537 scan_operands (d
, XVECEXP (part
, 2, i
), 0, 0);
547 scan_operands (d
, XEXP (part
, 0), 1, 0);
550 case STRICT_LOW_PART
:
551 scan_operands (d
, XEXP (part
, 0), 0, 1);
558 format_ptr
= GET_RTX_FORMAT (GET_CODE (part
));
560 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (part
)); i
++)
561 switch (*format_ptr
++)
565 scan_operands (d
, XEXP (part
, i
), 0, 0);
568 if (XVEC (part
, i
) != NULL
)
569 for (j
= 0; j
< XVECLEN (part
, i
); j
++)
570 scan_operands (d
, XVECEXP (part
, i
, j
), 0, 0);
575 /* Compare two operands for content equality. */
578 compare_operands (struct operand_data
*d0
, struct operand_data
*d1
)
588 if (strcmp (p0
, p1
) != 0)
597 if (strcmp (p0
, p1
) != 0)
600 if (d0
->mode
!= d1
->mode
)
603 if (d0
->strict_low
!= d1
->strict_low
)
606 if (d0
->eliminable
!= d1
->eliminable
)
612 /* Scan the list of operands we've already committed to output and either
613 find a subsequence that is the same, or allocate a new one at the end. */
616 place_operands (struct data
*d
)
618 struct operand_data
*od
, *od2
;
621 if (d
->n_operands
== 0)
623 d
->operand_number
= 0;
627 /* Brute force substring search. */
628 for (od
= odata
, i
= 0; od
; od
= od
->next
, i
= 0)
629 if (compare_operands (od
, &d
->operand
[0]))
635 if (i
== d
->n_operands
)
639 if (! compare_operands (od2
, &d
->operand
[i
]))
641 ++i
, od2
= od2
->next
;
645 /* Either partial match at the end of the list, or no match. In either
646 case, we tack on what operands are remaining to the end of the list. */
648 d
->operand_number
= next_operand_number
- i
;
649 for (; i
< d
->n_operands
; ++i
)
651 od2
= &d
->operand
[i
];
653 odata_end
= &od2
->next
;
654 od2
->index
= next_operand_number
++;
660 d
->operand_number
= od
->index
;
665 /* Process an assembler template from a define_insn or a define_peephole.
666 It is either the assembler code template, a list of assembler code
667 templates, or C code to generate the assembler code template. */
670 process_template (struct data
*d
, const char *template)
675 /* Templates starting with * contain straight code to be run. */
676 if (template[0] == '*')
679 d
->output_format
= INSN_OUTPUT_FORMAT_FUNCTION
;
681 printf ("\nstatic const char *output_%d (rtx *, rtx);\n",
683 puts ("\nstatic const char *");
684 printf ("output_%d (operands, insn)\n", d
->code_number
);
685 puts (" rtx *operands ATTRIBUTE_UNUSED;");
686 puts (" rtx insn ATTRIBUTE_UNUSED;");
693 /* If the assembler code template starts with a @ it is a newline-separated
694 list of assembler code templates, one for each alternative. */
695 else if (template[0] == '@')
698 d
->output_format
= INSN_OUTPUT_FORMAT_MULTI
;
700 printf ("\nstatic const char * const output_%d[] = {\n", d
->code_number
);
702 for (i
= 0, cp
= &template[1]; *cp
; )
704 while (ISSPACE (*cp
))
708 while (!IS_VSPACE (*cp
) && *cp
!= '\0')
718 message_with_line (d
->lineno
,
719 "'@' is redundant for output template with single alternative");
720 if (i
!= d
->n_alternatives
)
722 message_with_line (d
->lineno
,
723 "wrong number of alternatives in the output template");
731 d
->template = template;
732 d
->output_format
= INSN_OUTPUT_FORMAT_SINGLE
;
736 /* Check insn D for consistency in number of constraint alternatives. */
739 validate_insn_alternatives (struct data
*d
)
743 /* Make sure all the operands have the same number of alternatives
744 in their constraints. Let N be that number. */
745 for (start
= 0; start
< d
->n_operands
; start
++)
746 if (d
->operand
[start
].n_alternatives
> 0)
751 int which_alternative
= 0;
752 int alternative_count_unsure
= 0;
754 for (p
= d
->operand
[start
].constraint
; (c
= *p
); p
+= len
)
756 len
= CONSTRAINT_LEN (c
, p
);
758 if (len
< 1 || (len
> 1 && strchr (",#*+=&%!0123456789", c
)))
760 message_with_line (d
->lineno
,
761 "invalid length %d for char '%c' in alternative %d of operand %d",
762 len
, c
, which_alternative
, start
);
773 for (i
= 1; i
< len
; i
++)
776 message_with_line (d
->lineno
,
777 "NUL in alternative %d of operand %d",
778 which_alternative
, start
);
779 alternative_count_unsure
= 1;
782 else if (strchr (",#*", p
[i
]))
784 message_with_line (d
->lineno
,
785 "'%c' in alternative %d of operand %d",
786 p
[i
], which_alternative
, start
);
787 alternative_count_unsure
= 1;
790 if (alternative_count_unsure
)
793 n
= d
->operand
[start
].n_alternatives
;
794 else if (n
!= d
->operand
[start
].n_alternatives
)
796 message_with_line (d
->lineno
,
797 "wrong number of alternatives in operand %d",
803 /* Record the insn's overall number of alternatives. */
804 d
->n_alternatives
= n
;
807 /* Verify that there are no gaps in operand numbers for INSNs. */
810 validate_insn_operands (struct data
*d
)
814 for (i
= 0; i
< d
->n_operands
; ++i
)
815 if (d
->operand
[i
].seen
== 0)
817 message_with_line (d
->lineno
, "missing operand %d", i
);
822 /* Look at a define_insn just read. Assign its code number. Record
823 on idata the template and the number of arguments. If the insn has
824 a hairy output action, output a function for now. */
827 gen_insn (rtx insn
, int lineno
)
829 struct data
*d
= (struct data
*) xmalloc (sizeof (struct data
));
832 d
->code_number
= next_code_number
;
833 d
->index_number
= next_index_number
;
835 if (XSTR (insn
, 0)[0])
836 d
->name
= XSTR (insn
, 0);
840 /* Build up the list in the same order as the insns are seen
841 in the machine description. */
844 idata_end
= &d
->next
;
848 memset (d
->operand
, 0, sizeof (d
->operand
));
850 for (i
= 0; i
< XVECLEN (insn
, 1); i
++)
851 scan_operands (d
, XVECEXP (insn
, 1, i
), 0, 0);
853 d
->n_operands
= max_opno
+ 1;
854 d
->n_dups
= num_dups
;
856 check_constraint_len ();
857 validate_insn_operands (d
);
858 validate_insn_alternatives (d
);
860 process_template (d
, XTMPL (insn
, 3));
863 /* Look at a define_peephole just read. Assign its code number.
864 Record on idata the template and the number of arguments.
865 If the insn has a hairy output action, output it now. */
868 gen_peephole (rtx peep
, int lineno
)
870 struct data
*d
= (struct data
*) xmalloc (sizeof (struct data
));
873 d
->code_number
= next_code_number
;
874 d
->index_number
= next_index_number
;
878 /* Build up the list in the same order as the insns are seen
879 in the machine description. */
882 idata_end
= &d
->next
;
886 memset (d
->operand
, 0, sizeof (d
->operand
));
888 /* Get the number of operands by scanning all the patterns of the
889 peephole optimizer. But ignore all the rest of the information
891 for (i
= 0; i
< XVECLEN (peep
, 0); i
++)
892 scan_operands (d
, XVECEXP (peep
, 0, i
), 0, 0);
894 d
->n_operands
= max_opno
+ 1;
897 validate_insn_alternatives (d
);
899 process_template (d
, XTMPL (peep
, 2));
902 /* Process a define_expand just read. Assign its code number,
903 only for the purposes of `insn_gen_function'. */
906 gen_expand (rtx insn
, int lineno
)
908 struct data
*d
= (struct data
*) xmalloc (sizeof (struct data
));
911 d
->code_number
= next_code_number
;
912 d
->index_number
= next_index_number
;
914 if (XSTR (insn
, 0)[0])
915 d
->name
= XSTR (insn
, 0);
919 /* Build up the list in the same order as the insns are seen
920 in the machine description. */
923 idata_end
= &d
->next
;
927 memset (d
->operand
, 0, sizeof (d
->operand
));
929 /* Scan the operands to get the specified predicates and modes,
930 since expand_binop needs to know them. */
933 for (i
= 0; i
< XVECLEN (insn
, 1); i
++)
934 scan_operands (d
, XVECEXP (insn
, 1, i
), 0, 0);
936 d
->n_operands
= max_opno
+ 1;
937 d
->n_dups
= num_dups
;
939 d
->output_format
= INSN_OUTPUT_FORMAT_NONE
;
941 validate_insn_alternatives (d
);
945 /* Process a define_split just read. Assign its code number,
946 only for reasons of consistency and to simplify genrecog. */
949 gen_split (rtx split
, int lineno
)
951 struct data
*d
= (struct data
*) xmalloc (sizeof (struct data
));
954 d
->code_number
= next_code_number
;
955 d
->index_number
= next_index_number
;
959 /* Build up the list in the same order as the insns are seen
960 in the machine description. */
963 idata_end
= &d
->next
;
967 memset (d
->operand
, 0, sizeof (d
->operand
));
969 /* Get the number of operands by scanning all the patterns of the
970 split patterns. But ignore all the rest of the information thus
972 for (i
= 0; i
< XVECLEN (split
, 0); i
++)
973 scan_operands (d
, XVECEXP (split
, 0, i
), 0, 0);
975 d
->n_operands
= max_opno
+ 1;
977 d
->n_alternatives
= 0;
979 d
->output_format
= INSN_OUTPUT_FORMAT_NONE
;
984 extern int main (int, char **);
987 main (int argc
, char **argv
)
991 progname
= "genoutput";
994 fatal ("no input file name");
996 if (init_md_reader_args (argc
, argv
) != SUCCESS_EXIT_CODE
)
997 return (FATAL_EXIT_CODE
);
1000 next_code_number
= 0;
1001 next_index_number
= 0;
1003 /* Read the machine description. */
1009 desc
= read_md_rtx (&line_no
, &next_code_number
);
1013 if (GET_CODE (desc
) == DEFINE_INSN
)
1014 gen_insn (desc
, line_no
);
1015 if (GET_CODE (desc
) == DEFINE_PEEPHOLE
)
1016 gen_peephole (desc
, line_no
);
1017 if (GET_CODE (desc
) == DEFINE_EXPAND
)
1018 gen_expand (desc
, line_no
);
1019 if (GET_CODE (desc
) == DEFINE_SPLIT
1020 || GET_CODE (desc
) == DEFINE_PEEPHOLE2
)
1021 gen_split (desc
, line_no
);
1022 next_index_number
++;
1026 output_predicate_decls ();
1027 output_operand_data ();
1028 output_insn_data ();
1029 output_get_insn_name ();
1032 return (ferror (stdout
) != 0 || have_error
1033 ? FATAL_EXIT_CODE
: SUCCESS_EXIT_CODE
);
1036 /* Return the number of occurrences of character C in string S or
1037 -1 if S is the null string. */
1040 n_occurrences (int c
, const char *s
)
1044 if (s
== 0 || *s
== '\0')
1053 /* Remove whitespace in `s' by moving up characters until the end.
1054 Return a new string. */
1057 strip_whitespace (const char *s
)
1065 p
= q
= xmalloc (strlen (s
) + 1);
1066 while ((ch
= *s
++) != '\0')
1074 /* Verify that DEFAULT_CONSTRAINT_LEN is used properly and not
1075 tampered with. This isn't bullet-proof, but it should catch
1076 most genuine mistakes. */
1078 check_constraint_len (void)
1083 for (p
= ",#*+=&%!1234567890"; *p
; p
++)
1084 for (d
= -9; d
< 9; d
++)
1085 if (constraint_len (p
, d
) != d
)
1090 constraint_len (const char *p
, int genoutput_default_constraint_len
)
1092 /* Check that we still match defaults.h . First we do a generation-time
1093 check that fails if the value is not the expected one... */
1094 if (DEFAULT_CONSTRAINT_LEN (*p
, p
) != 1)
1096 /* And now a comile-time check that should give a diagnostic if the
1097 definition doesn't exactly match. */
1098 #define DEFAULT_CONSTRAINT_LEN(C,STR) 1
1099 /* Now re-define DEFAULT_CONSTRAINT_LEN so that we can verify it is
1101 #undef DEFAULT_CONSTRAINT_LEN
1102 #define DEFAULT_CONSTRAINT_LEN(C,STR) \
1103 ((C) != *p || STR != p ? -1 : genoutput_default_constraint_len)
1104 return CONSTRAINT_LEN (*p
, p
);
1105 /* And set it back. */
1106 #undef DEFAULT_CONSTRAINT_LEN
1107 #define DEFAULT_CONSTRAINT_LEN(C,STR) 1