1 /* Support routines for the various generation passes.
2 Copyright (C) 2000 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. */
26 #include "gensupport.h"
29 static struct obstack obstack
;
30 struct obstack
*rtl_obstack
= &obstack
;
32 #define obstack_chunk_alloc xmalloc
33 #define obstack_chunk_free free
35 static int sequence_num
;
38 static int predicable_default
;
39 static const char *predicable_true
;
40 static const char *predicable_false
;
42 /* We initially queue all patterns, process the define_insn and
43 define_cond_exec patterns, then return them one at a time. */
49 struct queue_elem
*next
;
52 static struct queue_elem
*define_attr_queue
;
53 static struct queue_elem
**define_attr_tail
= &define_attr_queue
;
54 static struct queue_elem
*define_insn_queue
;
55 static struct queue_elem
**define_insn_tail
= &define_insn_queue
;
56 static struct queue_elem
*define_cond_exec_queue
;
57 static struct queue_elem
**define_cond_exec_tail
= &define_cond_exec_queue
;
58 static struct queue_elem
*other_queue
;
59 static struct queue_elem
**other_tail
= &other_queue
;
61 static void queue_pattern
PARAMS ((rtx
, struct queue_elem
***, int));
62 static void remove_constraints
PARAMS ((rtx
));
63 static void process_rtx
PARAMS ((rtx
, int));
65 static int is_predicable
PARAMS ((struct queue_elem
*));
66 static void identify_predicable_attribute
PARAMS ((void));
67 static int n_alternatives
PARAMS ((const char *));
68 static void collect_insn_data
PARAMS ((rtx
, int *, int *));
69 static rtx alter_predicate_for_insn
PARAMS ((rtx
, int, int, int));
70 static const char *alter_test_for_insn
PARAMS ((struct queue_elem
*,
71 struct queue_elem
*));
72 static char *shift_output_template
PARAMS ((char *, const char *, int));
73 static const char *alter_output_for_insn
PARAMS ((struct queue_elem
*,
76 static void process_one_cond_exec
PARAMS ((struct queue_elem
*));
77 static void process_define_cond_exec
PARAMS ((void));
80 message_with_line
VPARAMS ((int lineno
, const char *msg
, ...))
82 #ifndef ANSI_PROTOTYPES
90 #ifndef ANSI_PROTOTYPES
91 lineno
= va_arg (ap
, int);
92 msg
= va_arg (ap
, const char *);
95 fprintf (stderr
, "%s:%d: ", read_rtx_filename
, lineno
);
96 vfprintf (stderr
, msg
, ap
);
102 /* Queue PATTERN on LIST_TAIL. */
105 queue_pattern (pattern
, list_tail
, lineno
)
107 struct queue_elem
***list_tail
;
110 struct queue_elem
*e
= (struct queue_elem
*) xmalloc (sizeof (*e
));
115 *list_tail
= &e
->next
;
118 /* Recursively remove constraints from an rtx. */
121 remove_constraints (part
)
125 register const char *format_ptr
;
130 if (GET_CODE (part
) == MATCH_OPERAND
)
132 else if (GET_CODE (part
) == MATCH_SCRATCH
)
135 format_ptr
= GET_RTX_FORMAT (GET_CODE (part
));
137 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (part
)); i
++)
138 switch (*format_ptr
++)
142 remove_constraints (XEXP (part
, i
));
145 if (XVEC (part
, i
) != NULL
)
146 for (j
= 0; j
< XVECLEN (part
, i
); j
++)
147 remove_constraints (XVECEXP (part
, i
, j
));
152 /* Process a top level rtx in some way, queueing as appropriate. */
155 process_rtx (desc
, lineno
)
159 switch (GET_CODE (desc
))
162 queue_pattern (desc
, &define_insn_tail
, lineno
);
165 case DEFINE_COND_EXEC
:
166 queue_pattern (desc
, &define_cond_exec_tail
, lineno
);
170 queue_pattern (desc
, &define_attr_tail
, lineno
);
173 case DEFINE_INSN_AND_SPLIT
:
175 const char *split_cond
;
179 /* Create a split with values from the insn_and_split. */
180 split
= rtx_alloc (DEFINE_SPLIT
);
182 i
= XVECLEN (desc
, 1);
183 XVEC (split
, 0) = rtvec_alloc (i
);
186 XVECEXP (split
, 0, i
) = copy_rtx (XVECEXP (desc
, 1, i
));
187 remove_constraints (XVECEXP (split
, 0, i
));
190 /* If the split condition starts with "&&", append it to the
191 insn condition to create the new split condition. */
192 split_cond
= XSTR (desc
, 4);
193 if (split_cond
[0] == '&' && split_cond
[1] == '&')
195 const char *insn_cond
= XSTR (desc
, 2);
196 size_t insn_cond_len
= strlen (insn_cond
);
197 size_t split_cond_len
= strlen (split_cond
);
200 combined
= (char *) xmalloc (insn_cond_len
+ split_cond_len
+ 1);
201 memcpy (combined
, insn_cond
, insn_cond_len
);
202 memcpy (combined
+ insn_cond_len
, split_cond
, split_cond_len
+ 1);
204 split_cond
= combined
;
206 XSTR (split
, 1) = split_cond
;
207 XVEC (split
, 2) = XVEC (desc
, 5);
208 XSTR (split
, 3) = XSTR (desc
, 6);
210 /* Fix up the DEFINE_INSN. */
211 attr
= XVEC (desc
, 7);
212 PUT_CODE (desc
, DEFINE_INSN
);
213 XVEC (desc
, 4) = attr
;
216 queue_pattern (desc
, &define_insn_tail
, lineno
);
217 queue_pattern (split
, &other_tail
, lineno
);
222 queue_pattern (desc
, &other_tail
, lineno
);
227 /* Return true if attribute PREDICABLE is true for ELEM, which holds
232 struct queue_elem
*elem
;
234 rtvec vec
= XVEC (elem
->data
, 4);
239 return predicable_default
;
241 for (i
= GET_NUM_ELEM (vec
) - 1; i
>= 0; --i
)
243 rtx sub
= RTVEC_ELT (vec
, i
);
244 switch (GET_CODE (sub
))
247 if (strcmp (XSTR (sub
, 0), "predicable") == 0)
249 value
= XSTR (sub
, 1);
254 case SET_ATTR_ALTERNATIVE
:
255 if (strcmp (XSTR (sub
, 0), "predicable") == 0)
257 message_with_line (elem
->lineno
,
258 "multiple alternatives for `predicable'");
265 if (GET_CODE (SET_DEST (sub
)) != ATTR
266 || strcmp (XSTR (SET_DEST (sub
), 0), "predicable") != 0)
269 if (GET_CODE (sub
) == CONST_STRING
)
271 value
= XSTR (sub
, 0);
275 /* ??? It would be possible to handle this if we really tried.
276 It's not easy though, and I'm not going to bother until it
277 really proves necessary. */
278 message_with_line (elem
->lineno
,
279 "non-constant value for `predicable'");
288 return predicable_default
;
291 /* Verify that predicability does not vary on the alternative. */
292 /* ??? It should be possible to handle this by simply eliminating
293 the non-predicable alternatives from the insn. FRV would like
294 to do this. Delay this until we've got the basics solid. */
295 if (strchr (value
, ',') != NULL
)
297 message_with_line (elem
->lineno
,
298 "multiple alternatives for `predicable'");
303 /* Find out which value we're looking at. */
304 if (strcmp (value
, predicable_true
) == 0)
306 if (strcmp (value
, predicable_false
) == 0)
309 message_with_line (elem
->lineno
,
310 "Unknown value `%s' for `predicable' attribute",
316 /* Examine the attribute "predicable"; discover its boolean values
320 identify_predicable_attribute ()
322 struct queue_elem
*elem
;
327 /* Look for the DEFINE_ATTR for `predicable', which must exist. */
328 for (elem
= define_attr_queue
; elem
; elem
= elem
->next
)
329 if (strcmp (XSTR (elem
->data
, 0), "predicable") == 0)
332 message_with_line (define_cond_exec_queue
->lineno
,
333 "Attribute `predicable' not defined");
338 value
= XSTR (elem
->data
, 1);
339 len
= strlen (value
);
340 false = (char *) xmalloc (len
+ 1);
341 memcpy (false, value
, len
+ 1);
343 true = strchr (false, ',');
344 if (true == NULL
|| strchr (++true, ',') != NULL
)
346 message_with_line (elem
->lineno
,
347 "Attribute `predicable' is not a boolean");
353 predicable_true
= true;
354 predicable_false
= false;
356 switch (GET_CODE (XEXP (elem
->data
, 2)))
359 value
= XSTR (XEXP (elem
->data
, 2), 0);
363 message_with_line (elem
->lineno
,
364 "Attribute `predicable' cannot be const");
369 message_with_line (elem
->lineno
,
370 "Attribute `predicable' must have a constant default");
375 if (strcmp (value
, true) == 0)
376 predicable_default
= 1;
377 else if (strcmp (value
, false) == 0)
378 predicable_default
= 0;
381 message_with_line (elem
->lineno
,
382 "Unknown value `%s' for `predicable' attribute",
388 /* Return the number of alternatives in constraint S. */
403 /* Determine how many alternatives there are in INSN, and how many
407 collect_insn_data (pattern
, palt
, pmax
)
415 code
= GET_CODE (pattern
);
419 i
= n_alternatives (XSTR (pattern
, 2));
420 *palt
= (i
> *palt
? i
: *palt
);
427 i
= XINT (pattern
, 0);
436 fmt
= GET_RTX_FORMAT (code
);
437 len
= GET_RTX_LENGTH (code
);
438 for (i
= 0; i
< len
; i
++)
443 collect_insn_data (XEXP (pattern
, i
), palt
, pmax
);
447 if (XVEC (pattern
, i
) == NULL
)
451 for (j
= XVECLEN (pattern
, i
) - 1; j
>= 0; --j
)
452 collect_insn_data (XVECEXP (pattern
, i
, j
), palt
, pmax
);
455 case 'i': case 'w': case '0': case 's': case 'S':
465 alter_predicate_for_insn (pattern
, alt
, max_op
, lineno
)
467 int alt
, max_op
, lineno
;
473 code
= GET_CODE (pattern
);
478 const char *c
= XSTR (pattern
, 2);
480 if (n_alternatives (c
) != 1)
482 message_with_line (lineno
,
483 "Too many alternatives for operand %d",
489 /* Replicate C as needed to fill out ALT alternatives. */
490 if (c
&& *c
&& alt
> 1)
492 size_t c_len
= strlen (c
);
493 size_t len
= alt
* (c_len
+ 1);
494 char *new_c
= (char *) xmalloc (len
);
496 memcpy (new_c
, c
, c_len
);
497 for (i
= 1; i
< alt
; ++i
)
499 new_c
[i
* (c_len
+ 1) - 1] = ',';
500 memcpy (&new_c
[i
* (c_len
+ 1)], c
, c_len
);
502 new_c
[len
- 1] = '\0';
503 XSTR (pattern
, 2) = new_c
;
512 XINT (pattern
, 0) += max_op
;
519 fmt
= GET_RTX_FORMAT (code
);
520 len
= GET_RTX_LENGTH (code
);
521 for (i
= 0; i
< len
; i
++)
528 r
= alter_predicate_for_insn (XEXP (pattern
, i
), alt
,
535 for (j
= XVECLEN (pattern
, i
) - 1; j
>= 0; --j
)
537 r
= alter_predicate_for_insn (XVECEXP (pattern
, i
, j
),
538 alt
, max_op
, lineno
);
544 case 'i': case 'w': case '0': case 's':
556 alter_test_for_insn (ce_elem
, insn_elem
)
557 struct queue_elem
*ce_elem
, *insn_elem
;
559 const char *ce_test
, *insn_test
;
561 size_t len
, ce_len
, insn_len
;
563 ce_test
= XSTR (ce_elem
->data
, 1);
564 insn_test
= XSTR (insn_elem
->data
, 2);
565 if (!ce_test
|| *ce_test
== '\0')
567 if (!insn_test
|| *insn_test
== '\0')
570 ce_len
= strlen (ce_test
);
571 insn_len
= strlen (insn_test
);
572 len
= 1 + ce_len
+ 1 + 4 + 1 + insn_len
+ 1 + 1;
573 new_test
= (char *) xmalloc (len
);
575 sprintf (new_test
, "(%s) && (%s)", ce_test
, insn_test
);
580 /* Adjust all of the operand numbers in OLD to match the shift they'll
581 get from an operand displacement of DISP. Return a pointer after the
585 shift_output_template (new, old
, disp
)
597 if (ISDIGIT ((unsigned char) c
))
599 else if (ISUPPER ((unsigned char) c
)
600 || ISLOWER ((unsigned char) c
))
613 alter_output_for_insn (ce_elem
, insn_elem
, alt
, max_op
)
614 struct queue_elem
*ce_elem
, *insn_elem
;
617 const char *ce_out
, *insn_out
;
619 size_t len
, ce_len
, insn_len
;
621 /* ??? Could coordinate with genoutput to not duplicate code here. */
623 ce_out
= XSTR (ce_elem
->data
, 2);
624 insn_out
= XSTR (insn_elem
->data
, 3);
625 if (!ce_out
|| *ce_out
== '\0')
628 ce_len
= strlen (ce_out
);
629 insn_len
= strlen (insn_out
);
631 if (*insn_out
== '*')
632 /* You must take care of the predicate yourself. */
635 if (*insn_out
== '@')
637 len
= (ce_len
+ 1) * alt
+ insn_len
+ 1;
638 p
= new = xmalloc (len
);
644 while (ISSPACE ((unsigned char) *insn_out
));
646 if (*insn_out
!= '#')
648 p
= shift_output_template (p
, ce_out
, max_op
);
654 while (*insn_out
&& *insn_out
!= '\n');
661 len
= ce_len
+ 1 + insn_len
+ 1;
664 p
= shift_output_template (new, ce_out
, max_op
);
666 memcpy (p
, insn_out
, insn_len
+ 1);
672 /* Replicate insns as appropriate for the given DEFINE_COND_EXEC. */
675 process_one_cond_exec (ce_elem
)
676 struct queue_elem
*ce_elem
;
678 struct queue_elem
*insn_elem
;
679 for (insn_elem
= define_insn_queue
; insn_elem
; insn_elem
= insn_elem
->next
)
681 int alternatives
, max_operand
;
682 rtx pred
, insn
, pattern
;
684 if (! is_predicable (insn_elem
))
689 collect_insn_data (insn_elem
->data
, &alternatives
, &max_operand
);
692 if (XVECLEN (ce_elem
->data
, 0) != 1)
694 message_with_line (ce_elem
->lineno
,
695 "too many patterns in predicate");
700 pred
= copy_rtx (XVECEXP (ce_elem
->data
, 0, 0));
701 pred
= alter_predicate_for_insn (pred
, alternatives
, max_operand
,
706 /* Construct a new pattern for the new insn. */
707 insn
= copy_rtx (insn_elem
->data
);
709 pattern
= rtx_alloc (COND_EXEC
);
710 XEXP (pattern
, 0) = pred
;
711 if (XVECLEN (insn
, 1) == 1)
713 XEXP (pattern
, 1) = XVECEXP (insn
, 1, 0);
714 XVECEXP (insn
, 1, 0) = pattern
;
715 PUT_NUM_ELEM (XVEC (insn
, 1), 1);
719 XEXP (pattern
, 1) = rtx_alloc (PARALLEL
);
720 XVEC (XEXP (pattern
, 1), 0) = XVEC (insn
, 1);
721 XVEC (insn
, 1) = rtvec_alloc (1);
722 XVECEXP (insn
, 1, 0) = pattern
;
725 XSTR (insn
, 2) = alter_test_for_insn (ce_elem
, insn_elem
);
726 XSTR (insn
, 3) = alter_output_for_insn (ce_elem
, insn_elem
,
727 alternatives
, max_operand
);
729 /* ??? Set `predicable' to false. Not crucial since it's really
730 only used here, and we won't reprocess this new pattern. */
732 /* Put the new pattern on the `other' list so that it
733 (a) is not reprocessed by other define_cond_exec patterns
734 (b) appears after all normal define_insn patterns.
736 ??? B is debatable. If one has normal insns that match
737 cond_exec patterns, they will be preferred over these
738 generated patterns. Whether this matters in practice, or if
739 it's a good thing, or whether we should thread these new
740 patterns into the define_insn chain just after their generator
741 is something we'll have to experiment with. */
743 queue_pattern (insn
, &other_tail
, insn_elem
->lineno
);
747 /* If we have any DEFINE_COND_EXEC patterns, expand the DEFINE_INSN
748 patterns appropriately. */
751 process_define_cond_exec ()
753 struct queue_elem
*elem
;
755 identify_predicable_attribute ();
759 for (elem
= define_cond_exec_queue
; elem
; elem
= elem
->next
)
760 process_one_cond_exec (elem
);
763 /* The entry point for initializing the reader. */
766 init_md_reader (filename
)
767 const char *filename
;
772 read_rtx_filename
= filename
;
773 input_file
= fopen (filename
, "r");
777 return FATAL_EXIT_CODE
;
780 obstack_init (rtl_obstack
);
784 /* Read the entire file. */
790 c
= read_skip_spaces (input_file
);
794 ungetc (c
, input_file
);
795 lineno
= read_rtx_lineno
;
796 desc
= read_rtx (input_file
);
797 process_rtx (desc
, lineno
);
801 /* Process define_cond_exec patterns. */
802 if (define_cond_exec_queue
!= NULL
)
803 process_define_cond_exec ();
805 return errors
? FATAL_EXIT_CODE
: SUCCESS_EXIT_CODE
;
808 /* The entry point for reading a single rtx from an md file. */
811 read_md_rtx (lineno
, seqnr
)
815 struct queue_elem
**queue
, *elem
;
818 /* Read all patterns from a given queue before moving on to the next. */
819 if (define_attr_queue
!= NULL
)
820 queue
= &define_attr_queue
;
821 else if (define_insn_queue
!= NULL
)
822 queue
= &define_insn_queue
;
823 else if (other_queue
!= NULL
)
824 queue
= &other_queue
;
831 *lineno
= elem
->lineno
;
832 *seqnr
= sequence_num
;
836 switch (GET_CODE (desc
))
841 case DEFINE_PEEPHOLE
:
842 case DEFINE_PEEPHOLE2
:
853 /* Until we can use the versions in libiberty. */
858 register size_t len
= strlen (input
) + 1;
859 register char *output
= xmalloc (len
);
860 memcpy (output
, input
, len
);
871 ptr
= (PTR
) realloc (old
, size
);
873 ptr
= (PTR
) malloc (size
);
875 fatal ("virtual memory exhausted");
883 register PTR val
= (PTR
) malloc (size
);
886 fatal ("virtual memory exhausted");