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
;
178 /* Create a split with values from the insn_and_split. */
179 split
= rtx_alloc (DEFINE_SPLIT
);
180 XEXP (split
, 0) = copy_rtx (XEXP (desc
, 1));
181 remove_constraints (XEXP (split
, 0));
183 /* If the split condition starts with "&&", append it to the
184 insn condition to create the new split condition. */
185 split_cond
= XSTR (desc
, 4);
186 if (split_cond
[0] == '&' && split_cond
[1] == '&')
188 const char *insn_cond
= XSTR (desc
, 2);
189 size_t insn_cond_len
= strlen (insn_cond
);
190 size_t split_cond_len
= strlen (split_cond
);
193 combined
= (char *) xmalloc (insn_cond_len
+ split_cond_len
+ 1);
194 memcpy (combined
, insn_cond
, insn_cond_len
);
195 memcpy (combined
+ insn_cond_len
, split_cond
, split_cond_len
+ 1);
197 split_cond
= combined
;
199 XSTR (split
, 1) = split_cond
;
200 XVEC (split
, 2) = XVEC (desc
, 5);
201 XSTR (split
, 3) = XSTR (desc
, 6);
203 /* Fix up the DEFINE_INSN. */
204 PUT_CODE (desc
, DEFINE_INSN
);
205 XVEC (desc
, 4) = XVEC (desc
, 7);
208 queue_pattern (desc
, &define_insn_tail
, lineno
);
209 queue_pattern (split
, &other_tail
, lineno
);
214 queue_pattern (desc
, &other_tail
, lineno
);
219 /* Return true if attribute PREDICABLE is true for ELEM, which holds
224 struct queue_elem
*elem
;
226 rtvec vec
= XVEC (elem
->data
, 4);
231 return predicable_default
;
233 for (i
= GET_NUM_ELEM (vec
) - 1; i
>= 0; --i
)
235 rtx sub
= RTVEC_ELT (vec
, i
);
236 switch (GET_CODE (sub
))
239 if (strcmp (XSTR (sub
, 0), "predicable") == 0)
241 value
= XSTR (sub
, 1);
246 case SET_ATTR_ALTERNATIVE
:
247 if (strcmp (XSTR (sub
, 0), "predicable") == 0)
249 message_with_line (elem
->lineno
,
250 "multiple alternatives for `predicable'");
257 if (GET_CODE (SET_DEST (sub
)) != ATTR
258 || strcmp (XSTR (SET_DEST (sub
), 0), "predicable") != 0)
261 if (GET_CODE (sub
) == CONST_STRING
)
263 value
= XSTR (sub
, 0);
267 /* ??? It would be possible to handle this if we really tried.
268 It's not easy though, and I'm not going to bother until it
269 really proves necessary. */
270 message_with_line (elem
->lineno
,
271 "non-constant value for `predicable'");
280 return predicable_default
;
283 /* Verify that predicability does not vary on the alternative. */
284 /* ??? It should be possible to handle this by simply eliminating
285 the non-predicable alternatives from the insn. FRV would like
286 to do this. Delay this until we've got the basics solid. */
287 if (strchr (value
, ',') != NULL
)
289 message_with_line (elem
->lineno
,
290 "multiple alternatives for `predicable'");
295 /* Find out which value we're looking at. */
296 if (strcmp (value
, predicable_true
) == 0)
298 if (strcmp (value
, predicable_false
) == 0)
301 message_with_line (elem
->lineno
,
302 "Unknown value `%s' for `predicable' attribute",
308 /* Examine the attribute "predicable"; discover its boolean values
312 identify_predicable_attribute ()
314 struct queue_elem
*elem
;
319 /* Look for the DEFINE_ATTR for `predicable', which must exist. */
320 for (elem
= define_attr_queue
; elem
; elem
= elem
->next
)
321 if (strcmp (XSTR (elem
->data
, 0), "predicable") == 0)
324 message_with_line (define_cond_exec_queue
->lineno
,
325 "Attribute `predicable' not defined");
330 value
= XSTR (elem
->data
, 1);
331 len
= strlen (value
);
332 false = (char *) xmalloc (len
+ 1);
333 memcpy (false, value
, len
+ 1);
335 true = strchr (false, ',');
336 if (true == NULL
|| strchr (++true, ',') != NULL
)
338 message_with_line (elem
->lineno
,
339 "Attribute `predicable' is not a boolean");
345 predicable_true
= true;
346 predicable_false
= false;
348 switch (GET_CODE (XEXP (elem
->data
, 2)))
351 value
= XSTR (XEXP (elem
->data
, 2), 0);
355 message_with_line (elem
->lineno
,
356 "Attribute `predicable' cannot be const");
361 message_with_line (elem
->lineno
,
362 "Attribute `predicable' must have a constant default");
367 if (strcmp (value
, true) == 0)
368 predicable_default
= 1;
369 else if (strcmp (value
, false) == 0)
370 predicable_default
= 0;
373 message_with_line (elem
->lineno
,
374 "Unknown value `%s' for `predicable' attribute",
380 /* Return the number of alternatives in constraint S. */
395 /* Determine how many alternatives there are in INSN, and how many
399 collect_insn_data (pattern
, palt
, pmax
)
407 code
= GET_CODE (pattern
);
411 *palt
= n_alternatives (XSTR (pattern
, 2));
418 i
= XINT (pattern
, 0);
427 fmt
= GET_RTX_FORMAT (code
);
428 len
= GET_RTX_LENGTH (code
);
429 for (i
= 0; i
< len
; i
++)
434 collect_insn_data (XEXP (pattern
, i
), palt
, pmax
);
438 if (XVEC (pattern
, i
) == NULL
)
442 for (j
= XVECLEN (pattern
, i
) - 1; j
>= 0; --j
)
443 collect_insn_data (XVECEXP (pattern
, i
, j
), palt
, pmax
);
446 case 'i': case 'w': case '0': case 's': case 'S':
456 alter_predicate_for_insn (pattern
, alt
, max_op
, lineno
)
458 int alt
, max_op
, lineno
;
464 code
= GET_CODE (pattern
);
469 const char *c
= XSTR (pattern
, 2);
471 if (n_alternatives (c
) != 1)
473 message_with_line (lineno
,
474 "Too many alternatives for operand %d",
480 /* Replicate C as needed to fill out ALT alternatives. */
481 if (c
&& *c
&& alt
> 1)
483 size_t c_len
= strlen (c
);
484 size_t len
= alt
* (c_len
+ 1);
485 char *new_c
= (char *) xmalloc (len
);
487 memcpy (new_c
, c
, c_len
);
488 for (i
= 1; i
< alt
; ++i
)
490 new_c
[i
* (c_len
+ 1) - 1] = ',';
491 memcpy (&new_c
[i
* (c_len
+ 1)], c
, c_len
);
493 new_c
[len
- 1] = '\0';
494 XSTR (pattern
, 2) = new_c
;
503 XINT (pattern
, 0) += max_op
;
510 fmt
= GET_RTX_FORMAT (code
);
511 len
= GET_RTX_LENGTH (code
);
512 for (i
= 0; i
< len
; i
++)
519 r
= alter_predicate_for_insn (XEXP (pattern
, i
), alt
,
526 for (j
= XVECLEN (pattern
, i
) - 1; j
>= 0; --j
)
528 r
= alter_predicate_for_insn (XVECEXP (pattern
, i
, j
),
529 alt
, max_op
, lineno
);
535 case 'i': case 'w': case '0': case 's':
547 alter_test_for_insn (ce_elem
, insn_elem
)
548 struct queue_elem
*ce_elem
, *insn_elem
;
550 const char *ce_test
, *insn_test
;
552 size_t len
, ce_len
, insn_len
;
554 ce_test
= XSTR (ce_elem
->data
, 1);
555 insn_test
= XSTR (insn_elem
->data
, 2);
556 if (!ce_test
|| *ce_test
== '\0')
558 if (!insn_test
|| *insn_test
== '\0')
561 ce_len
= strlen (ce_test
);
562 insn_len
= strlen (insn_test
);
563 len
= 1 + ce_len
+ 1 + 4 + 1 + insn_len
+ 1 + 1;
564 new_test
= (char *) xmalloc (len
);
566 sprintf (new_test
, "(%s) && (%s)", ce_test
, insn_test
);
571 /* Adjust all of the operand numbers in OLD to match the shift they'll
572 get from an operand displacement of DISP. Return a pointer after the
576 shift_output_template (new, old
, disp
)
588 if (ISDIGIT ((unsigned char) c
))
590 else if (ISUPPER ((unsigned char) c
)
591 || ISLOWER ((unsigned char) c
))
604 alter_output_for_insn (ce_elem
, insn_elem
, alt
, max_op
)
605 struct queue_elem
*ce_elem
, *insn_elem
;
608 const char *ce_out
, *insn_out
;
610 size_t len
, ce_len
, insn_len
;
612 /* ??? Could coordinate with genoutput to not duplicate code here. */
614 ce_out
= XSTR (ce_elem
->data
, 2);
615 insn_out
= XSTR (insn_elem
->data
, 3);
616 if (!ce_out
|| *ce_out
== '\0')
619 ce_len
= strlen (ce_out
);
620 insn_len
= strlen (insn_out
);
622 if (*insn_out
== '*')
623 /* You must take care of the predicate yourself. */
626 if (*insn_out
== '@')
628 len
= (ce_len
+ 1) * alt
+ insn_len
+ 1;
629 p
= new = xmalloc (len
);
635 while (ISSPACE ((unsigned char) *insn_out
));
637 if (*insn_out
!= '#')
639 p
= shift_output_template (p
, ce_out
, max_op
);
645 while (*insn_out
&& *insn_out
!= '\n');
652 len
= ce_len
+ 1 + insn_len
+ 1;
655 p
= shift_output_template (new, ce_out
, max_op
);
657 memcpy (p
, insn_out
, insn_len
+ 1);
663 /* Replicate insns as appropriate for the given DEFINE_COND_EXEC. */
666 process_one_cond_exec (ce_elem
)
667 struct queue_elem
*ce_elem
;
669 struct queue_elem
*insn_elem
;
670 for (insn_elem
= define_insn_queue
; insn_elem
; insn_elem
= insn_elem
->next
)
672 int alternatives
, max_operand
;
673 rtx pred
, insn
, pattern
;
675 if (! is_predicable (insn_elem
))
680 collect_insn_data (insn_elem
->data
, &alternatives
, &max_operand
);
683 if (XVECLEN (ce_elem
->data
, 0) != 1)
685 message_with_line (ce_elem
->lineno
,
686 "too many patterns in predicate");
691 pred
= copy_rtx (XVECEXP (ce_elem
->data
, 0, 0));
692 pred
= alter_predicate_for_insn (pred
, alternatives
, max_operand
,
697 /* Construct a new pattern for the new insn. */
698 insn
= copy_rtx (insn_elem
->data
);
700 pattern
= rtx_alloc (COND_EXEC
);
701 XEXP (pattern
, 0) = pred
;
702 if (XVECLEN (insn
, 1) == 1)
704 XEXP (pattern
, 1) = XVECEXP (insn
, 1, 0);
705 XVECEXP (insn
, 1, 0) = pattern
;
706 PUT_NUM_ELEM (XVEC (insn
, 1), 1);
710 XEXP (pattern
, 1) = rtx_alloc (PARALLEL
);
711 XVEC (XEXP (pattern
, 1), 0) = XVEC (insn
, 1);
712 XVEC (insn
, 1) = rtvec_alloc (1);
713 XVECEXP (insn
, 1, 0) = pattern
;
716 XSTR (insn
, 2) = alter_test_for_insn (ce_elem
, insn_elem
);
717 XSTR (insn
, 3) = alter_output_for_insn (ce_elem
, insn_elem
,
718 alternatives
, max_operand
);
720 /* ??? Set `predicable' to false. Not crucial since it's really
721 only used here, and we won't reprocess this new pattern. */
723 /* Put the new pattern on the `other' list so that it
724 (a) is not reprocessed by other define_cond_exec patterns
725 (b) appears after all normal define_insn patterns.
727 ??? B is debatable. If one has normal insns that match
728 cond_exec patterns, they will be preferred over these
729 generated patterns. Whether this matters in practice, or if
730 it's a good thing, or whether we should thread these new
731 patterns into the define_insn chain just after their generator
732 is something we'll have to experiment with. */
734 queue_pattern (insn
, &other_tail
, insn_elem
->lineno
);
738 /* If we have any DEFINE_COND_EXEC patterns, expand the DEFINE_INSN
739 patterns appropriately. */
742 process_define_cond_exec ()
744 struct queue_elem
*elem
;
746 identify_predicable_attribute ();
750 for (elem
= define_cond_exec_queue
; elem
; elem
= elem
->next
)
751 process_one_cond_exec (elem
);
754 /* The entry point for initializing the reader. */
757 init_md_reader (filename
)
758 const char *filename
;
763 read_rtx_filename
= filename
;
764 input_file
= fopen (filename
, "r");
768 return FATAL_EXIT_CODE
;
771 obstack_init (rtl_obstack
);
775 /* Read the entire file. */
781 c
= read_skip_spaces (input_file
);
785 ungetc (c
, input_file
);
786 lineno
= read_rtx_lineno
;
787 desc
= read_rtx (input_file
);
788 process_rtx (desc
, lineno
);
792 /* Process define_cond_exec patterns. */
793 if (define_cond_exec_queue
!= NULL
)
794 process_define_cond_exec ();
796 return errors
? FATAL_EXIT_CODE
: SUCCESS_EXIT_CODE
;
799 /* The entry point for reading a single rtx from an md file. */
802 read_md_rtx (lineno
, seqnr
)
806 struct queue_elem
**queue
, *elem
;
809 /* Read all patterns from a given queue before moving on to the next. */
810 if (define_attr_queue
!= NULL
)
811 queue
= &define_attr_queue
;
812 else if (define_insn_queue
!= NULL
)
813 queue
= &define_insn_queue
;
814 else if (other_queue
!= NULL
)
815 queue
= &other_queue
;
822 *lineno
= elem
->lineno
;
823 *seqnr
= sequence_num
;
827 switch (GET_CODE (desc
))
832 case DEFINE_PEEPHOLE
:
833 case DEFINE_PEEPHOLE2
: