1 /* Generate code from machine description to recognize rtl as insns.
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1997, 1998,
3 1999, 2000 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it 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 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* This program is used to produce insn-recog.c, which contains a
24 function called `recog' plus its subroutines. These functions
25 contain a decision tree that recognizes whether an rtx, the
26 argument given to recog, is a valid instruction.
28 recog returns -1 if the rtx is not valid. If the rtx is valid,
29 recog returns a nonnegative number which is the insn code number
30 for the pattern that matched. This is the same as the order in the
31 machine description of the entry that matched. This number can be
32 used as an index into various insn_* tables, such as insn_template,
33 insn_outfun, and insn_n_operands (found in insn-output.c).
35 The third argument to recog is an optional pointer to an int. If
36 present, recog will accept a pattern if it matches except for
37 missing CLOBBER expressions at the end. In that case, the value
38 pointed to by the optional pointer will be set to the number of
39 CLOBBERs that need to be added (it should be initialized to zero by
40 the caller). If it is set nonzero, the caller should allocate a
41 PARALLEL of the appropriate size, copy the initial entries, and
42 call add_clobbers (found in insn-emit.c) to fill in the CLOBBERs.
44 This program also generates the function `split_insns', which
45 returns 0 if the rtl could not be split, or it returns the split
48 This program also generates the function `peephole2_insns', which
49 returns 0 if the rtl could not be matched. If there was a match,
50 the new rtl is returned in a SEQUENCE, and LAST_INSN will point
51 to the last recognized insn in the old sequence. */
57 #include "gensupport.h"
60 #define OUTPUT_LABEL(INDENT_STRING, LABEL_NUMBER) \
61 printf("%sL%d: ATTRIBUTE_UNUSED_LABEL\n", (INDENT_STRING), (LABEL_NUMBER))
63 /* Holds an array of names indexed by insn_code_number. */
64 static char **insn_name_ptr
= 0;
65 static int insn_name_ptr_size
= 0;
67 /* A listhead of decision trees. The alternatives to a node are kept
68 in a doublely-linked list so we can easily add nodes to the proper
69 place when merging. */
73 struct decision
*first
;
74 struct decision
*last
;
77 /* A single test. The two accept types aren't tests per-se, but
78 their equality (or lack thereof) does affect tree merging so
79 it is convenient to keep them here. */
83 /* A linked list through the tests attached to a node. */
84 struct decision_test
*next
;
86 /* These types are roughly in the order in which we'd like to test them. */
88 DT_mode
, DT_code
, DT_veclen
,
89 DT_elt_zero_int
, DT_elt_one_int
, DT_elt_zero_wide
,
90 DT_veclen_ge
, DT_dup
, DT_pred
, DT_c_test
,
91 DT_accept_op
, DT_accept_insn
96 enum machine_mode mode
; /* Machine mode of node. */
97 RTX_CODE code
; /* Code to test. */
101 const char *name
; /* Predicate to call. */
102 int index
; /* Index into `preds' or -1. */
103 enum machine_mode mode
; /* Machine mode for node. */
106 const char *c_test
; /* Additional test to perform. */
107 int veclen
; /* Length of vector. */
108 int dup
; /* Number of operand to compare against. */
109 HOST_WIDE_INT intval
; /* Value for XINT for XWINT. */
110 int opno
; /* Operand number matched. */
113 int code_number
; /* Insn number matched. */
114 int lineno
; /* Line number of the insn. */
115 int num_clobbers_to_add
; /* Number of CLOBBERs to be added. */
120 /* Data structure for decision tree for recognizing legitimate insns. */
124 struct decision_head success
; /* Nodes to test on success. */
125 struct decision
*next
; /* Node to test on failure. */
126 struct decision
*prev
; /* Node whose failure tests us. */
127 struct decision
*afterward
; /* Node to test on success,
128 but failure of successor nodes. */
130 const char *position
; /* String denoting position in pattern. */
132 struct decision_test
*tests
; /* The tests for this node. */
134 int number
; /* Node number, used for labels */
135 int subroutine_number
; /* Number of subroutine this node starts */
136 int need_label
; /* Label needs to be output. */
139 #define SUBROUTINE_THRESHOLD 100
141 static int next_subroutine_number
;
143 /* We can write three types of subroutines: One for insn recognition,
144 one to split insns, and one for peephole-type optimizations. This
145 defines which type is being written. */
148 RECOG
, SPLIT
, PEEPHOLE2
151 #define IS_SPLIT(X) ((X) != RECOG)
153 /* Next available node number for tree nodes. */
155 static int next_number
;
157 /* Next number to use as an insn_code. */
159 static int next_insn_code
;
161 /* Similar, but counts all expressions in the MD file; used for
164 static int next_index
;
166 /* Record the highest depth we ever have so we know how many variables to
167 allocate in each subroutine we make. */
169 static int max_depth
;
171 /* The line number of the start of the pattern currently being processed. */
172 static int pattern_lineno
;
174 /* Count of errors. */
175 static int error_count
;
177 /* This table contains a list of the rtl codes that can possibly match a
178 predicate defined in recog.c. The function `maybe_both_true' uses it to
179 deduce that there are no expressions that can be matches by certain pairs
180 of tree nodes. Also, if a predicate can match only one code, we can
181 hardwire that code into the node testing the predicate. */
183 static struct pred_table
186 RTX_CODE codes
[NUM_RTX_CODE
];
188 {"general_operand", {CONST_INT
, CONST_DOUBLE
, CONST
, SYMBOL_REF
,
189 LABEL_REF
, SUBREG
, REG
, MEM
}},
190 #ifdef PREDICATE_CODES
193 {"address_operand", {CONST_INT
, CONST_DOUBLE
, CONST
, SYMBOL_REF
,
194 LABEL_REF
, SUBREG
, REG
, MEM
, PLUS
, MINUS
, MULT
}},
195 {"register_operand", {SUBREG
, REG
}},
196 {"pmode_register_operand", {SUBREG
, REG
}},
197 {"scratch_operand", {SCRATCH
, REG
}},
198 {"immediate_operand", {CONST_INT
, CONST_DOUBLE
, CONST
, SYMBOL_REF
,
200 {"const_int_operand", {CONST_INT
}},
201 {"const_double_operand", {CONST_INT
, CONST_DOUBLE
}},
202 {"nonimmediate_operand", {SUBREG
, REG
, MEM
}},
203 {"nonmemory_operand", {CONST_INT
, CONST_DOUBLE
, CONST
, SYMBOL_REF
,
204 LABEL_REF
, SUBREG
, REG
}},
205 {"push_operand", {MEM
}},
206 {"pop_operand", {MEM
}},
207 {"memory_operand", {SUBREG
, MEM
}},
208 {"indirect_operand", {SUBREG
, MEM
}},
209 {"comparison_operator", {EQ
, NE
, LE
, LT
, GE
, GT
, LEU
, LTU
, GEU
, GTU
,
210 UNORDERED
, ORDERED
, UNEQ
, UNGE
, UNGT
, UNLE
,
212 {"mode_independent_operand", {CONST_INT
, CONST_DOUBLE
, CONST
, SYMBOL_REF
,
213 LABEL_REF
, SUBREG
, REG
, MEM
}}
216 #define NUM_KNOWN_PREDS ARRAY_SIZE (preds)
218 static const char * special_mode_pred_table
[] = {
219 #ifdef SPECIAL_MODE_PREDICATES
220 SPECIAL_MODE_PREDICATES
222 "pmode_register_operand"
225 #define NUM_SPECIAL_MODE_PREDS ARRAY_SIZE (special_mode_pred_table)
227 static struct decision
*new_decision
228 PARAMS ((const char *, struct decision_head
*));
229 static struct decision_test
*new_decision_test
230 PARAMS ((enum decision_type
, struct decision_test
***));
231 static rtx find_operand
233 static rtx find_matching_operand
235 static void validate_pattern
236 PARAMS ((rtx
, rtx
, rtx
, int));
237 static struct decision
*add_to_sequence
238 PARAMS ((rtx
, struct decision_head
*, const char *, enum routine_type
, int));
240 static int maybe_both_true_2
241 PARAMS ((struct decision_test
*, struct decision_test
*));
242 static int maybe_both_true_1
243 PARAMS ((struct decision_test
*, struct decision_test
*));
244 static int maybe_both_true
245 PARAMS ((struct decision
*, struct decision
*, int));
247 static int nodes_identical_1
248 PARAMS ((struct decision_test
*, struct decision_test
*));
249 static int nodes_identical
250 PARAMS ((struct decision
*, struct decision
*));
251 static void merge_accept_insn
252 PARAMS ((struct decision
*, struct decision
*));
253 static void merge_trees
254 PARAMS ((struct decision_head
*, struct decision_head
*));
256 static void factor_tests
257 PARAMS ((struct decision_head
*));
258 static void simplify_tests
259 PARAMS ((struct decision_head
*));
260 static int break_out_subroutines
261 PARAMS ((struct decision_head
*, int));
262 static void find_afterward
263 PARAMS ((struct decision_head
*, struct decision
*));
265 static void change_state
266 PARAMS ((const char *, const char *, struct decision
*, const char *));
267 static void print_code
268 PARAMS ((enum rtx_code
));
269 static void write_afterward
270 PARAMS ((struct decision
*, struct decision
*, const char *));
271 static struct decision
*write_switch
272 PARAMS ((struct decision
*, int));
273 static void write_cond
274 PARAMS ((struct decision_test
*, int, enum routine_type
));
275 static void write_action
276 PARAMS ((struct decision
*, struct decision_test
*, int, int,
277 struct decision
*, enum routine_type
));
278 static int is_unconditional
279 PARAMS ((struct decision_test
*, enum routine_type
));
280 static int write_node
281 PARAMS ((struct decision
*, int, enum routine_type
));
282 static void write_tree_1
283 PARAMS ((struct decision_head
*, int, enum routine_type
));
284 static void write_tree
285 PARAMS ((struct decision_head
*, const char *, enum routine_type
, int));
286 static void write_subroutine
287 PARAMS ((struct decision_head
*, enum routine_type
));
288 static void write_subroutines
289 PARAMS ((struct decision_head
*, enum routine_type
));
290 static void write_header
293 static struct decision_head make_insn_sequence
294 PARAMS ((rtx
, enum routine_type
));
295 static void process_tree
296 PARAMS ((struct decision_head
*, enum routine_type
));
298 static void record_insn_name
299 PARAMS ((int, const char *));
301 static void debug_decision_0
302 PARAMS ((struct decision
*, int, int));
303 static void debug_decision_1
304 PARAMS ((struct decision
*, int));
305 static void debug_decision_2
306 PARAMS ((struct decision_test
*));
307 extern void debug_decision
308 PARAMS ((struct decision
*));
309 extern void debug_decision_list
310 PARAMS ((struct decision
*));
312 /* Create a new node in sequence after LAST. */
314 static struct decision
*
315 new_decision (position
, last
)
316 const char *position
;
317 struct decision_head
*last
;
319 register struct decision
*new
320 = (struct decision
*) xmalloc (sizeof (struct decision
));
322 memset (new, 0, sizeof (*new));
323 new->success
= *last
;
324 new->position
= xstrdup (position
);
325 new->number
= next_number
++;
327 last
->first
= last
->last
= new;
331 /* Create a new test and link it in at PLACE. */
333 static struct decision_test
*
334 new_decision_test (type
, pplace
)
335 enum decision_type type
;
336 struct decision_test
***pplace
;
338 struct decision_test
**place
= *pplace
;
339 struct decision_test
*test
;
341 test
= (struct decision_test
*) xmalloc (sizeof (*test
));
352 /* Search for and return operand N. */
355 find_operand (pattern
, n
)
364 code
= GET_CODE (pattern
);
365 if ((code
== MATCH_SCRATCH
366 || code
== MATCH_INSN
367 || code
== MATCH_OPERAND
368 || code
== MATCH_OPERATOR
369 || code
== MATCH_PARALLEL
)
370 && XINT (pattern
, 0) == n
)
373 fmt
= GET_RTX_FORMAT (code
);
374 len
= GET_RTX_LENGTH (code
);
375 for (i
= 0; i
< len
; i
++)
380 if ((r
= find_operand (XEXP (pattern
, i
), n
)) != NULL_RTX
)
385 if (! XVEC (pattern
, i
))
390 for (j
= 0; j
< XVECLEN (pattern
, i
); j
++)
391 if ((r
= find_operand (XVECEXP (pattern
, i
, j
), n
)) != NULL_RTX
)
395 case 'i': case 'w': case '0': case 's':
406 /* Search for and return operand M, such that it has a matching
407 constraint for operand N. */
410 find_matching_operand (pattern
, n
)
419 code
= GET_CODE (pattern
);
420 if (code
== MATCH_OPERAND
421 && (XSTR (pattern
, 2)[0] == '0' + n
422 || (XSTR (pattern
, 2)[0] == '%'
423 && XSTR (pattern
, 2)[1] == '0' + n
)))
426 fmt
= GET_RTX_FORMAT (code
);
427 len
= GET_RTX_LENGTH (code
);
428 for (i
= 0; i
< len
; i
++)
433 if ((r
= find_matching_operand (XEXP (pattern
, i
), n
)))
438 if (! XVEC (pattern
, i
))
443 for (j
= 0; j
< XVECLEN (pattern
, i
); j
++)
444 if ((r
= find_matching_operand (XVECEXP (pattern
, i
, j
), n
)))
448 case 'i': case 'w': case '0': case 's':
460 /* Check for various errors in patterns. SET is nonnull for a destination,
461 and is the complete set pattern. SET_CODE is '=' for normal sets, and
462 '+' within a context that requires in-out constraints. */
465 validate_pattern (pattern
, insn
, set
, set_code
)
476 code
= GET_CODE (pattern
);
486 const char *pred_name
= XSTR (pattern
, 1);
487 int allows_non_lvalue
= 1, allows_non_const
= 1;
488 int special_mode_pred
= 0;
491 if (GET_CODE (insn
) == DEFINE_INSN
)
492 c_test
= XSTR (insn
, 2);
494 c_test
= XSTR (insn
, 1);
496 if (pred_name
[0] != 0)
498 for (i
= 0; i
< NUM_KNOWN_PREDS
; i
++)
499 if (! strcmp (preds
[i
].name
, pred_name
))
502 if (i
< NUM_KNOWN_PREDS
)
506 allows_non_lvalue
= allows_non_const
= 0;
507 for (j
= 0; preds
[i
].codes
[j
] != 0; j
++)
509 RTX_CODE c
= preds
[i
].codes
[j
];
516 && c
!= CONSTANT_P_RTX
)
517 allows_non_const
= 1;
524 && c
!= STRICT_LOW_PART
)
525 allows_non_lvalue
= 1;
530 #ifdef PREDICATE_CODES
531 /* If the port has a list of the predicates it uses but
533 message_with_line (pattern_lineno
,
534 "warning: `%s' not in PREDICATE_CODES",
539 for (i
= 0; i
< NUM_SPECIAL_MODE_PREDS
; ++i
)
540 if (strcmp (pred_name
, special_mode_pred_table
[i
]) == 0)
542 special_mode_pred
= 1;
547 /* A MATCH_OPERAND that is a SET should have an output reload. */
548 if (set
&& code
== MATCH_OPERAND
549 && XSTR (pattern
, 2)[0] != '\0')
553 if (XSTR (pattern
, 2)[0] == '+')
555 /* If we've only got an output reload for this operand,
556 we'd better have a matching input operand. */
557 else if (XSTR (pattern
, 2)[0] == '='
558 && find_matching_operand (insn
, XINT (pattern
, 0)))
562 message_with_line (pattern_lineno
,
563 "operand %d missing in-out reload",
568 else if (XSTR (pattern
, 2)[0] != '='
569 && XSTR (pattern
, 2)[0] != '+')
571 message_with_line (pattern_lineno
,
572 "operand %d missing output reload",
578 /* Allowing non-lvalues in destinations -- particularly CONST_INT --
579 while not likely to occur at runtime, results in less efficient
580 code from insn-recog.c. */
582 && pred_name
[0] != '\0'
583 && allows_non_lvalue
)
585 message_with_line (pattern_lineno
,
586 "warning: destination operand %d allows non-lvalue",
590 /* A modeless MATCH_OPERAND can be handy when we can
591 check for multiple modes in the c_test. In most other cases,
592 it is a mistake. Only DEFINE_INSN is eligible, since SPLIT
593 and PEEP2 can FAIL within the output pattern. Exclude
594 address_operand, since its mode is related to the mode of
595 the memory not the operand. Exclude the SET_DEST of a call
596 instruction, as that is a common idiom. */
598 if (GET_MODE (pattern
) == VOIDmode
599 && code
== MATCH_OPERAND
600 && GET_CODE (insn
) == DEFINE_INSN
602 && ! special_mode_pred
603 && pred_name
[0] != '\0'
604 && strcmp (pred_name
, "address_operand") != 0
605 && strstr (c_test
, "operands") == NULL
607 && GET_CODE (set
) == SET
608 && GET_CODE (SET_SRC (set
)) == CALL
))
610 message_with_line (pattern_lineno
,
611 "warning: operand %d missing mode?",
619 enum machine_mode dmode
, smode
;
622 dest
= SET_DEST (pattern
);
623 src
= SET_SRC (pattern
);
625 /* Find the referant for a DUP. */
627 if (GET_CODE (dest
) == MATCH_DUP
628 || GET_CODE (dest
) == MATCH_OP_DUP
629 || GET_CODE (dest
) == MATCH_PAR_DUP
)
630 dest
= find_operand (insn
, XINT (dest
, 0));
632 if (GET_CODE (src
) == MATCH_DUP
633 || GET_CODE (src
) == MATCH_OP_DUP
634 || GET_CODE (src
) == MATCH_PAR_DUP
)
635 src
= find_operand (insn
, XINT (src
, 0));
637 /* STRICT_LOW_PART is a wrapper. Its argument is the real
638 destination, and it's mode should match the source. */
639 if (GET_CODE (dest
) == STRICT_LOW_PART
)
640 dest
= XEXP (dest
, 0);
642 dmode
= GET_MODE (dest
);
643 smode
= GET_MODE (src
);
645 /* The mode of an ADDRESS_OPERAND is the mode of the memory
646 reference, not the mode of the address. */
647 if (GET_CODE (src
) == MATCH_OPERAND
648 && ! strcmp (XSTR (src
, 1), "address_operand"))
651 /* The operands of a SET must have the same mode unless one
653 else if (dmode
!= VOIDmode
&& smode
!= VOIDmode
&& dmode
!= smode
)
655 message_with_line (pattern_lineno
,
656 "mode mismatch in set: %smode vs %smode",
657 GET_MODE_NAME (dmode
), GET_MODE_NAME (smode
));
661 /* If only one of the operands is VOIDmode, and PC or CC0 is
662 not involved, it's probably a mistake. */
663 else if (dmode
!= smode
664 && GET_CODE (dest
) != PC
665 && GET_CODE (dest
) != CC0
666 && GET_CODE (src
) != PC
667 && GET_CODE (src
) != CC0
668 && GET_CODE (src
) != CONST_INT
)
671 which
= (dmode
== VOIDmode
? "destination" : "source");
672 message_with_line (pattern_lineno
,
673 "warning: %s missing a mode?", which
);
676 if (dest
!= SET_DEST (pattern
))
677 validate_pattern (dest
, insn
, pattern
, '=');
678 validate_pattern (SET_DEST (pattern
), insn
, pattern
, '=');
679 validate_pattern (SET_SRC (pattern
), insn
, NULL_RTX
, 0);
684 validate_pattern (SET_DEST (pattern
), insn
, pattern
, '=');
688 validate_pattern (XEXP (pattern
, 0), insn
, set
, set
? '+' : 0);
689 validate_pattern (XEXP (pattern
, 1), insn
, NULL_RTX
, 0);
690 validate_pattern (XEXP (pattern
, 2), insn
, NULL_RTX
, 0);
693 case STRICT_LOW_PART
:
694 validate_pattern (XEXP (pattern
, 0), insn
, set
, set
? '+' : 0);
698 if (GET_MODE (XEXP (pattern
, 0)) != VOIDmode
)
700 message_with_line (pattern_lineno
,
701 "operand to label_ref %smode not VOIDmode",
702 GET_MODE_NAME (GET_MODE (XEXP (pattern
, 0))));
711 fmt
= GET_RTX_FORMAT (code
);
712 len
= GET_RTX_LENGTH (code
);
713 for (i
= 0; i
< len
; i
++)
718 validate_pattern (XEXP (pattern
, i
), insn
, NULL_RTX
, 0);
722 for (j
= 0; j
< XVECLEN (pattern
, i
); j
++)
723 validate_pattern (XVECEXP (pattern
, i
, j
), insn
, NULL_RTX
, 0);
726 case 'i': case 'w': case '0': case 's':
735 /* Create a chain of nodes to verify that an rtl expression matches
738 LAST is a pointer to the listhead in the previous node in the chain (or
739 in the calling function, for the first node).
741 POSITION is the string representing the current position in the insn.
743 INSN_TYPE is the type of insn for which we are emitting code.
745 A pointer to the final node in the chain is returned. */
747 static struct decision
*
748 add_to_sequence (pattern
, last
, position
, insn_type
, top
)
750 struct decision_head
*last
;
751 const char *position
;
752 enum routine_type insn_type
;
756 struct decision
*this, *sub
;
757 struct decision_test
*test
;
758 struct decision_test
**place
;
761 register const char *fmt
;
762 int depth
= strlen (position
);
764 enum machine_mode mode
;
766 if (depth
> max_depth
)
769 subpos
= (char *) xmalloc (depth
+ 2);
770 strcpy (subpos
, position
);
771 subpos
[depth
+ 1] = 0;
773 sub
= this = new_decision (position
, last
);
774 place
= &this->tests
;
777 mode
= GET_MODE (pattern
);
778 code
= GET_CODE (pattern
);
783 /* Toplevel peephole pattern. */
784 if (insn_type
== PEEPHOLE2
&& top
)
786 /* We don't need the node we just created -- unlink it. */
787 last
->first
= last
->last
= NULL
;
789 for (i
= 0; i
< (size_t) XVECLEN (pattern
, 0); i
++)
791 /* Which insn we're looking at is represented by A-Z. We don't
792 ever use 'A', however; it is always implied. */
794 subpos
[depth
] = (i
> 0 ? 'A' + i
: 0);
795 sub
= add_to_sequence (XVECEXP (pattern
, 0, i
),
796 last
, subpos
, insn_type
, 0);
797 last
= &sub
->success
;
802 /* Else nothing special. */
806 /* The explicit patterns within a match_parallel enforce a minimum
807 length on the vector. The match_parallel predicate may allow
808 for more elements. We do need to check for this minimum here
809 or the code generated to match the internals may reference data
810 beyond the end of the vector. */
811 test
= new_decision_test (DT_veclen_ge
, &place
);
812 test
->u
.veclen
= XVECLEN (pattern
, 2);
820 const char *pred_name
;
821 RTX_CODE was_code
= code
;
822 int allows_const_int
= 1;
824 if (code
== MATCH_SCRATCH
)
826 pred_name
= "scratch_operand";
831 pred_name
= XSTR (pattern
, 1);
832 if (code
== MATCH_PARALLEL
)
838 if (pred_name
[0] != 0)
840 test
= new_decision_test (DT_pred
, &place
);
841 test
->u
.pred
.name
= pred_name
;
842 test
->u
.pred
.mode
= mode
;
844 /* See if we know about this predicate and save its number. If
845 we do, and it only accepts one code, note that fact. The
846 predicate `const_int_operand' only tests for a CONST_INT, so
847 if we do so we can avoid calling it at all.
849 Finally, if we know that the predicate does not allow
850 CONST_INT, we know that the only way the predicate can match
851 is if the modes match (here we use the kludge of relying on
852 the fact that "address_operand" accepts CONST_INT; otherwise,
853 it would have to be a special case), so we can test the mode
854 (but we need not). This fact should considerably simplify the
857 for (i
= 0; i
< NUM_KNOWN_PREDS
; i
++)
858 if (! strcmp (preds
[i
].name
, pred_name
))
861 if (i
< NUM_KNOWN_PREDS
)
865 test
->u
.pred
.index
= i
;
867 if (preds
[i
].codes
[1] == 0 && code
== UNKNOWN
)
868 code
= preds
[i
].codes
[0];
870 allows_const_int
= 0;
871 for (j
= 0; preds
[i
].codes
[j
] != 0; j
++)
872 if (preds
[i
].codes
[j
] == CONST_INT
)
874 allows_const_int
= 1;
879 test
->u
.pred
.index
= -1;
882 /* Can't enforce a mode if we allow const_int. */
883 if (allows_const_int
)
886 /* Accept the operand, ie. record it in `operands'. */
887 test
= new_decision_test (DT_accept_op
, &place
);
888 test
->u
.opno
= XINT (pattern
, 0);
890 if (was_code
== MATCH_OPERATOR
|| was_code
== MATCH_PARALLEL
)
892 char base
= (was_code
== MATCH_OPERATOR
? '0' : 'a');
893 for (i
= 0; i
< (size_t) XVECLEN (pattern
, 2); i
++)
895 subpos
[depth
] = i
+ base
;
896 sub
= add_to_sequence (XVECEXP (pattern
, 2, i
),
897 &sub
->success
, subpos
, insn_type
, 0);
906 test
= new_decision_test (DT_dup
, &place
);
907 test
->u
.dup
= XINT (pattern
, 0);
909 test
= new_decision_test (DT_accept_op
, &place
);
910 test
->u
.opno
= XINT (pattern
, 0);
912 for (i
= 0; i
< (size_t) XVECLEN (pattern
, 1); i
++)
914 subpos
[depth
] = i
+ '0';
915 sub
= add_to_sequence (XVECEXP (pattern
, 1, i
),
916 &sub
->success
, subpos
, insn_type
, 0);
924 test
= new_decision_test (DT_dup
, &place
);
925 test
->u
.dup
= XINT (pattern
, 0);
929 pattern
= XEXP (pattern
, 0);
936 fmt
= GET_RTX_FORMAT (code
);
937 len
= GET_RTX_LENGTH (code
);
939 /* Do tests against the current node first. */
940 for (i
= 0; i
< (size_t) len
; i
++)
946 test
= new_decision_test (DT_elt_zero_int
, &place
);
947 test
->u
.intval
= XINT (pattern
, i
);
951 test
= new_decision_test (DT_elt_one_int
, &place
);
952 test
->u
.intval
= XINT (pattern
, i
);
957 else if (fmt
[i
] == 'w')
962 test
= new_decision_test (DT_elt_zero_wide
, &place
);
963 test
->u
.intval
= XWINT (pattern
, i
);
965 else if (fmt
[i
] == 'E')
970 test
= new_decision_test (DT_veclen
, &place
);
971 test
->u
.veclen
= XVECLEN (pattern
, i
);
975 /* Now test our sub-patterns. */
976 for (i
= 0; i
< (size_t) len
; i
++)
981 subpos
[depth
] = '0' + i
;
982 sub
= add_to_sequence (XEXP (pattern
, i
), &sub
->success
,
983 subpos
, insn_type
, 0);
989 for (j
= 0; j
< XVECLEN (pattern
, i
); j
++)
991 subpos
[depth
] = 'a' + j
;
992 sub
= add_to_sequence (XVECEXP (pattern
, i
, j
),
993 &sub
->success
, subpos
, insn_type
, 0);
1010 /* Insert nodes testing mode and code, if they're still relevant,
1011 before any of the nodes we may have added above. */
1012 if (code
!= UNKNOWN
)
1014 place
= &this->tests
;
1015 test
= new_decision_test (DT_code
, &place
);
1016 test
->u
.code
= code
;
1019 if (mode
!= VOIDmode
)
1021 place
= &this->tests
;
1022 test
= new_decision_test (DT_mode
, &place
);
1023 test
->u
.mode
= mode
;
1026 /* If we didn't insert any tests or accept nodes, hork. */
1027 if (this->tests
== NULL
)
1035 /* A subroutine of maybe_both_true; examines only one test.
1036 Returns > 0 for "definitely both true" and < 0 for "maybe both true". */
1039 maybe_both_true_2 (d1
, d2
)
1040 struct decision_test
*d1
, *d2
;
1042 if (d1
->type
== d2
->type
)
1047 return d1
->u
.mode
== d2
->u
.mode
;
1050 return d1
->u
.code
== d2
->u
.code
;
1053 return d1
->u
.veclen
== d2
->u
.veclen
;
1055 case DT_elt_zero_int
:
1056 case DT_elt_one_int
:
1057 case DT_elt_zero_wide
:
1058 return d1
->u
.intval
== d2
->u
.intval
;
1065 /* If either has a predicate that we know something about, set
1066 things up so that D1 is the one that always has a known
1067 predicate. Then see if they have any codes in common. */
1069 if (d1
->type
== DT_pred
|| d2
->type
== DT_pred
)
1071 if (d2
->type
== DT_pred
)
1073 struct decision_test
*tmp
;
1074 tmp
= d1
, d1
= d2
, d2
= tmp
;
1077 /* If D2 tests a mode, see if it matches D1. */
1078 if (d1
->u
.pred
.mode
!= VOIDmode
)
1080 if (d2
->type
== DT_mode
)
1082 if (d1
->u
.pred
.mode
!= d2
->u
.mode
1083 /* The mode of an address_operand predicate is the
1084 mode of the memory, not the operand. It can only
1085 be used for testing the predicate, so we must
1087 && strcmp (d1
->u
.pred
.name
, "address_operand") != 0)
1090 /* Don't check two predicate modes here, because if both predicates
1091 accept CONST_INT, then both can still be true even if the modes
1092 are different. If they don't accept CONST_INT, there will be a
1093 separate DT_mode that will make maybe_both_true_1 return 0. */
1096 if (d1
->u
.pred
.index
>= 0)
1098 /* If D2 tests a code, see if it is in the list of valid
1099 codes for D1's predicate. */
1100 if (d2
->type
== DT_code
)
1102 const RTX_CODE
*c
= &preds
[d1
->u
.pred
.index
].codes
[0];
1105 if (*c
== d2
->u
.code
)
1113 /* Otherwise see if the predicates have any codes in common. */
1114 else if (d2
->type
== DT_pred
&& d2
->u
.pred
.index
>= 0)
1116 const RTX_CODE
*c1
= &preds
[d1
->u
.pred
.index
].codes
[0];
1119 while (*c1
!= 0 && !common
)
1121 const RTX_CODE
*c2
= &preds
[d2
->u
.pred
.index
].codes
[0];
1122 while (*c2
!= 0 && !common
)
1124 common
= (*c1
== *c2
);
1136 /* Tests vs veclen may be known when strict equality is involved. */
1137 if (d1
->type
== DT_veclen
&& d2
->type
== DT_veclen_ge
)
1138 return d1
->u
.veclen
>= d2
->u
.veclen
;
1139 if (d1
->type
== DT_veclen_ge
&& d2
->type
== DT_veclen
)
1140 return d2
->u
.veclen
>= d1
->u
.veclen
;
1145 /* A subroutine of maybe_both_true; examines all the tests for a given node.
1146 Returns > 0 for "definitely both true" and < 0 for "maybe both true". */
1149 maybe_both_true_1 (d1
, d2
)
1150 struct decision_test
*d1
, *d2
;
1152 struct decision_test
*t1
, *t2
;
1154 /* A match_operand with no predicate can match anything. Recognize
1155 this by the existance of a lone DT_accept_op test. */
1156 if (d1
->type
== DT_accept_op
|| d2
->type
== DT_accept_op
)
1159 /* Eliminate pairs of tests while they can exactly match. */
1160 while (d1
&& d2
&& d1
->type
== d2
->type
)
1162 if (maybe_both_true_2 (d1
, d2
) == 0)
1164 d1
= d1
->next
, d2
= d2
->next
;
1167 /* After that, consider all pairs. */
1168 for (t1
= d1
; t1
; t1
= t1
->next
)
1169 for (t2
= d2
; t2
; t2
= t2
->next
)
1170 if (maybe_both_true_2 (t1
, t2
) == 0)
1176 /* Return 0 if we can prove that there is no RTL that can match both
1177 D1 and D2. Otherwise, return 1 (it may be that there is an RTL that
1178 can match both or just that we couldn't prove there wasn't such an RTL).
1180 TOPLEVEL is non-zero if we are to only look at the top level and not
1181 recursively descend. */
1184 maybe_both_true (d1
, d2
, toplevel
)
1185 struct decision
*d1
, *d2
;
1188 struct decision
*p1
, *p2
;
1191 /* Don't compare strings on the different positions in insn. Doing so
1192 is incorrect and results in false matches from constructs like
1194 [(set (subreg:HI (match_operand:SI "register_operand" "r") 0)
1195 (subreg:HI (match_operand:SI "register_operand" "r") 0))]
1197 [(set (match_operand:HI "register_operand" "r")
1198 (match_operand:HI "register_operand" "r"))]
1200 If we are presented with such, we are recursing through the remainder
1201 of a node's success nodes (from the loop at the end of this function).
1202 Skip forward until we come to a position that matches.
1204 Due to the way position strings are constructed, we know that iterating
1205 forward from the lexically lower position (e.g. "00") will run into
1206 the lexically higher position (e.g. "1") and not the other way around.
1207 This saves a bit of effort. */
1209 cmp
= strcmp (d1
->position
, d2
->position
);
1215 /* If the d2->position was lexically lower, swap. */
1217 p1
= d1
, d1
= d2
, d2
= p1
;
1219 if (d1
->success
.first
== 0)
1221 for (p1
= d1
->success
.first
; p1
; p1
= p1
->next
)
1222 if (maybe_both_true (p1
, d2
, 0))
1228 /* Test the current level. */
1229 cmp
= maybe_both_true_1 (d1
->tests
, d2
->tests
);
1233 /* We can't prove that D1 and D2 cannot both be true. If we are only
1234 to check the top level, return 1. Otherwise, see if we can prove
1235 that all choices in both successors are mutually exclusive. If
1236 either does not have any successors, we can't prove they can't both
1239 if (toplevel
|| d1
->success
.first
== 0 || d2
->success
.first
== 0)
1242 for (p1
= d1
->success
.first
; p1
; p1
= p1
->next
)
1243 for (p2
= d2
->success
.first
; p2
; p2
= p2
->next
)
1244 if (maybe_both_true (p1
, p2
, 0))
1250 /* A subroutine of nodes_identical. Examine two tests for equivalence. */
1253 nodes_identical_1 (d1
, d2
)
1254 struct decision_test
*d1
, *d2
;
1259 return d1
->u
.mode
== d2
->u
.mode
;
1262 return d1
->u
.code
== d2
->u
.code
;
1265 return (d1
->u
.pred
.mode
== d2
->u
.pred
.mode
1266 && strcmp (d1
->u
.pred
.name
, d2
->u
.pred
.name
) == 0);
1269 return strcmp (d1
->u
.c_test
, d2
->u
.c_test
) == 0;
1273 return d1
->u
.veclen
== d2
->u
.veclen
;
1276 return d1
->u
.dup
== d2
->u
.dup
;
1278 case DT_elt_zero_int
:
1279 case DT_elt_one_int
:
1280 case DT_elt_zero_wide
:
1281 return d1
->u
.intval
== d2
->u
.intval
;
1284 return d1
->u
.opno
== d2
->u
.opno
;
1286 case DT_accept_insn
:
1287 /* Differences will be handled in merge_accept_insn. */
1295 /* True iff the two nodes are identical (on one level only). Due
1296 to the way these lists are constructed, we shouldn't have to
1297 consider different orderings on the tests. */
1300 nodes_identical (d1
, d2
)
1301 struct decision
*d1
, *d2
;
1303 struct decision_test
*t1
, *t2
;
1305 for (t1
= d1
->tests
, t2
= d2
->tests
; t1
&& t2
; t1
= t1
->next
, t2
= t2
->next
)
1307 if (t1
->type
!= t2
->type
)
1309 if (! nodes_identical_1 (t1
, t2
))
1313 /* For success, they should now both be null. */
1317 /* Check that their subnodes are at the same position, as any one set
1318 of sibling decisions must be at the same position. Allowing this
1319 requires complications to find_afterward and when change_state is
1321 if (d1
->success
.first
1322 && d2
->success
.first
1323 && strcmp (d1
->success
.first
->position
, d2
->success
.first
->position
))
1329 /* A subroutine of merge_trees; given two nodes that have been declared
1330 identical, cope with two insn accept states. If they differ in the
1331 number of clobbers, then the conflict was created by make_insn_sequence
1332 and we can drop the with-clobbers version on the floor. If both
1333 nodes have no additional clobbers, we have found an ambiguity in the
1334 source machine description. */
1337 merge_accept_insn (oldd
, addd
)
1338 struct decision
*oldd
, *addd
;
1340 struct decision_test
*old
, *add
;
1342 for (old
= oldd
->tests
; old
; old
= old
->next
)
1343 if (old
->type
== DT_accept_insn
)
1348 for (add
= addd
->tests
; add
; add
= add
->next
)
1349 if (add
->type
== DT_accept_insn
)
1354 /* If one node is for a normal insn and the second is for the base
1355 insn with clobbers stripped off, the second node should be ignored. */
1357 if (old
->u
.insn
.num_clobbers_to_add
== 0
1358 && add
->u
.insn
.num_clobbers_to_add
> 0)
1360 /* Nothing to do here. */
1362 else if (old
->u
.insn
.num_clobbers_to_add
> 0
1363 && add
->u
.insn
.num_clobbers_to_add
== 0)
1365 /* In this case, replace OLD with ADD. */
1366 old
->u
.insn
= add
->u
.insn
;
1370 message_with_line (add
->u
.insn
.lineno
, "`%s' matches `%s'",
1371 get_insn_name (add
->u
.insn
.code_number
),
1372 get_insn_name (old
->u
.insn
.code_number
));
1373 message_with_line (old
->u
.insn
.lineno
, "previous definition of `%s'",
1374 get_insn_name (old
->u
.insn
.code_number
));
1379 /* Merge two decision trees OLDH and ADDH, modifying OLDH destructively. */
1382 merge_trees (oldh
, addh
)
1383 struct decision_head
*oldh
, *addh
;
1385 struct decision
*next
, *add
;
1387 if (addh
->first
== 0)
1389 if (oldh
->first
== 0)
1395 /* Trying to merge bits at different positions isn't possible. */
1396 if (strcmp (oldh
->first
->position
, addh
->first
->position
))
1399 for (add
= addh
->first
; add
; add
= next
)
1401 struct decision
*old
, *insert_before
= NULL
;
1405 /* The semantics of pattern matching state that the tests are
1406 done in the order given in the MD file so that if an insn
1407 matches two patterns, the first one will be used. However,
1408 in practice, most, if not all, patterns are unambiguous so
1409 that their order is independent. In that case, we can merge
1410 identical tests and group all similar modes and codes together.
1412 Scan starting from the end of OLDH until we reach a point
1413 where we reach the head of the list or where we pass a
1414 pattern that could also be true if NEW is true. If we find
1415 an identical pattern, we can merge them. Also, record the
1416 last node that tests the same code and mode and the last one
1417 that tests just the same mode.
1419 If we have no match, place NEW after the closest match we found. */
1421 for (old
= oldh
->last
; old
; old
= old
->prev
)
1423 if (nodes_identical (old
, add
))
1425 merge_accept_insn (old
, add
);
1426 merge_trees (&old
->success
, &add
->success
);
1430 if (maybe_both_true (old
, add
, 0))
1433 /* Insert the nodes in DT test type order, which is roughly
1434 how expensive/important the test is. Given that the tests
1435 are also ordered within the list, examining the first is
1437 if ((int) add
->tests
->type
< (int) old
->tests
->type
)
1438 insert_before
= old
;
1441 if (insert_before
== NULL
)
1444 add
->prev
= oldh
->last
;
1445 oldh
->last
->next
= add
;
1450 if ((add
->prev
= insert_before
->prev
) != NULL
)
1451 add
->prev
->next
= add
;
1454 add
->next
= insert_before
;
1455 insert_before
->prev
= add
;
1462 /* Walk the tree looking for sub-nodes that perform common tests.
1463 Factor out the common test into a new node. This enables us
1464 (depending on the test type) to emit switch statements later. */
1468 struct decision_head
*head
;
1470 struct decision
*first
, *next
;
1472 for (first
= head
->first
; first
&& first
->next
; first
= next
)
1474 enum decision_type type
;
1475 struct decision
*new, *old_last
;
1477 type
= first
->tests
->type
;
1480 /* Want at least two compatible sequential nodes. */
1481 if (next
->tests
->type
!= type
)
1484 /* Don't want all node types, just those we can turn into
1485 switch statements. */
1488 && type
!= DT_veclen
1489 && type
!= DT_elt_zero_int
1490 && type
!= DT_elt_one_int
1491 && type
!= DT_elt_zero_wide
)
1494 /* If we'd been performing more than one test, create a new node
1495 below our first test. */
1496 if (first
->tests
->next
!= NULL
)
1498 new = new_decision (first
->position
, &first
->success
);
1499 new->tests
= first
->tests
->next
;
1500 first
->tests
->next
= NULL
;
1503 /* Crop the node tree off after our first test. */
1505 old_last
= head
->last
;
1508 /* For each compatible test, adjust to perform only one test in
1509 the top level node, then merge the node back into the tree. */
1512 struct decision_head h
;
1514 if (next
->tests
->next
!= NULL
)
1516 new = new_decision (next
->position
, &next
->success
);
1517 new->tests
= next
->tests
->next
;
1518 next
->tests
->next
= NULL
;
1523 h
.first
= h
.last
= new;
1525 merge_trees (head
, &h
);
1527 while (next
&& next
->tests
->type
== type
);
1529 /* After we run out of compatible tests, graft the remaining nodes
1530 back onto the tree. */
1533 next
->prev
= head
->last
;
1534 head
->last
->next
= next
;
1535 head
->last
= old_last
;
1540 for (first
= head
->first
; first
; first
= first
->next
)
1541 factor_tests (&first
->success
);
1544 /* After factoring, try to simplify the tests on any one node.
1545 Tests that are useful for switch statements are recognizable
1546 by having only a single test on a node -- we'll be manipulating
1547 nodes with multiple tests:
1549 If we have mode tests or code tests that are redundant with
1550 predicates, remove them. */
1553 simplify_tests (head
)
1554 struct decision_head
*head
;
1556 struct decision
*tree
;
1558 for (tree
= head
->first
; tree
; tree
= tree
->next
)
1560 struct decision_test
*a
, *b
;
1567 /* Find a predicate node. */
1568 while (b
&& b
->type
!= DT_pred
)
1572 /* Due to how these tests are constructed, we don't even need
1573 to check that the mode and code are compatible -- they were
1574 generated from the predicate in the first place. */
1575 while (a
->type
== DT_mode
|| a
->type
== DT_code
)
1582 for (tree
= head
->first
; tree
; tree
= tree
->next
)
1583 simplify_tests (&tree
->success
);
1586 /* Count the number of subnodes of HEAD. If the number is high enough,
1587 make the first node in HEAD start a separate subroutine in the C code
1588 that is generated. */
1591 break_out_subroutines (head
, initial
)
1592 struct decision_head
*head
;
1596 struct decision
*sub
;
1598 for (sub
= head
->first
; sub
; sub
= sub
->next
)
1599 size
+= 1 + break_out_subroutines (&sub
->success
, 0);
1601 if (size
> SUBROUTINE_THRESHOLD
&& ! initial
)
1603 head
->first
->subroutine_number
= ++next_subroutine_number
;
1609 /* For each node p, find the next alternative that might be true
1613 find_afterward (head
, real_afterward
)
1614 struct decision_head
*head
;
1615 struct decision
*real_afterward
;
1617 struct decision
*p
, *q
, *afterward
;
1619 /* We can't propogate alternatives across subroutine boundaries.
1620 This is not incorrect, merely a minor optimization loss. */
1623 afterward
= (p
->subroutine_number
> 0 ? NULL
: real_afterward
);
1625 for ( ; p
; p
= p
->next
)
1627 /* Find the next node that might be true if this one fails. */
1628 for (q
= p
->next
; q
; q
= q
->next
)
1629 if (maybe_both_true (p
, q
, 1))
1632 /* If we reached the end of the list without finding one,
1633 use the incoming afterward position. */
1642 for (p
= head
->first
; p
; p
= p
->next
)
1643 if (p
->success
.first
)
1644 find_afterward (&p
->success
, p
->afterward
);
1646 /* When we are generating a subroutine, record the real afterward
1647 position in the first node where write_tree can find it, and we
1648 can do the right thing at the subroutine call site. */
1650 if (p
->subroutine_number
> 0)
1651 p
->afterward
= real_afterward
;
1654 /* Assuming that the state of argument is denoted by OLDPOS, take whatever
1655 actions are necessary to move to NEWPOS. If we fail to move to the
1656 new state, branch to node AFTERWARD if non-zero, otherwise return.
1658 Failure to move to the new state can only occur if we are trying to
1659 match multiple insns and we try to step past the end of the stream. */
1662 change_state (oldpos
, newpos
, afterward
, indent
)
1665 struct decision
*afterward
;
1668 int odepth
= strlen (oldpos
);
1669 int ndepth
= strlen (newpos
);
1671 int old_has_insn
, new_has_insn
;
1673 /* Pop up as many levels as necessary. */
1674 for (depth
= odepth
; strncmp (oldpos
, newpos
, depth
) != 0; --depth
)
1677 /* Hunt for the last [A-Z] in both strings. */
1678 for (old_has_insn
= odepth
- 1; old_has_insn
>= 0; --old_has_insn
)
1679 if (oldpos
[old_has_insn
] >= 'A' && oldpos
[old_has_insn
] <= 'Z')
1681 for (new_has_insn
= ndepth
- 1; new_has_insn
>= 0; --new_has_insn
)
1682 if (newpos
[new_has_insn
] >= 'A' && newpos
[new_has_insn
] <= 'Z')
1685 /* Go down to desired level. */
1686 while (depth
< ndepth
)
1688 /* It's a different insn from the first one. */
1689 if (newpos
[depth
] >= 'A' && newpos
[depth
] <= 'Z')
1691 /* We can only fail if we're moving down the tree. */
1692 if (old_has_insn
>= 0 && oldpos
[old_has_insn
] >= newpos
[depth
])
1694 printf ("%stem = peep2_next_insn (%d);\n",
1695 indent
, newpos
[depth
] - 'A');
1699 printf ("%stem = peep2_next_insn (%d);\n",
1700 indent
, newpos
[depth
] - 'A');
1701 printf ("%sif (tem == NULL_RTX)\n", indent
);
1703 printf ("%s goto L%d;\n", indent
, afterward
->number
);
1705 printf ("%s goto ret0;\n", indent
);
1707 printf ("%sx%d = PATTERN (tem);\n", indent
, depth
+ 1);
1709 else if (newpos
[depth
] >= 'a' && newpos
[depth
] <= 'z')
1710 printf ("%sx%d = XVECEXP (x%d, 0, %d);\n",
1711 indent
, depth
+ 1, depth
, newpos
[depth
] - 'a');
1713 printf ("%sx%d = XEXP (x%d, %c);\n",
1714 indent
, depth
+ 1, depth
, newpos
[depth
]);
1719 /* Print the enumerator constant for CODE -- the upcase version of
1726 register const char *p
;
1727 for (p
= GET_RTX_NAME (code
); *p
; p
++)
1728 putchar (TOUPPER (*p
));
1731 /* Emit code to cross an afterward link -- change state and branch. */
1734 write_afterward (start
, afterward
, indent
)
1735 struct decision
*start
;
1736 struct decision
*afterward
;
1739 if (!afterward
|| start
->subroutine_number
> 0)
1740 printf("%sgoto ret0;\n", indent
);
1743 change_state (start
->position
, afterward
->position
, NULL
, indent
);
1744 printf ("%sgoto L%d;\n", indent
, afterward
->number
);
1748 /* Emit a switch statement, if possible, for an initial sequence of
1749 nodes at START. Return the first node yet untested. */
1751 static struct decision
*
1752 write_switch (start
, depth
)
1753 struct decision
*start
;
1756 struct decision
*p
= start
;
1757 enum decision_type type
= p
->tests
->type
;
1758 struct decision
*needs_label
= NULL
;
1760 /* If we have two or more nodes in sequence that test the same one
1761 thing, we may be able to use a switch statement. */
1765 || p
->next
->tests
->type
!= type
1766 || p
->next
->tests
->next
1767 || nodes_identical_1 (p
->tests
, p
->next
->tests
))
1770 /* DT_code is special in that we can do interesting things with
1771 known predicates at the same time. */
1772 if (type
== DT_code
)
1774 char codemap
[NUM_RTX_CODE
];
1775 struct decision
*ret
;
1778 memset (codemap
, 0, sizeof(codemap
));
1780 printf (" switch (GET_CODE (x%d))\n {\n", depth
);
1781 code
= p
->tests
->u
.code
;
1784 if (p
!= start
&& p
->need_label
&& needs_label
== NULL
)
1789 printf (":\n goto L%d;\n", p
->success
.first
->number
);
1790 p
->success
.first
->need_label
= 1;
1797 && p
->tests
->type
== DT_code
1798 && ! codemap
[code
= p
->tests
->u
.code
]);
1800 /* If P is testing a predicate that we know about and we haven't
1801 seen any of the codes that are valid for the predicate, we can
1802 write a series of "case" statement, one for each possible code.
1803 Since we are already in a switch, these redundant tests are very
1804 cheap and will reduce the number of predicates called. */
1806 /* Note that while we write out cases for these predicates here,
1807 we don't actually write the test here, as it gets kinda messy.
1808 It is trivial to leave this to later by telling our caller that
1809 we only processed the CODE tests. */
1810 if (needs_label
!= NULL
)
1815 while (p
&& p
->tests
->type
== DT_pred
1816 && p
->tests
->u
.pred
.index
>= 0)
1820 for (c
= &preds
[p
->tests
->u
.pred
.index
].codes
[0]; *c
; ++c
)
1821 if (codemap
[(int) *c
] != 0)
1824 for (c
= &preds
[p
->tests
->u
.pred
.index
].codes
[0]; *c
; ++c
)
1829 codemap
[(int) *c
] = 1;
1832 printf (" goto L%d;\n", p
->number
);
1838 /* Make the default case skip the predicates we managed to match. */
1840 printf (" default:\n");
1845 printf (" goto L%d;\n", p
->number
);
1849 write_afterward (start
, start
->afterward
, " ");
1852 printf (" break;\n");
1857 else if (type
== DT_mode
1858 || type
== DT_veclen
1859 || type
== DT_elt_zero_int
1860 || type
== DT_elt_one_int
1861 || type
== DT_elt_zero_wide
)
1863 printf (" switch (");
1867 printf ("GET_MODE (x%d)", depth
);
1870 printf ("XVECLEN (x%d, 0)", depth
);
1872 case DT_elt_zero_int
:
1873 printf ("XINT (x%d, 0)", depth
);
1875 case DT_elt_one_int
:
1876 printf ("XINT (x%d, 1)", depth
);
1878 case DT_elt_zero_wide
:
1879 /* Convert result of XWINT to int for portability since some C
1880 compilers won't do it and some will. */
1881 printf ("(int) XWINT (x%d, 0)", depth
);
1890 /* Merge trees will not unify identical nodes if their
1891 sub-nodes are at different levels. Thus we must check
1892 for duplicate cases. */
1894 for (q
= start
; q
!= p
; q
= q
->next
)
1895 if (nodes_identical_1 (p
->tests
, q
->tests
))
1898 if (p
!= start
&& p
->need_label
&& needs_label
== NULL
)
1905 printf ("%smode", GET_MODE_NAME (p
->tests
->u
.mode
));
1908 printf ("%d", p
->tests
->u
.veclen
);
1910 case DT_elt_zero_int
:
1911 case DT_elt_one_int
:
1912 case DT_elt_zero_wide
:
1913 printf (HOST_WIDE_INT_PRINT_DEC
, p
->tests
->u
.intval
);
1918 printf (":\n goto L%d;\n", p
->success
.first
->number
);
1919 p
->success
.first
->need_label
= 1;
1923 while (p
&& p
->tests
->type
== type
&& !p
->tests
->next
);
1926 printf (" default:\n break;\n }\n");
1928 return needs_label
!= NULL
? needs_label
: p
;
1932 /* None of the other tests are ameanable. */
1937 /* Emit code for one test. */
1940 write_cond (p
, depth
, subroutine_type
)
1941 struct decision_test
*p
;
1943 enum routine_type subroutine_type
;
1948 printf ("GET_MODE (x%d) == %smode", depth
, GET_MODE_NAME (p
->u
.mode
));
1952 printf ("GET_CODE (x%d) == ", depth
);
1953 print_code (p
->u
.code
);
1957 printf ("XVECLEN (x%d, 0) == %d", depth
, p
->u
.veclen
);
1960 case DT_elt_zero_int
:
1961 printf ("XINT (x%d, 0) == %d", depth
, (int) p
->u
.intval
);
1964 case DT_elt_one_int
:
1965 printf ("XINT (x%d, 1) == %d", depth
, (int) p
->u
.intval
);
1968 case DT_elt_zero_wide
:
1969 printf ("XWINT (x%d, 0) == ", depth
);
1970 printf (HOST_WIDE_INT_PRINT_DEC
, p
->u
.intval
);
1974 printf ("XVECLEN (x%d, 0) >= %d", depth
, p
->u
.veclen
);
1978 printf ("rtx_equal_p (x%d, operands[%d])", depth
, p
->u
.dup
);
1982 printf ("%s (x%d, %smode)", p
->u
.pred
.name
, depth
,
1983 GET_MODE_NAME (p
->u
.pred
.mode
));
1987 printf ("(%s)", p
->u
.c_test
);
1990 case DT_accept_insn
:
1991 switch (subroutine_type
)
1994 if (p
->u
.insn
.num_clobbers_to_add
== 0)
1996 printf ("pnum_clobbers != NULL");
2009 /* Emit code for one action. The previous tests have succeeded;
2010 TEST is the last of the chain. In the normal case we simply
2011 perform a state change. For the `accept' tests we must do more work. */
2014 write_action (p
, test
, depth
, uncond
, success
, subroutine_type
)
2016 struct decision_test
*test
;
2018 struct decision
*success
;
2019 enum routine_type subroutine_type
;
2026 else if (test
->type
== DT_accept_op
|| test
->type
== DT_accept_insn
)
2028 fputs (" {\n", stdout
);
2035 if (test
->type
== DT_accept_op
)
2037 printf("%soperands[%d] = x%d;\n", indent
, test
->u
.opno
, depth
);
2039 /* Only allow DT_accept_insn to follow. */
2043 if (test
->type
!= DT_accept_insn
)
2048 /* Sanity check that we're now at the end of the list of tests. */
2052 if (test
->type
== DT_accept_insn
)
2054 switch (subroutine_type
)
2057 if (test
->u
.insn
.num_clobbers_to_add
!= 0)
2058 printf ("%s*pnum_clobbers = %d;\n",
2059 indent
, test
->u
.insn
.num_clobbers_to_add
);
2060 printf ("%sreturn %d;\n", indent
, test
->u
.insn
.code_number
);
2064 printf ("%sreturn gen_split_%d (operands);\n",
2065 indent
, test
->u
.insn
.code_number
);
2070 int match_len
= 0, i
;
2072 for (i
= strlen (p
->position
) - 1; i
>= 0; --i
)
2073 if (p
->position
[i
] >= 'A' && p
->position
[i
] <= 'Z')
2075 match_len
= p
->position
[i
] - 'A';
2078 printf ("%s*_pmatch_len = %d;\n", indent
, match_len
);
2079 printf ("%stem = gen_peephole2_%d (insn, operands);\n",
2080 indent
, test
->u
.insn
.code_number
);
2081 printf ("%sif (tem != 0)\n%s return tem;\n", indent
, indent
);
2091 printf("%sgoto L%d;\n", indent
, success
->number
);
2092 success
->need_label
= 1;
2096 fputs (" }\n", stdout
);
2099 /* Return 1 if the test is always true and has no fallthru path. Return -1
2100 if the test does have a fallthru path, but requires that the condition be
2101 terminated. Otherwise return 0 for a normal test. */
2102 /* ??? is_unconditional is a stupid name for a tri-state function. */
2105 is_unconditional (t
, subroutine_type
)
2106 struct decision_test
*t
;
2107 enum routine_type subroutine_type
;
2109 if (t
->type
== DT_accept_op
)
2112 if (t
->type
== DT_accept_insn
)
2114 switch (subroutine_type
)
2117 return (t
->u
.insn
.num_clobbers_to_add
== 0);
2130 /* Emit code for one node -- the conditional and the accompanying action.
2131 Return true if there is no fallthru path. */
2134 write_node (p
, depth
, subroutine_type
)
2137 enum routine_type subroutine_type
;
2139 struct decision_test
*test
, *last_test
;
2142 last_test
= test
= p
->tests
;
2143 uncond
= is_unconditional (test
, subroutine_type
);
2147 write_cond (test
, depth
, subroutine_type
);
2149 while ((test
= test
->next
) != NULL
)
2154 uncond2
= is_unconditional (test
, subroutine_type
);
2159 write_cond (test
, depth
, subroutine_type
);
2165 write_action (p
, last_test
, depth
, uncond
, p
->success
.first
, subroutine_type
);
2170 /* Emit code for all of the sibling nodes of HEAD. */
2173 write_tree_1 (head
, depth
, subroutine_type
)
2174 struct decision_head
*head
;
2176 enum routine_type subroutine_type
;
2178 struct decision
*p
, *next
;
2181 for (p
= head
->first
; p
; p
= next
)
2183 /* The label for the first element was printed in write_tree. */
2184 if (p
!= head
->first
&& p
->need_label
)
2185 OUTPUT_LABEL (" ", p
->number
);
2187 /* Attempt to write a switch statement for a whole sequence. */
2188 next
= write_switch (p
, depth
);
2193 /* Failed -- fall back and write one node. */
2194 uncond
= write_node (p
, depth
, subroutine_type
);
2199 /* Finished with this chain. Close a fallthru path by branching
2200 to the afterward node. */
2202 write_afterward (head
->last
, head
->last
->afterward
, " ");
2205 /* Write out the decision tree starting at HEAD. PREVPOS is the
2206 position at the node that branched to this node. */
2209 write_tree (head
, prevpos
, type
, initial
)
2210 struct decision_head
*head
;
2211 const char *prevpos
;
2212 enum routine_type type
;
2215 register struct decision
*p
= head
->first
;
2219 OUTPUT_LABEL (" ", p
->number
);
2221 if (! initial
&& p
->subroutine_number
> 0)
2223 static const char * const name_prefix
[] = {
2224 "recog", "split", "peephole2"
2227 static const char * const call_suffix
[] = {
2228 ", pnum_clobbers", "", ", _pmatch_len"
2231 /* This node has been broken out into a separate subroutine.
2232 Call it, test the result, and branch accordingly. */
2236 printf (" tem = %s_%d (x0, insn%s);\n",
2237 name_prefix
[type
], p
->subroutine_number
, call_suffix
[type
]);
2238 if (IS_SPLIT (type
))
2239 printf (" if (tem != 0)\n return tem;\n");
2241 printf (" if (tem >= 0)\n return tem;\n");
2243 change_state (p
->position
, p
->afterward
->position
, NULL
, " ");
2244 printf (" goto L%d;\n", p
->afterward
->number
);
2248 printf (" return %s_%d (x0, insn%s);\n",
2249 name_prefix
[type
], p
->subroutine_number
, call_suffix
[type
]);
2254 int depth
= strlen (p
->position
);
2256 change_state (prevpos
, p
->position
, head
->last
->afterward
, " ");
2257 write_tree_1 (head
, depth
, type
);
2259 for (p
= head
->first
; p
; p
= p
->next
)
2260 if (p
->success
.first
)
2261 write_tree (&p
->success
, p
->position
, type
, 0);
2265 /* Write out a subroutine of type TYPE to do comparisons starting at
2269 write_subroutine (head
, type
)
2270 struct decision_head
*head
;
2271 enum routine_type type
;
2273 int subfunction
= head
->first
? head
->first
->subroutine_number
: 0;
2278 s_or_e
= subfunction
? "static " : "";
2281 sprintf (extension
, "_%d", subfunction
);
2282 else if (type
== RECOG
)
2283 extension
[0] = '\0';
2285 strcpy (extension
, "_insns");
2290 printf ("%sint recog%s PARAMS ((rtx, rtx, int *));\n", s_or_e
, extension
);
2292 recog%s (x0, insn, pnum_clobbers)\n\
2294 rtx insn ATTRIBUTE_UNUSED;\n\
2295 int *pnum_clobbers ATTRIBUTE_UNUSED;\n", s_or_e
, extension
);
2298 printf ("%srtx split%s PARAMS ((rtx, rtx));\n", s_or_e
, extension
);
2300 split%s (x0, insn)\n\
2302 rtx insn ATTRIBUTE_UNUSED;\n", s_or_e
, extension
);
2305 printf ("%srtx peephole2%s PARAMS ((rtx, rtx, int *));\n",
2308 peephole2%s (x0, insn, _pmatch_len)\n\
2310 rtx insn ATTRIBUTE_UNUSED;\n\
2311 int *_pmatch_len ATTRIBUTE_UNUSED;\n", s_or_e
, extension
);
2315 printf ("{\n register rtx * const operands ATTRIBUTE_UNUSED = &recog_data.operand[0];\n");
2316 for (i
= 1; i
<= max_depth
; i
++)
2317 printf (" register rtx x%d ATTRIBUTE_UNUSED;\n", i
);
2319 printf (" %s tem ATTRIBUTE_UNUSED;\n", IS_SPLIT (type
) ? "rtx" : "int");
2322 printf (" recog_data.insn = NULL_RTX;\n");
2325 write_tree (head
, "", type
, 1);
2327 printf (" goto ret0;\n");
2329 printf (" ret0:\n return %d;\n}\n\n", IS_SPLIT (type
) ? 0 : -1);
2332 /* In break_out_subroutines, we discovered the boundaries for the
2333 subroutines, but did not write them out. Do so now. */
2336 write_subroutines (head
, type
)
2337 struct decision_head
*head
;
2338 enum routine_type type
;
2342 for (p
= head
->first
; p
; p
= p
->next
)
2343 if (p
->success
.first
)
2344 write_subroutines (&p
->success
, type
);
2346 if (head
->first
->subroutine_number
> 0)
2347 write_subroutine (head
, type
);
2350 /* Begin the output file. */
2356 /* Generated automatically by the program `genrecog' from the target\n\
2357 machine description file. */\n\
2359 #include \"config.h\"\n\
2360 #include \"system.h\"\n\
2361 #include \"rtl.h\"\n\
2362 #include \"tm_p.h\"\n\
2363 #include \"function.h\"\n\
2364 #include \"insn-config.h\"\n\
2365 #include \"recog.h\"\n\
2366 #include \"real.h\"\n\
2367 #include \"output.h\"\n\
2368 #include \"flags.h\"\n\
2369 #include \"hard-reg-set.h\"\n\
2370 #include \"resource.h\"\n\
2371 #include \"toplev.h\"\n\
2375 /* `recog' contains a decision tree that recognizes whether the rtx\n\
2376 X0 is a valid instruction.\n\
2378 recog returns -1 if the rtx is not valid. If the rtx is valid, recog\n\
2379 returns a nonnegative number which is the insn code number for the\n\
2380 pattern that matched. This is the same as the order in the machine\n\
2381 description of the entry that matched. This number can be used as an\n\
2382 index into `insn_data' and other tables.\n");
2384 The third argument to recog is an optional pointer to an int. If\n\
2385 present, recog will accept a pattern if it matches except for missing\n\
2386 CLOBBER expressions at the end. In that case, the value pointed to by\n\
2387 the optional pointer will be set to the number of CLOBBERs that need\n\
2388 to be added (it should be initialized to zero by the caller). If it");
2390 is set nonzero, the caller should allocate a PARALLEL of the\n\
2391 appropriate size, copy the initial entries, and call add_clobbers\n\
2392 (found in insn-emit.c) to fill in the CLOBBERs.\n\
2396 The function split_insns returns 0 if the rtl could not\n\
2397 be split or the split rtl in a SEQUENCE if it can be.\n\
2399 The function peephole2_insns returns 0 if the rtl could not\n\
2400 be matched. If there was a match, the new rtl is returned in a SEQUENCE,\n\
2401 and LAST_INSN will point to the last recognized insn in the old sequence.\n\
2406 /* Construct and return a sequence of decisions
2407 that will recognize INSN.
2409 TYPE says what type of routine we are recognizing (RECOG or SPLIT). */
2411 static struct decision_head
2412 make_insn_sequence (insn
, type
)
2414 enum routine_type type
;
2417 const char *c_test
= XSTR (insn
, type
== RECOG
? 2 : 1);
2418 struct decision
*last
;
2419 struct decision_test
*test
, **place
;
2420 struct decision_head head
;
2423 record_insn_name (next_insn_code
, (type
== RECOG
? XSTR (insn
, 0) : NULL
));
2425 c_test_pos
[0] = '\0';
2426 if (type
== PEEPHOLE2
)
2430 /* peephole2 gets special treatment:
2431 - X always gets an outer parallel even if it's only one entry
2432 - we remove all traces of outer-level match_scratch and match_dup
2433 expressions here. */
2434 x
= rtx_alloc (PARALLEL
);
2435 PUT_MODE (x
, VOIDmode
);
2436 XVEC (x
, 0) = rtvec_alloc (XVECLEN (insn
, 0));
2437 for (i
= j
= 0; i
< XVECLEN (insn
, 0); i
++)
2439 rtx tmp
= XVECEXP (insn
, 0, i
);
2440 if (GET_CODE (tmp
) != MATCH_SCRATCH
&& GET_CODE (tmp
) != MATCH_DUP
)
2442 XVECEXP (x
, 0, j
) = tmp
;
2448 c_test_pos
[0] = 'A' + j
- 1;
2449 c_test_pos
[1] = '\0';
2451 else if (XVECLEN (insn
, type
== RECOG
) == 1)
2452 x
= XVECEXP (insn
, type
== RECOG
, 0);
2455 x
= rtx_alloc (PARALLEL
);
2456 XVEC (x
, 0) = XVEC (insn
, type
== RECOG
);
2457 PUT_MODE (x
, VOIDmode
);
2460 validate_pattern (x
, insn
, NULL_RTX
, 0);
2462 memset(&head
, 0, sizeof(head
));
2463 last
= add_to_sequence (x
, &head
, "", type
, 1);
2465 /* Find the end of the test chain on the last node. */
2466 for (test
= last
->tests
; test
->next
; test
= test
->next
)
2468 place
= &test
->next
;
2472 /* Need a new node if we have another test to add. */
2473 if (test
->type
== DT_accept_op
)
2475 last
= new_decision (c_test_pos
, &last
->success
);
2476 place
= &last
->tests
;
2478 test
= new_decision_test (DT_c_test
, &place
);
2479 test
->u
.c_test
= c_test
;
2482 test
= new_decision_test (DT_accept_insn
, &place
);
2483 test
->u
.insn
.code_number
= next_insn_code
;
2484 test
->u
.insn
.lineno
= pattern_lineno
;
2485 test
->u
.insn
.num_clobbers_to_add
= 0;
2490 /* If this is an DEFINE_INSN and X is a PARALLEL, see if it ends
2491 with a group of CLOBBERs of (hard) registers or MATCH_SCRATCHes.
2492 If so, set up to recognize the pattern without these CLOBBERs. */
2494 if (GET_CODE (x
) == PARALLEL
)
2498 /* Find the last non-clobber in the parallel. */
2499 for (i
= XVECLEN (x
, 0); i
> 0; i
--)
2501 rtx y
= XVECEXP (x
, 0, i
- 1);
2502 if (GET_CODE (y
) != CLOBBER
2503 || (GET_CODE (XEXP (y
, 0)) != REG
2504 && GET_CODE (XEXP (y
, 0)) != MATCH_SCRATCH
))
2508 if (i
!= XVECLEN (x
, 0))
2511 struct decision_head clobber_head
;
2513 /* Build a similar insn without the clobbers. */
2515 new = XVECEXP (x
, 0, 0);
2520 new = rtx_alloc (PARALLEL
);
2521 XVEC (new, 0) = rtvec_alloc (i
);
2522 for (j
= i
- 1; j
>= 0; j
--)
2523 XVECEXP (new, 0, j
) = XVECEXP (x
, 0, j
);
2527 memset (&clobber_head
, 0, sizeof(clobber_head
));
2528 last
= add_to_sequence (new, &clobber_head
, "", type
, 1);
2530 /* Find the end of the test chain on the last node. */
2531 for (test
= last
->tests
; test
->next
; test
= test
->next
)
2534 /* We definitely have a new test to add -- create a new
2536 place
= &test
->next
;
2537 if (test
->type
== DT_accept_op
)
2539 last
= new_decision ("", &last
->success
);
2540 place
= &last
->tests
;
2545 test
= new_decision_test (DT_c_test
, &place
);
2546 test
->u
.c_test
= c_test
;
2549 test
= new_decision_test (DT_accept_insn
, &place
);
2550 test
->u
.insn
.code_number
= next_insn_code
;
2551 test
->u
.insn
.lineno
= pattern_lineno
;
2552 test
->u
.insn
.num_clobbers_to_add
= XVECLEN (x
, 0) - i
;
2554 merge_trees (&head
, &clobber_head
);
2560 /* Define the subroutine we will call below and emit in genemit. */
2561 printf ("extern rtx gen_split_%d PARAMS ((rtx *));\n", next_insn_code
);
2565 /* Define the subroutine we will call below and emit in genemit. */
2566 printf ("extern rtx gen_peephole2_%d PARAMS ((rtx, rtx *));\n",
2575 process_tree (head
, subroutine_type
)
2576 struct decision_head
*head
;
2577 enum routine_type subroutine_type
;
2579 if (head
->first
== NULL
)
2581 /* We can elide peephole2_insns, but not recog or split_insns. */
2582 if (subroutine_type
== PEEPHOLE2
)
2587 factor_tests (head
);
2589 next_subroutine_number
= 0;
2590 break_out_subroutines (head
, 1);
2591 find_afterward (head
, NULL
);
2593 /* We run this after find_afterward, because find_afterward needs
2594 the redundant DT_mode tests on predicates to determine whether
2595 two tests can both be true or not. */
2596 simplify_tests(head
);
2598 write_subroutines (head
, subroutine_type
);
2601 write_subroutine (head
, subroutine_type
);
2604 extern int main
PARAMS ((int, char **));
2612 struct decision_head recog_tree
, split_tree
, peephole2_tree
, h
;
2614 progname
= "genrecog";
2616 memset (&recog_tree
, 0, sizeof recog_tree
);
2617 memset (&split_tree
, 0, sizeof split_tree
);
2618 memset (&peephole2_tree
, 0, sizeof peephole2_tree
);
2621 fatal ("No input file name.");
2623 if (init_md_reader (argv
[1]) != SUCCESS_EXIT_CODE
)
2624 return (FATAL_EXIT_CODE
);
2631 /* Read the machine description. */
2635 desc
= read_md_rtx (&pattern_lineno
, &next_insn_code
);
2639 if (GET_CODE (desc
) == DEFINE_INSN
)
2641 h
= make_insn_sequence (desc
, RECOG
);
2642 merge_trees (&recog_tree
, &h
);
2644 else if (GET_CODE (desc
) == DEFINE_SPLIT
)
2646 h
= make_insn_sequence (desc
, SPLIT
);
2647 merge_trees (&split_tree
, &h
);
2649 else if (GET_CODE (desc
) == DEFINE_PEEPHOLE2
)
2651 h
= make_insn_sequence (desc
, PEEPHOLE2
);
2652 merge_trees (&peephole2_tree
, &h
);
2659 return FATAL_EXIT_CODE
;
2663 process_tree (&recog_tree
, RECOG
);
2664 process_tree (&split_tree
, SPLIT
);
2665 process_tree (&peephole2_tree
, PEEPHOLE2
);
2668 return (ferror (stdout
) != 0 ? FATAL_EXIT_CODE
: SUCCESS_EXIT_CODE
);
2671 /* Define this so we can link with print-rtl.o to get debug_rtx function. */
2673 get_insn_name (code
)
2676 if (code
< insn_name_ptr_size
)
2677 return insn_name_ptr
[code
];
2683 record_insn_name (code
, name
)
2687 static const char *last_real_name
= "insn";
2688 static int last_real_code
= 0;
2691 if (insn_name_ptr_size
<= code
)
2694 new_size
= (insn_name_ptr_size
? insn_name_ptr_size
* 2 : 512);
2696 (char **) xrealloc (insn_name_ptr
, sizeof(char *) * new_size
);
2697 memset (insn_name_ptr
+ insn_name_ptr_size
, 0,
2698 sizeof(char *) * (new_size
- insn_name_ptr_size
));
2699 insn_name_ptr_size
= new_size
;
2702 if (!name
|| name
[0] == '\0')
2704 new = xmalloc (strlen (last_real_name
) + 10);
2705 sprintf (new, "%s+%d", last_real_name
, code
- last_real_code
);
2709 last_real_name
= new = xstrdup (name
);
2710 last_real_code
= code
;
2713 insn_name_ptr
[code
] = new;
2717 debug_decision_2 (test
)
2718 struct decision_test
*test
;
2723 fprintf (stderr
, "mode=%s", GET_MODE_NAME (test
->u
.mode
));
2726 fprintf (stderr
, "code=%s", GET_RTX_NAME (test
->u
.code
));
2729 fprintf (stderr
, "veclen=%d", test
->u
.veclen
);
2731 case DT_elt_zero_int
:
2732 fprintf (stderr
, "elt0_i=%d", (int) test
->u
.intval
);
2734 case DT_elt_one_int
:
2735 fprintf (stderr
, "elt1_i=%d", (int) test
->u
.intval
);
2737 case DT_elt_zero_wide
:
2738 fprintf (stderr
, "elt0_w=");
2739 fprintf (stderr
, HOST_WIDE_INT_PRINT_DEC
, test
->u
.intval
);
2742 fprintf (stderr
, "veclen>=%d", test
->u
.veclen
);
2745 fprintf (stderr
, "dup=%d", test
->u
.dup
);
2748 fprintf (stderr
, "pred=(%s,%s)",
2749 test
->u
.pred
.name
, GET_MODE_NAME(test
->u
.pred
.mode
));
2754 strncpy (sub
, test
->u
.c_test
, sizeof(sub
));
2755 memcpy (sub
+16, "...", 4);
2756 fprintf (stderr
, "c_test=\"%s\"", sub
);
2760 fprintf (stderr
, "A_op=%d", test
->u
.opno
);
2762 case DT_accept_insn
:
2763 fprintf (stderr
, "A_insn=(%d,%d)",
2764 test
->u
.insn
.code_number
, test
->u
.insn
.num_clobbers_to_add
);
2773 debug_decision_1 (d
, indent
)
2778 struct decision_test
*test
;
2782 for (i
= 0; i
< indent
; ++i
)
2784 fputs ("(nil)\n", stderr
);
2788 for (i
= 0; i
< indent
; ++i
)
2795 debug_decision_2 (test
);
2796 while ((test
= test
->next
) != NULL
)
2798 fputs (" + ", stderr
);
2799 debug_decision_2 (test
);
2802 fprintf (stderr
, "} %d n %d a %d\n", d
->number
,
2803 (d
->next
? d
->next
->number
: -1),
2804 (d
->afterward
? d
->afterward
->number
: -1));
2808 debug_decision_0 (d
, indent
, maxdepth
)
2810 int indent
, maxdepth
;
2819 for (i
= 0; i
< indent
; ++i
)
2821 fputs ("(nil)\n", stderr
);
2825 debug_decision_1 (d
, indent
);
2826 for (n
= d
->success
.first
; n
; n
= n
->next
)
2827 debug_decision_0 (n
, indent
+ 2, maxdepth
- 1);
2834 debug_decision_0 (d
, 0, 1000000);
2838 debug_decision_list (d
)
2843 debug_decision_0 (d
, 0, 0);