1 /* Support routines for the various generation passes.
2 Copyright (C) 2000, 2001, 2002, 2003, 2004
3 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GCC is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
14 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
15 License for more details.
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
24 #include "coretypes.h"
30 #include "gensupport.h"
33 /* In case some macros used by files we include need it, define this here. */
40 static struct obstack obstack
;
41 struct obstack
*rtl_obstack
= &obstack
;
43 static int sequence_num
;
46 static int predicable_default
;
47 static const char *predicable_true
;
48 static const char *predicable_false
;
50 static htab_t condition_table
;
52 static char *base_dir
= NULL
;
54 /* We initially queue all patterns, process the define_insn and
55 define_cond_exec patterns, then return them one at a time. */
62 struct queue_elem
*next
;
63 /* In a DEFINE_INSN that came from a DEFINE_INSN_AND_SPLIT, SPLIT
64 points to the generated DEFINE_SPLIT. */
65 struct queue_elem
*split
;
68 static struct queue_elem
*define_attr_queue
;
69 static struct queue_elem
**define_attr_tail
= &define_attr_queue
;
70 static struct queue_elem
*define_pred_queue
;
71 static struct queue_elem
**define_pred_tail
= &define_pred_queue
;
72 static struct queue_elem
*define_insn_queue
;
73 static struct queue_elem
**define_insn_tail
= &define_insn_queue
;
74 static struct queue_elem
*define_cond_exec_queue
;
75 static struct queue_elem
**define_cond_exec_tail
= &define_cond_exec_queue
;
76 static struct queue_elem
*other_queue
;
77 static struct queue_elem
**other_tail
= &other_queue
;
79 static struct queue_elem
*queue_pattern (rtx
, struct queue_elem
***,
82 /* Current maximum length of directory names in the search path
83 for include files. (Altered as we get more of them.) */
85 size_t max_include_len
;
89 struct file_name_list
*next
;
93 struct file_name_list
*first_dir_md_include
= 0; /* First dir to search */
94 /* First dir to search for <file> */
95 struct file_name_list
*first_bracket_include
= 0;
96 struct file_name_list
*last_dir_md_include
= 0; /* Last in chain */
98 static void remove_constraints (rtx
);
99 static void process_rtx (rtx
, int);
101 static int is_predicable (struct queue_elem
*);
102 static void identify_predicable_attribute (void);
103 static int n_alternatives (const char *);
104 static void collect_insn_data (rtx
, int *, int *);
105 static rtx
alter_predicate_for_insn (rtx
, int, int, int);
106 static const char *alter_test_for_insn (struct queue_elem
*,
107 struct queue_elem
*);
108 static char *shift_output_template (char *, const char *, int);
109 static const char *alter_output_for_insn (struct queue_elem
*,
112 static void process_one_cond_exec (struct queue_elem
*);
113 static void process_define_cond_exec (void);
114 static void process_include (rtx
, int);
115 static char *save_string (const char *, int);
116 static void init_predicate_table (void);
119 message_with_line (int lineno
, const char *msg
, ...)
125 fprintf (stderr
, "%s:%d: ", read_rtx_filename
, lineno
);
126 vfprintf (stderr
, msg
, ap
);
127 fputc ('\n', stderr
);
132 /* Make a version of gen_rtx_CONST_INT so that GEN_INT can be used in
133 the gensupport programs. */
136 gen_rtx_CONST_INT (enum machine_mode
ARG_UNUSED (mode
),
139 rtx rt
= rtx_alloc (CONST_INT
);
145 /* Queue PATTERN on LIST_TAIL. Return the address of the new queue
148 static struct queue_elem
*
149 queue_pattern (rtx pattern
, struct queue_elem
***list_tail
,
150 const char *filename
, int lineno
)
152 struct queue_elem
*e
= XNEW(struct queue_elem
);
154 e
->filename
= filename
;
159 *list_tail
= &e
->next
;
163 /* Recursively remove constraints from an rtx. */
166 remove_constraints (rtx part
)
169 const char *format_ptr
;
174 if (GET_CODE (part
) == MATCH_OPERAND
)
176 else if (GET_CODE (part
) == MATCH_SCRATCH
)
179 format_ptr
= GET_RTX_FORMAT (GET_CODE (part
));
181 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (part
)); i
++)
182 switch (*format_ptr
++)
186 remove_constraints (XEXP (part
, i
));
189 if (XVEC (part
, i
) != NULL
)
190 for (j
= 0; j
< XVECLEN (part
, i
); j
++)
191 remove_constraints (XVECEXP (part
, i
, j
));
196 /* Process an include file assuming that it lives in gcc/config/{target}/
197 if the include looks like (include "file"). */
200 process_include (rtx desc
, int lineno
)
202 const char *filename
= XSTR (desc
, 0);
203 const char *old_filename
;
208 /* If specified file name is absolute, skip the include stack. */
209 if (! IS_ABSOLUTE_PATH (filename
))
211 struct file_name_list
*stackp
;
213 /* Search directory path, trying to open the file. */
214 for (stackp
= first_dir_md_include
; stackp
; stackp
= stackp
->next
)
216 static const char sep
[2] = { DIR_SEPARATOR
, '\0' };
218 pathname
= concat (stackp
->fname
, sep
, filename
, NULL
);
219 input_file
= fopen (pathname
, "r");
220 if (input_file
!= NULL
)
227 pathname
= concat (base_dir
, filename
, NULL
);
229 pathname
= xstrdup (filename
);
230 input_file
= fopen (pathname
, "r");
231 if (input_file
== NULL
)
234 message_with_line (lineno
, "include file `%s' not found", filename
);
240 /* Save old cursor; setup new for the new file. Note that "lineno" the
241 argument to this function is the beginning of the include statement,
242 while read_rtx_lineno has already been advanced. */
243 old_filename
= read_rtx_filename
;
244 old_lineno
= read_rtx_lineno
;
245 read_rtx_filename
= pathname
;
248 /* Read the entire file. */
254 c
= read_skip_spaces (input_file
);
258 ungetc (c
, input_file
);
259 lineno
= read_rtx_lineno
;
260 desc
= read_rtx (input_file
);
261 process_rtx (desc
, lineno
);
264 /* Do not free pathname. It is attached to the various rtx queue
267 read_rtx_filename
= old_filename
;
268 read_rtx_lineno
= old_lineno
;
273 /* Process a top level rtx in some way, queuing as appropriate. */
276 process_rtx (rtx desc
, int lineno
)
278 switch (GET_CODE (desc
))
281 queue_pattern (desc
, &define_insn_tail
, read_rtx_filename
, lineno
);
284 case DEFINE_COND_EXEC
:
285 queue_pattern (desc
, &define_cond_exec_tail
, read_rtx_filename
, lineno
);
289 queue_pattern (desc
, &define_attr_tail
, read_rtx_filename
, lineno
);
292 case DEFINE_PREDICATE
:
293 case DEFINE_SPECIAL_PREDICATE
:
294 queue_pattern (desc
, &define_pred_tail
, read_rtx_filename
, lineno
);
298 process_include (desc
, lineno
);
301 case DEFINE_INSN_AND_SPLIT
:
303 const char *split_cond
;
307 struct queue_elem
*insn_elem
;
308 struct queue_elem
*split_elem
;
310 /* Create a split with values from the insn_and_split. */
311 split
= rtx_alloc (DEFINE_SPLIT
);
313 i
= XVECLEN (desc
, 1);
314 XVEC (split
, 0) = rtvec_alloc (i
);
317 XVECEXP (split
, 0, i
) = copy_rtx (XVECEXP (desc
, 1, i
));
318 remove_constraints (XVECEXP (split
, 0, i
));
321 /* If the split condition starts with "&&", append it to the
322 insn condition to create the new split condition. */
323 split_cond
= XSTR (desc
, 4);
324 if (split_cond
[0] == '&' && split_cond
[1] == '&')
325 split_cond
= concat (XSTR (desc
, 2), split_cond
, NULL
);
326 XSTR (split
, 1) = split_cond
;
327 XVEC (split
, 2) = XVEC (desc
, 5);
328 XSTR (split
, 3) = XSTR (desc
, 6);
330 /* Fix up the DEFINE_INSN. */
331 attr
= XVEC (desc
, 7);
332 PUT_CODE (desc
, DEFINE_INSN
);
333 XVEC (desc
, 4) = attr
;
337 = queue_pattern (desc
, &define_insn_tail
, read_rtx_filename
,
340 = queue_pattern (split
, &other_tail
, read_rtx_filename
, lineno
);
341 insn_elem
->split
= split_elem
;
346 queue_pattern (desc
, &other_tail
, read_rtx_filename
, lineno
);
351 /* Return true if attribute PREDICABLE is true for ELEM, which holds
355 is_predicable (struct queue_elem
*elem
)
357 rtvec vec
= XVEC (elem
->data
, 4);
362 return predicable_default
;
364 for (i
= GET_NUM_ELEM (vec
) - 1; i
>= 0; --i
)
366 rtx sub
= RTVEC_ELT (vec
, i
);
367 switch (GET_CODE (sub
))
370 if (strcmp (XSTR (sub
, 0), "predicable") == 0)
372 value
= XSTR (sub
, 1);
377 case SET_ATTR_ALTERNATIVE
:
378 if (strcmp (XSTR (sub
, 0), "predicable") == 0)
380 message_with_line (elem
->lineno
,
381 "multiple alternatives for `predicable'");
388 if (GET_CODE (SET_DEST (sub
)) != ATTR
389 || strcmp (XSTR (SET_DEST (sub
), 0), "predicable") != 0)
392 if (GET_CODE (sub
) == CONST_STRING
)
394 value
= XSTR (sub
, 0);
398 /* ??? It would be possible to handle this if we really tried.
399 It's not easy though, and I'm not going to bother until it
400 really proves necessary. */
401 message_with_line (elem
->lineno
,
402 "non-constant value for `predicable'");
411 return predicable_default
;
414 /* Verify that predicability does not vary on the alternative. */
415 /* ??? It should be possible to handle this by simply eliminating
416 the non-predicable alternatives from the insn. FRV would like
417 to do this. Delay this until we've got the basics solid. */
418 if (strchr (value
, ',') != NULL
)
420 message_with_line (elem
->lineno
,
421 "multiple alternatives for `predicable'");
426 /* Find out which value we're looking at. */
427 if (strcmp (value
, predicable_true
) == 0)
429 if (strcmp (value
, predicable_false
) == 0)
432 message_with_line (elem
->lineno
,
433 "unknown value `%s' for `predicable' attribute",
439 /* Examine the attribute "predicable"; discover its boolean values
443 identify_predicable_attribute (void)
445 struct queue_elem
*elem
;
446 char *p_true
, *p_false
;
449 /* Look for the DEFINE_ATTR for `predicable', which must exist. */
450 for (elem
= define_attr_queue
; elem
; elem
= elem
->next
)
451 if (strcmp (XSTR (elem
->data
, 0), "predicable") == 0)
454 message_with_line (define_cond_exec_queue
->lineno
,
455 "attribute `predicable' not defined");
460 value
= XSTR (elem
->data
, 1);
461 p_false
= xstrdup (value
);
462 p_true
= strchr (p_false
, ',');
463 if (p_true
== NULL
|| strchr (++p_true
, ',') != NULL
)
465 message_with_line (elem
->lineno
,
466 "attribute `predicable' is not a boolean");
472 predicable_true
= p_true
;
473 predicable_false
= p_false
;
475 switch (GET_CODE (XEXP (elem
->data
, 2)))
478 value
= XSTR (XEXP (elem
->data
, 2), 0);
482 message_with_line (elem
->lineno
,
483 "attribute `predicable' cannot be const");
488 message_with_line (elem
->lineno
,
489 "attribute `predicable' must have a constant default");
494 if (strcmp (value
, p_true
) == 0)
495 predicable_default
= 1;
496 else if (strcmp (value
, p_false
) == 0)
497 predicable_default
= 0;
500 message_with_line (elem
->lineno
,
501 "unknown value `%s' for `predicable' attribute",
507 /* Return the number of alternatives in constraint S. */
510 n_alternatives (const char *s
)
521 /* Determine how many alternatives there are in INSN, and how many
525 collect_insn_data (rtx pattern
, int *palt
, int *pmax
)
531 code
= GET_CODE (pattern
);
535 i
= n_alternatives (XSTR (pattern
, 2));
536 *palt
= (i
> *palt
? i
: *palt
);
542 i
= XINT (pattern
, 0);
551 fmt
= GET_RTX_FORMAT (code
);
552 len
= GET_RTX_LENGTH (code
);
553 for (i
= 0; i
< len
; i
++)
558 collect_insn_data (XEXP (pattern
, i
), palt
, pmax
);
562 if (XVEC (pattern
, i
) == NULL
)
566 for (j
= XVECLEN (pattern
, i
) - 1; j
>= 0; --j
)
567 collect_insn_data (XVECEXP (pattern
, i
, j
), palt
, pmax
);
570 case 'i': case 'w': case '0': case 's': case 'S': case 'T':
580 alter_predicate_for_insn (rtx pattern
, int alt
, int max_op
, int lineno
)
586 code
= GET_CODE (pattern
);
591 const char *c
= XSTR (pattern
, 2);
593 if (n_alternatives (c
) != 1)
595 message_with_line (lineno
,
596 "too many alternatives for operand %d",
602 /* Replicate C as needed to fill out ALT alternatives. */
603 if (c
&& *c
&& alt
> 1)
605 size_t c_len
= strlen (c
);
606 size_t len
= alt
* (c_len
+ 1);
607 char *new_c
= XNEWVEC(char, len
);
609 memcpy (new_c
, c
, c_len
);
610 for (i
= 1; i
< alt
; ++i
)
612 new_c
[i
* (c_len
+ 1) - 1] = ',';
613 memcpy (&new_c
[i
* (c_len
+ 1)], c
, c_len
);
615 new_c
[len
- 1] = '\0';
616 XSTR (pattern
, 2) = new_c
;
624 XINT (pattern
, 0) += max_op
;
631 fmt
= GET_RTX_FORMAT (code
);
632 len
= GET_RTX_LENGTH (code
);
633 for (i
= 0; i
< len
; i
++)
640 r
= alter_predicate_for_insn (XEXP (pattern
, i
), alt
,
647 for (j
= XVECLEN (pattern
, i
) - 1; j
>= 0; --j
)
649 r
= alter_predicate_for_insn (XVECEXP (pattern
, i
, j
),
650 alt
, max_op
, lineno
);
656 case 'i': case 'w': case '0': case 's':
668 alter_test_for_insn (struct queue_elem
*ce_elem
,
669 struct queue_elem
*insn_elem
)
671 const char *ce_test
, *insn_test
;
673 ce_test
= XSTR (ce_elem
->data
, 1);
674 insn_test
= XSTR (insn_elem
->data
, 2);
675 if (!ce_test
|| *ce_test
== '\0')
677 if (!insn_test
|| *insn_test
== '\0')
680 return concat ("(", ce_test
, ") && (", insn_test
, ")", NULL
);
683 /* Adjust all of the operand numbers in SRC to match the shift they'll
684 get from an operand displacement of DISP. Return a pointer after the
688 shift_output_template (char *dest
, const char *src
, int disp
)
697 if (ISDIGIT ((unsigned char) c
))
699 else if (ISALPHA (c
))
712 alter_output_for_insn (struct queue_elem
*ce_elem
,
713 struct queue_elem
*insn_elem
,
716 const char *ce_out
, *insn_out
;
718 size_t len
, ce_len
, insn_len
;
720 /* ??? Could coordinate with genoutput to not duplicate code here. */
722 ce_out
= XSTR (ce_elem
->data
, 2);
723 insn_out
= XTMPL (insn_elem
->data
, 3);
724 if (!ce_out
|| *ce_out
== '\0')
727 ce_len
= strlen (ce_out
);
728 insn_len
= strlen (insn_out
);
730 if (*insn_out
== '*')
731 /* You must take care of the predicate yourself. */
734 if (*insn_out
== '@')
736 len
= (ce_len
+ 1) * alt
+ insn_len
+ 1;
737 p
= result
= XNEWVEC(char, len
);
743 while (ISSPACE ((unsigned char) *insn_out
));
745 if (*insn_out
!= '#')
747 p
= shift_output_template (p
, ce_out
, max_op
);
753 while (*insn_out
&& *insn_out
!= '\n');
760 len
= ce_len
+ 1 + insn_len
+ 1;
761 result
= XNEWVEC (char, len
);
763 p
= shift_output_template (result
, ce_out
, max_op
);
765 memcpy (p
, insn_out
, insn_len
+ 1);
771 /* Replicate insns as appropriate for the given DEFINE_COND_EXEC. */
774 process_one_cond_exec (struct queue_elem
*ce_elem
)
776 struct queue_elem
*insn_elem
;
777 for (insn_elem
= define_insn_queue
; insn_elem
; insn_elem
= insn_elem
->next
)
779 int alternatives
, max_operand
;
780 rtx pred
, insn
, pattern
, split
;
783 if (! is_predicable (insn_elem
))
788 collect_insn_data (insn_elem
->data
, &alternatives
, &max_operand
);
791 if (XVECLEN (ce_elem
->data
, 0) != 1)
793 message_with_line (ce_elem
->lineno
,
794 "too many patterns in predicate");
799 pred
= copy_rtx (XVECEXP (ce_elem
->data
, 0, 0));
800 pred
= alter_predicate_for_insn (pred
, alternatives
, max_operand
,
805 /* Construct a new pattern for the new insn. */
806 insn
= copy_rtx (insn_elem
->data
);
808 pattern
= rtx_alloc (COND_EXEC
);
809 XEXP (pattern
, 0) = pred
;
810 if (XVECLEN (insn
, 1) == 1)
812 XEXP (pattern
, 1) = XVECEXP (insn
, 1, 0);
813 XVECEXP (insn
, 1, 0) = pattern
;
814 PUT_NUM_ELEM (XVEC (insn
, 1), 1);
818 XEXP (pattern
, 1) = rtx_alloc (PARALLEL
);
819 XVEC (XEXP (pattern
, 1), 0) = XVEC (insn
, 1);
820 XVEC (insn
, 1) = rtvec_alloc (1);
821 XVECEXP (insn
, 1, 0) = pattern
;
824 XSTR (insn
, 2) = alter_test_for_insn (ce_elem
, insn_elem
);
825 XTMPL (insn
, 3) = alter_output_for_insn (ce_elem
, insn_elem
,
826 alternatives
, max_operand
);
828 /* ??? Set `predicable' to false. Not crucial since it's really
829 only used here, and we won't reprocess this new pattern. */
831 /* Put the new pattern on the `other' list so that it
832 (a) is not reprocessed by other define_cond_exec patterns
833 (b) appears after all normal define_insn patterns.
835 ??? B is debatable. If one has normal insns that match
836 cond_exec patterns, they will be preferred over these
837 generated patterns. Whether this matters in practice, or if
838 it's a good thing, or whether we should thread these new
839 patterns into the define_insn chain just after their generator
840 is something we'll have to experiment with. */
842 queue_pattern (insn
, &other_tail
, insn_elem
->filename
,
845 if (!insn_elem
->split
)
848 /* If the original insn came from a define_insn_and_split,
849 generate a new split to handle the predicated insn. */
850 split
= copy_rtx (insn_elem
->split
->data
);
851 /* Predicate the pattern matched by the split. */
852 pattern
= rtx_alloc (COND_EXEC
);
853 XEXP (pattern
, 0) = pred
;
854 if (XVECLEN (split
, 0) == 1)
856 XEXP (pattern
, 1) = XVECEXP (split
, 0, 0);
857 XVECEXP (split
, 0, 0) = pattern
;
858 PUT_NUM_ELEM (XVEC (split
, 0), 1);
862 XEXP (pattern
, 1) = rtx_alloc (PARALLEL
);
863 XVEC (XEXP (pattern
, 1), 0) = XVEC (split
, 0);
864 XVEC (split
, 0) = rtvec_alloc (1);
865 XVECEXP (split
, 0, 0) = pattern
;
867 /* Predicate all of the insns generated by the split. */
868 for (i
= 0; i
< XVECLEN (split
, 2); i
++)
870 pattern
= rtx_alloc (COND_EXEC
);
871 XEXP (pattern
, 0) = pred
;
872 XEXP (pattern
, 1) = XVECEXP (split
, 2, i
);
873 XVECEXP (split
, 2, i
) = pattern
;
875 /* Add the new split to the queue. */
876 queue_pattern (split
, &other_tail
, read_rtx_filename
,
877 insn_elem
->split
->lineno
);
881 /* If we have any DEFINE_COND_EXEC patterns, expand the DEFINE_INSN
882 patterns appropriately. */
885 process_define_cond_exec (void)
887 struct queue_elem
*elem
;
889 identify_predicable_attribute ();
893 for (elem
= define_cond_exec_queue
; elem
; elem
= elem
->next
)
894 process_one_cond_exec (elem
);
898 save_string (const char *s
, int len
)
900 char *result
= XNEWVEC (char, len
+ 1);
902 memcpy (result
, s
, len
);
908 /* The entry point for initializing the reader. */
911 init_md_reader_args_cb (int argc
, char **argv
, bool (*parse_opt
)(const char *))
918 for (i
= 1; i
< argc
; i
++)
920 if (argv
[i
][0] != '-')
923 fatal ("too many input files");
932 case 'I': /* Add directory to path for includes. */
934 struct file_name_list
*dirtmp
;
936 dirtmp
= XNEW (struct file_name_list
);
937 dirtmp
->next
= 0; /* New one goes on the end */
938 if (first_dir_md_include
== 0)
939 first_dir_md_include
= dirtmp
;
941 last_dir_md_include
->next
= dirtmp
;
942 last_dir_md_include
= dirtmp
; /* Tail follows the last one */
943 if (argv
[i
][1] == 'I' && argv
[i
][2] != 0)
944 dirtmp
->fname
= argv
[i
] + 2;
945 else if (i
+ 1 == argc
)
946 fatal ("directory name missing after -I option");
948 dirtmp
->fname
= argv
[++i
];
949 if (strlen (dirtmp
->fname
) > max_include_len
)
950 max_include_len
= strlen (dirtmp
->fname
);
954 /* The program may have provided a callback so it can
955 accept its own options. */
956 if (parse_opt
&& parse_opt (argv
[i
]))
959 fatal ("invalid option `%s'", argv
[i
]);
965 fatal ("no input file name");
967 lastsl
= strrchr (in_fname
, '/');
969 base_dir
= save_string (in_fname
, lastsl
- in_fname
+ 1 );
971 read_rtx_filename
= in_fname
;
972 input_file
= fopen (in_fname
, "r");
976 return FATAL_EXIT_CODE
;
979 /* Initialize the table of insn conditions. */
980 condition_table
= htab_create (n_insn_conditions
,
981 hash_c_test
, cmp_c_test
, NULL
);
983 for (ix
= 0; ix
< n_insn_conditions
; ix
++)
984 *(htab_find_slot (condition_table
, &insn_conditions
[ix
], INSERT
))
985 = (void *) &insn_conditions
[ix
];
987 init_predicate_table ();
989 obstack_init (rtl_obstack
);
993 /* Read the entire file. */
998 int c
= read_skip_spaces (input_file
);
1002 ungetc (c
, input_file
);
1003 lineno
= read_rtx_lineno
;
1004 desc
= read_rtx (input_file
);
1005 process_rtx (desc
, lineno
);
1007 fclose (input_file
);
1009 /* Process define_cond_exec patterns. */
1010 if (define_cond_exec_queue
!= NULL
)
1011 process_define_cond_exec ();
1013 return errors
? FATAL_EXIT_CODE
: SUCCESS_EXIT_CODE
;
1016 /* Programs that don't have their own options can use this entry point
1019 init_md_reader_args (int argc
, char **argv
)
1021 return init_md_reader_args_cb (argc
, argv
, 0);
1024 /* The entry point for reading a single rtx from an md file. */
1027 read_md_rtx (int *lineno
, int *seqnr
)
1029 struct queue_elem
**queue
, *elem
;
1034 /* Read all patterns from a given queue before moving on to the next. */
1035 if (define_attr_queue
!= NULL
)
1036 queue
= &define_attr_queue
;
1037 else if (define_pred_queue
!= NULL
)
1038 queue
= &define_pred_queue
;
1039 else if (define_insn_queue
!= NULL
)
1040 queue
= &define_insn_queue
;
1041 else if (other_queue
!= NULL
)
1042 queue
= &other_queue
;
1047 *queue
= elem
->next
;
1049 read_rtx_filename
= elem
->filename
;
1050 *lineno
= elem
->lineno
;
1051 *seqnr
= sequence_num
;
1055 /* Discard insn patterns which we know can never match (because
1056 their C test is provably always false). If insn_elision is
1057 false, our caller needs to see all the patterns. Note that the
1058 elided patterns are never counted by the sequence numbering; it
1059 it is the caller's responsibility, when insn_elision is false, not
1060 to use elided pattern numbers for anything. */
1061 switch (GET_CODE (desc
))
1065 if (maybe_eval_c_test (XSTR (desc
, 2)) != 0)
1067 else if (insn_elision
)
1072 case DEFINE_PEEPHOLE
:
1073 case DEFINE_PEEPHOLE2
:
1074 if (maybe_eval_c_test (XSTR (desc
, 1)) != 0)
1076 else if (insn_elision
)
1087 /* Helper functions for insn elision. */
1089 /* Compute a hash function of a c_test structure, which is keyed
1090 by its ->expr field. */
1092 hash_c_test (const void *x
)
1094 const struct c_test
*a
= (const struct c_test
*) x
;
1095 const unsigned char *base
, *s
= (const unsigned char *) a
->expr
;
1103 while ((c
= *s
++) != '\0')
1105 hash
+= c
+ (c
<< 17);
1110 hash
+= len
+ (len
<< 17);
1116 /* Compare two c_test expression structures. */
1118 cmp_c_test (const void *x
, const void *y
)
1120 const struct c_test
*a
= (const struct c_test
*) x
;
1121 const struct c_test
*b
= (const struct c_test
*) y
;
1123 return !strcmp (a
->expr
, b
->expr
);
1126 /* Given a string representing a C test expression, look it up in the
1127 condition_table and report whether or not its value is known
1128 at compile time. Returns a tristate: 1 for known true, 0 for
1129 known false, -1 for unknown. */
1131 maybe_eval_c_test (const char *expr
)
1133 const struct c_test
*test
;
1134 struct c_test dummy
;
1139 if (insn_elision_unavailable
)
1143 test
= (const struct c_test
*)htab_find (condition_table
, &dummy
);
1150 /* Given a string, return the number of comma-separated elements in it.
1151 Return 0 for the null string. */
1153 n_comma_elts (const char *s
)
1160 for (n
= 1; *s
; s
++)
1167 /* Given a pointer to a (char *), return a pointer to the beginning of the
1168 next comma-separated element in the string. Advance the pointer given
1169 to the end of that element. Return NULL if at end of string. Caller
1170 is responsible for copying the string if necessary. White space between
1171 a comma and an element is ignored. */
1174 scan_comma_elt (const char **pstr
)
1177 const char *p
= *pstr
;
1189 while (*p
!= ',' && *p
!= '\0')
1196 /* Helper functions for define_predicate and define_special_predicate
1197 processing. Shared between genrecog.c and genpreds.c. */
1199 static htab_t predicate_table
;
1200 struct pred_data
*first_predicate
;
1201 static struct pred_data
**last_predicate
= &first_predicate
;
1204 hash_struct_pred_data (const void *ptr
)
1206 return htab_hash_string (((const struct pred_data
*)ptr
)->name
);
1210 eq_struct_pred_data (const void *a
, const void *b
)
1212 return !strcmp (((const struct pred_data
*)a
)->name
,
1213 ((const struct pred_data
*)b
)->name
);
1217 lookup_predicate (const char *name
)
1219 struct pred_data key
;
1221 return htab_find (predicate_table
, &key
);
1225 add_predicate (struct pred_data
*pred
)
1227 void **slot
= htab_find_slot (predicate_table
, pred
, INSERT
);
1230 error ("duplicate predicate definition for '%s'", pred
->name
);
1234 *last_predicate
= pred
;
1235 last_predicate
= &pred
->next
;
1238 /* This array gives the initial content of the predicate table. It
1239 has entries for all predicates defined in recog.c. The back end
1240 can define PREDICATE_CODES to give additional entries for the
1241 table; this is considered an obsolete mechanism (use
1242 define_predicate instead). */
1244 struct old_pred_table
1247 RTX_CODE codes
[NUM_RTX_CODE
];
1250 static const struct old_pred_table old_preds
[] = {
1251 {"general_operand", {CONST_INT
, CONST_DOUBLE
, CONST
, SYMBOL_REF
,
1252 LABEL_REF
, SUBREG
, REG
, MEM
}},
1253 {"address_operand", {CONST_INT
, CONST_DOUBLE
, CONST
, SYMBOL_REF
,
1254 LABEL_REF
, SUBREG
, REG
, MEM
,
1255 PLUS
, MINUS
, MULT
}},
1256 {"register_operand", {SUBREG
, REG
}},
1257 {"pmode_register_operand", {SUBREG
, REG
}},
1258 {"scratch_operand", {SCRATCH
, REG
}},
1259 {"immediate_operand", {CONST_INT
, CONST_DOUBLE
, CONST
, SYMBOL_REF
,
1261 {"const_int_operand", {CONST_INT
}},
1262 {"const_double_operand", {CONST_INT
, CONST_DOUBLE
}},
1263 {"nonimmediate_operand", {SUBREG
, REG
, MEM
}},
1264 {"nonmemory_operand", {CONST_INT
, CONST_DOUBLE
, CONST
, SYMBOL_REF
,
1265 LABEL_REF
, SUBREG
, REG
}},
1266 {"push_operand", {MEM
}},
1267 {"pop_operand", {MEM
}},
1268 {"memory_operand", {SUBREG
, MEM
}},
1269 {"indirect_operand", {SUBREG
, MEM
}},
1270 {"comparison_operator", {EQ
, NE
, LE
, LT
, GE
, GT
, LEU
, LTU
, GEU
, GTU
,
1271 UNORDERED
, ORDERED
, UNEQ
, UNGE
, UNGT
, UNLE
,
1273 #ifdef PREDICATE_CODES
1277 #define NUM_KNOWN_OLD_PREDS ARRAY_SIZE (old_preds)
1279 /* This table gives the initial set of special predicates. It has
1280 entries for all special predicates defined in recog.c. The back
1281 end can define SPECIAL_MODE_PREDICATES to give additional entries
1282 for the table; this is considered an obsolete mechanism (use
1283 define_special_predicate instead). */
1284 static const char *const old_special_pred_table
[] = {
1286 "pmode_register_operand",
1287 #ifdef SPECIAL_MODE_PREDICATES
1288 SPECIAL_MODE_PREDICATES
1292 #define NUM_OLD_SPECIAL_MODE_PREDS ARRAY_SIZE (old_special_pred_table)
1294 /* Initialize the table of predicate definitions, starting with
1295 the information we have on generic predicates, and the old-style
1296 PREDICATE_CODES definitions. */
1299 init_predicate_table (void)
1302 struct pred_data
*pred
;
1304 predicate_table
= htab_create_alloc (37, hash_struct_pred_data
,
1305 eq_struct_pred_data
, 0,
1308 for (i
= 0; i
< NUM_KNOWN_OLD_PREDS
; i
++)
1310 pred
= xcalloc (sizeof (struct pred_data
), 1);
1311 pred
->name
= old_preds
[i
].name
;
1313 for (j
= 0; old_preds
[i
].codes
[j
] != 0; j
++)
1315 enum rtx_code code
= old_preds
[i
].codes
[j
];
1317 pred
->codes
[code
] = true;
1318 if (GET_RTX_CLASS (code
) != RTX_CONST_OBJ
)
1319 pred
->allows_non_const
= true;
1325 && code
!= STRICT_LOW_PART
)
1326 pred
->allows_non_lvalue
= true;
1329 pred
->singleton
= old_preds
[i
].codes
[0];
1331 add_predicate (pred
);
1334 for (i
= 0; i
< NUM_OLD_SPECIAL_MODE_PREDS
; i
++)
1336 pred
= lookup_predicate (old_special_pred_table
[i
]);
1339 error ("old-style special predicate list refers "
1340 "to unknown predicate '%s'", old_special_pred_table
[i
]);
1343 pred
->special
= true;