1 /* Support routines for the various generation passes.
2 Copyright (C) 2000, 2001 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it
7 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 GCC is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
14 License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING. If not, write to the Free
18 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
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
, ...))
83 VA_FIXEDARG (ap
, int, lineno
);
84 VA_FIXEDARG (ap
, const char *, msg
);
86 fprintf (stderr
, "%s:%d: ", read_rtx_filename
, lineno
);
87 vfprintf (stderr
, msg
, ap
);
93 /* Queue PATTERN on LIST_TAIL. */
96 queue_pattern (pattern
, list_tail
, lineno
)
98 struct queue_elem
***list_tail
;
101 struct queue_elem
*e
= (struct queue_elem
*) xmalloc (sizeof (*e
));
106 *list_tail
= &e
->next
;
109 /* Recursively remove constraints from an rtx. */
112 remove_constraints (part
)
116 const char *format_ptr
;
121 if (GET_CODE (part
) == MATCH_OPERAND
)
123 else if (GET_CODE (part
) == MATCH_SCRATCH
)
126 format_ptr
= GET_RTX_FORMAT (GET_CODE (part
));
128 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (part
)); i
++)
129 switch (*format_ptr
++)
133 remove_constraints (XEXP (part
, i
));
136 if (XVEC (part
, i
) != NULL
)
137 for (j
= 0; j
< XVECLEN (part
, i
); j
++)
138 remove_constraints (XVECEXP (part
, i
, j
));
143 /* Process a top level rtx in some way, queueing as appropriate. */
146 process_rtx (desc
, lineno
)
150 switch (GET_CODE (desc
))
153 queue_pattern (desc
, &define_insn_tail
, lineno
);
156 case DEFINE_COND_EXEC
:
157 queue_pattern (desc
, &define_cond_exec_tail
, lineno
);
161 queue_pattern (desc
, &define_attr_tail
, lineno
);
164 case DEFINE_INSN_AND_SPLIT
:
166 const char *split_cond
;
171 /* Create a split with values from the insn_and_split. */
172 split
= rtx_alloc (DEFINE_SPLIT
);
174 i
= XVECLEN (desc
, 1);
175 XVEC (split
, 0) = rtvec_alloc (i
);
178 XVECEXP (split
, 0, i
) = copy_rtx (XVECEXP (desc
, 1, i
));
179 remove_constraints (XVECEXP (split
, 0, i
));
182 /* If the split condition starts with "&&", append it to the
183 insn condition to create the new split condition. */
184 split_cond
= XSTR (desc
, 4);
185 if (split_cond
[0] == '&' && split_cond
[1] == '&')
187 const char *insn_cond
= XSTR (desc
, 2);
188 size_t insn_cond_len
= strlen (insn_cond
);
189 size_t split_cond_len
= strlen (split_cond
);
192 combined
= (char *) xmalloc (insn_cond_len
+ split_cond_len
+ 1);
193 memcpy (combined
, insn_cond
, insn_cond_len
);
194 memcpy (combined
+ insn_cond_len
, split_cond
, split_cond_len
+ 1);
196 split_cond
= combined
;
198 XSTR (split
, 1) = split_cond
;
199 XVEC (split
, 2) = XVEC (desc
, 5);
200 XSTR (split
, 3) = XSTR (desc
, 6);
202 /* Fix up the DEFINE_INSN. */
203 attr
= XVEC (desc
, 7);
204 PUT_CODE (desc
, DEFINE_INSN
);
205 XVEC (desc
, 4) = attr
;
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
;
315 char *p_true
, *p_false
;
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 p_false
= (char *) xmalloc (len
+ 1);
333 memcpy (p_false
, value
, len
+ 1);
335 p_true
= strchr (p_false
, ',');
336 if (p_true
== NULL
|| strchr (++p_true
, ',') != NULL
)
338 message_with_line (elem
->lineno
,
339 "Attribute `predicable' is not a boolean");
345 predicable_true
= p_true
;
346 predicable_false
= p_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
, p_true
) == 0)
368 predicable_default
= 1;
369 else if (strcmp (value
, p_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 i
= n_alternatives (XSTR (pattern
, 2));
412 *palt
= (i
> *palt
? i
: *palt
);
419 i
= XINT (pattern
, 0);
428 fmt
= GET_RTX_FORMAT (code
);
429 len
= GET_RTX_LENGTH (code
);
430 for (i
= 0; i
< len
; i
++)
435 collect_insn_data (XEXP (pattern
, i
), palt
, pmax
);
439 if (XVEC (pattern
, i
) == NULL
)
443 for (j
= XVECLEN (pattern
, i
) - 1; j
>= 0; --j
)
444 collect_insn_data (XVECEXP (pattern
, i
, j
), palt
, pmax
);
447 case 'i': case 'w': case '0': case 's': case 'S': case 'T':
457 alter_predicate_for_insn (pattern
, alt
, max_op
, lineno
)
459 int alt
, max_op
, lineno
;
465 code
= GET_CODE (pattern
);
470 const char *c
= XSTR (pattern
, 2);
472 if (n_alternatives (c
) != 1)
474 message_with_line (lineno
,
475 "Too many alternatives for operand %d",
481 /* Replicate C as needed to fill out ALT alternatives. */
482 if (c
&& *c
&& alt
> 1)
484 size_t c_len
= strlen (c
);
485 size_t len
= alt
* (c_len
+ 1);
486 char *new_c
= (char *) xmalloc (len
);
488 memcpy (new_c
, c
, c_len
);
489 for (i
= 1; i
< alt
; ++i
)
491 new_c
[i
* (c_len
+ 1) - 1] = ',';
492 memcpy (&new_c
[i
* (c_len
+ 1)], c
, c_len
);
494 new_c
[len
- 1] = '\0';
495 XSTR (pattern
, 2) = new_c
;
504 XINT (pattern
, 0) += max_op
;
511 fmt
= GET_RTX_FORMAT (code
);
512 len
= GET_RTX_LENGTH (code
);
513 for (i
= 0; i
< len
; i
++)
520 r
= alter_predicate_for_insn (XEXP (pattern
, i
), alt
,
527 for (j
= XVECLEN (pattern
, i
) - 1; j
>= 0; --j
)
529 r
= alter_predicate_for_insn (XVECEXP (pattern
, i
, j
),
530 alt
, max_op
, lineno
);
536 case 'i': case 'w': case '0': case 's':
548 alter_test_for_insn (ce_elem
, insn_elem
)
549 struct queue_elem
*ce_elem
, *insn_elem
;
551 const char *ce_test
, *insn_test
;
553 size_t len
, ce_len
, insn_len
;
555 ce_test
= XSTR (ce_elem
->data
, 1);
556 insn_test
= XSTR (insn_elem
->data
, 2);
557 if (!ce_test
|| *ce_test
== '\0')
559 if (!insn_test
|| *insn_test
== '\0')
562 ce_len
= strlen (ce_test
);
563 insn_len
= strlen (insn_test
);
564 len
= 1 + ce_len
+ 1 + 4 + 1 + insn_len
+ 1 + 1;
565 new_test
= (char *) xmalloc (len
);
567 sprintf (new_test
, "(%s) && (%s)", ce_test
, insn_test
);
572 /* Adjust all of the operand numbers in OLD to match the shift they'll
573 get from an operand displacement of DISP. Return a pointer after the
577 shift_output_template (new, old
, disp
)
589 if (ISDIGIT ((unsigned char) c
))
591 else if (ISUPPER ((unsigned char) c
)
592 || ISLOWER ((unsigned char) c
))
605 alter_output_for_insn (ce_elem
, insn_elem
, alt
, max_op
)
606 struct queue_elem
*ce_elem
, *insn_elem
;
609 const char *ce_out
, *insn_out
;
611 size_t len
, ce_len
, insn_len
;
613 /* ??? Could coordinate with genoutput to not duplicate code here. */
615 ce_out
= XSTR (ce_elem
->data
, 2);
616 insn_out
= XTMPL (insn_elem
->data
, 3);
617 if (!ce_out
|| *ce_out
== '\0')
620 ce_len
= strlen (ce_out
);
621 insn_len
= strlen (insn_out
);
623 if (*insn_out
== '*')
624 /* You must take care of the predicate yourself. */
627 if (*insn_out
== '@')
629 len
= (ce_len
+ 1) * alt
+ insn_len
+ 1;
630 p
= new = xmalloc (len
);
636 while (ISSPACE ((unsigned char) *insn_out
));
638 if (*insn_out
!= '#')
640 p
= shift_output_template (p
, ce_out
, max_op
);
646 while (*insn_out
&& *insn_out
!= '\n');
653 len
= ce_len
+ 1 + insn_len
+ 1;
656 p
= shift_output_template (new, ce_out
, max_op
);
658 memcpy (p
, insn_out
, insn_len
+ 1);
664 /* Replicate insns as appropriate for the given DEFINE_COND_EXEC. */
667 process_one_cond_exec (ce_elem
)
668 struct queue_elem
*ce_elem
;
670 struct queue_elem
*insn_elem
;
671 for (insn_elem
= define_insn_queue
; insn_elem
; insn_elem
= insn_elem
->next
)
673 int alternatives
, max_operand
;
674 rtx pred
, insn
, pattern
;
676 if (! is_predicable (insn_elem
))
681 collect_insn_data (insn_elem
->data
, &alternatives
, &max_operand
);
684 if (XVECLEN (ce_elem
->data
, 0) != 1)
686 message_with_line (ce_elem
->lineno
,
687 "too many patterns in predicate");
692 pred
= copy_rtx (XVECEXP (ce_elem
->data
, 0, 0));
693 pred
= alter_predicate_for_insn (pred
, alternatives
, max_operand
,
698 /* Construct a new pattern for the new insn. */
699 insn
= copy_rtx (insn_elem
->data
);
701 pattern
= rtx_alloc (COND_EXEC
);
702 XEXP (pattern
, 0) = pred
;
703 if (XVECLEN (insn
, 1) == 1)
705 XEXP (pattern
, 1) = XVECEXP (insn
, 1, 0);
706 XVECEXP (insn
, 1, 0) = pattern
;
707 PUT_NUM_ELEM (XVEC (insn
, 1), 1);
711 XEXP (pattern
, 1) = rtx_alloc (PARALLEL
);
712 XVEC (XEXP (pattern
, 1), 0) = XVEC (insn
, 1);
713 XVEC (insn
, 1) = rtvec_alloc (1);
714 XVECEXP (insn
, 1, 0) = pattern
;
717 XSTR (insn
, 2) = alter_test_for_insn (ce_elem
, insn_elem
);
718 XTMPL (insn
, 3) = alter_output_for_insn (ce_elem
, insn_elem
,
719 alternatives
, max_operand
);
721 /* ??? Set `predicable' to false. Not crucial since it's really
722 only used here, and we won't reprocess this new pattern. */
724 /* Put the new pattern on the `other' list so that it
725 (a) is not reprocessed by other define_cond_exec patterns
726 (b) appears after all normal define_insn patterns.
728 ??? B is debatable. If one has normal insns that match
729 cond_exec patterns, they will be preferred over these
730 generated patterns. Whether this matters in practice, or if
731 it's a good thing, or whether we should thread these new
732 patterns into the define_insn chain just after their generator
733 is something we'll have to experiment with. */
735 queue_pattern (insn
, &other_tail
, insn_elem
->lineno
);
739 /* If we have any DEFINE_COND_EXEC patterns, expand the DEFINE_INSN
740 patterns appropriately. */
743 process_define_cond_exec ()
745 struct queue_elem
*elem
;
747 identify_predicable_attribute ();
751 for (elem
= define_cond_exec_queue
; elem
; elem
= elem
->next
)
752 process_one_cond_exec (elem
);
755 /* The entry point for initializing the reader. */
758 init_md_reader (filename
)
759 const char *filename
;
764 read_rtx_filename
= filename
;
765 input_file
= fopen (filename
, "r");
769 return FATAL_EXIT_CODE
;
772 obstack_init (rtl_obstack
);
776 /* Read the entire file. */
782 c
= read_skip_spaces (input_file
);
786 ungetc (c
, input_file
);
787 lineno
= read_rtx_lineno
;
788 desc
= read_rtx (input_file
);
789 process_rtx (desc
, lineno
);
793 /* Process define_cond_exec patterns. */
794 if (define_cond_exec_queue
!= NULL
)
795 process_define_cond_exec ();
797 return errors
? FATAL_EXIT_CODE
: SUCCESS_EXIT_CODE
;
800 /* The entry point for reading a single rtx from an md file. */
803 read_md_rtx (lineno
, seqnr
)
807 struct queue_elem
**queue
, *elem
;
810 /* Read all patterns from a given queue before moving on to the next. */
811 if (define_attr_queue
!= NULL
)
812 queue
= &define_attr_queue
;
813 else if (define_insn_queue
!= NULL
)
814 queue
= &define_insn_queue
;
815 else if (other_queue
!= NULL
)
816 queue
= &other_queue
;
823 *lineno
= elem
->lineno
;
824 *seqnr
= sequence_num
;
828 switch (GET_CODE (desc
))
833 case DEFINE_PEEPHOLE
:
834 case DEFINE_PEEPHOLE2
:
845 /* Until we can use the versions in libiberty. */
850 size_t len
= strlen (input
) + 1;
851 char *output
= xmalloc (len
);
852 memcpy (output
, input
, len
);
857 xcalloc (nelem
, elsize
)
858 size_t nelem
, elsize
;
862 if (nelem
== 0 || elsize
== 0)
865 newmem
= really_call_calloc (nelem
, elsize
);
867 fatal ("virtual memory exhausted");
878 ptr
= (PTR
) really_call_realloc (old
, size
);
880 ptr
= (PTR
) really_call_malloc (size
);
882 fatal ("virtual memory exhausted");
890 PTR val
= (PTR
) really_call_malloc (size
);
893 fatal ("virtual memory exhausted");