1 /* Generate code from machine description to recognize rtl as insns.
2 Copyright (C) 1987, 88, 92, 93, 94, 95, 97, 98 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. */
22 /* This program is used to produce insn-recog.c, which contains
23 a function called `recog' plus its subroutines.
24 These functions contain a decision tree
25 that recognizes whether an rtx, the argument given to recog,
26 is a valid instruction.
28 recog returns -1 if the rtx is not valid.
29 If the rtx is valid, recog returns a nonnegative number
30 which is the insn code number for the pattern that matched.
31 This is the same as the order in the machine description of the
32 entry that matched. This number can be used as an index into various
33 insn_* tables, such as insn_template, insn_outfun, and insn_n_operands
34 (found in insn-output.c).
36 The third argument to recog is an optional pointer to an int.
37 If present, recog will accept a pattern if it matches except for
38 missing CLOBBER expressions at the end. In that case, the value
39 pointed to by the optional pointer will be set to the number of
40 CLOBBERs that need to be added (it should be initialized to zero by
41 the caller). If it is set nonzero, the caller should allocate a
42 PARALLEL of the appropriate size, copy the initial entries, and call
43 add_clobbers (found in insn-emit.c) to fill in the CLOBBERs.
45 This program also generates the function `split_insns',
46 which returns 0 if the rtl could not be split, or
47 it returns the split rtl in a SEQUENCE. */
58 static struct obstack obstack;
59 struct obstack *rtl_obstack = &obstack;
61 #define obstack_chunk_alloc xmalloc
62 #define obstack_chunk_free free
64 #ifdef NEED_DECLARATION_FREE
67 extern rtx read_rtx ();
69 /* Data structure for a listhead of decision trees. The alternatives
70 to a node are kept in a doublely-linked list so we can easily add nodes
71 to the proper place when merging. */
73 struct decision_head { struct decision *first, *last; };
75 /* Data structure for decision tree for recognizing
76 legitimate instructions. */
80 int number; /* Node number, used for labels */
81 char *position; /* String denoting position in pattern */
82 RTX_CODE code; /* Code to test for or UNKNOWN to suppress */
83 char ignore_code; /* If non-zero, need not test code */
84 char ignore_mode; /* If non-zero, need not test mode */
85 int veclen; /* Length of vector, if nonzero */
86 enum machine_mode mode; /* Machine mode of node */
87 char enforce_mode; /* If non-zero, test `mode' */
88 char retest_code, retest_mode; /* See write_tree_1 */
89 int test_elt_zero_int; /* Nonzero if should test XINT (rtl, 0) */
90 int elt_zero_int; /* Required value for XINT (rtl, 0) */
91 int test_elt_one_int; /* Nonzero if should test XINT (rtl, 1) */
92 int elt_one_int; /* Required value for XINT (rtl, 1) */
93 int test_elt_zero_wide; /* Nonzero if should test XWINT (rtl, 0) */
94 HOST_WIDE_INT elt_zero_wide; /* Required value for XWINT (rtl, 0) */
95 char *tests; /* If nonzero predicate to call */
96 int pred; /* `preds' index of predicate or -1 */
97 char *c_test; /* Additional test to perform */
98 struct decision_head success; /* Nodes to test on success */
99 int insn_code_number; /* Insn number matched, if success */
100 int num_clobbers_to_add; /* Number of CLOBBERs to be added to pattern */
101 struct decision *next; /* Node to test on failure */
102 struct decision *prev; /* Node whose failure tests us */
103 struct decision *afterward; /* Node to test on success, but failure of
105 int opno; /* Operand number, if >= 0 */
106 int dupno; /* Number of operand to compare against */
107 int label_needed; /* Nonzero if label needed when writing tree */
108 int subroutine_number; /* Number of subroutine this node starts */
111 #define SUBROUTINE_THRESHOLD 50
113 static int next_subroutine_number;
115 /* We can write two types of subroutines: One for insn recognition and
116 one to split insns. This defines which type is being written. */
118 enum routine_type {RECOG, SPLIT};
120 /* Next available node number for tree nodes. */
122 static int next_number;
124 /* Next number to use as an insn_code. */
126 static int next_insn_code;
128 /* Similar, but counts all expressions in the MD file; used for
131 static int next_index;
133 /* Record the highest depth we ever have so we know how many variables to
134 allocate in each subroutine we make. */
136 static int max_depth;
138 /* This table contains a list of the rtl codes that can possibly match a
139 predicate defined in recog.c. The function `not_both_true' uses it to
140 deduce that there are no expressions that can be matches by certain pairs
141 of tree nodes. Also, if a predicate can match only one code, we can
142 hardwire that code into the node testing the predicate. */
144 static struct pred_table
147 RTX_CODE codes[NUM_RTX_CODE];
149 = {{"general_operand", {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF,
150 LABEL_REF, SUBREG, REG, MEM}},
151 #ifdef PREDICATE_CODES
154 {"address_operand", {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF,
155 LABEL_REF, SUBREG, REG, MEM, PLUS, MINUS, MULT}},
156 {"register_operand", {SUBREG, REG}},
157 {"scratch_operand", {SCRATCH, REG}},
158 {"immediate_operand", {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF,
160 {"const_int_operand", {CONST_INT}},
161 {"const_double_operand", {CONST_INT, CONST_DOUBLE}},
162 {"nonimmediate_operand", {SUBREG, REG, MEM}},
163 {"nonmemory_operand", {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF,
164 LABEL_REF, SUBREG, REG}},
165 {"push_operand", {MEM}},
166 {"memory_operand", {SUBREG, MEM}},
167 {"indirect_operand", {SUBREG, MEM}},
168 {"comparison_operator", {EQ, NE, LE, LT, GE, GT, LEU, LTU, GEU, GTU}},
169 {"mode_independent_operand", {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF,
170 LABEL_REF, SUBREG, REG, MEM}}};
172 #define NUM_KNOWN_PREDS (sizeof preds / sizeof preds[0])
174 static struct decision_head make_insn_sequence PROTO((rtx, enum routine_type));
175 static struct decision *add_to_sequence PROTO((rtx, struct decision_head *,
177 static int not_both_true PROTO((struct decision *, struct decision *,
179 static int position_merit PROTO((struct decision *, enum machine_mode,
181 static struct decision_head merge_trees PROTO((struct decision_head,
182 struct decision_head));
183 static int break_out_subroutines PROTO((struct decision_head,
184 enum routine_type, int));
185 static void write_subroutine PROTO((struct decision *, enum routine_type));
186 static void write_tree_1 PROTO((struct decision *, char *,
187 struct decision *, enum routine_type));
188 static void print_code PROTO((enum rtx_code));
189 static int same_codes PROTO((struct decision *, enum rtx_code));
190 static void clear_codes PROTO((struct decision *));
191 static int same_modes PROTO((struct decision *, enum machine_mode));
192 static void clear_modes PROTO((struct decision *));
193 static void write_tree PROTO((struct decision *, char *,
194 struct decision *, int,
196 static void change_state PROTO((char *, char *, int));
197 static char *copystr PROTO((char *));
198 static void mybzero PROTO((char *, unsigned));
199 static void mybcopy PROTO((char *, char *, unsigned));
200 static void fatal PROTO((char *));
201 char *xrealloc PROTO((char *, unsigned));
202 char *xmalloc PROTO((unsigned));
203 void fancy_abort PROTO((void));
205 /* Construct and return a sequence of decisions
206 that will recognize INSN.
208 TYPE says what type of routine we are recognizing (RECOG or SPLIT). */
210 static struct decision_head
211 make_insn_sequence (insn, type)
213 enum routine_type type;
216 char *c_test = XSTR (insn, type == RECOG ? 2 : 1);
217 struct decision *last;
218 struct decision_head head;
220 if (XVECLEN (insn, type == RECOG) == 1)
221 x = XVECEXP (insn, type == RECOG, 0);
224 x = rtx_alloc (PARALLEL);
225 XVEC (x, 0) = XVEC (insn, type == RECOG);
226 PUT_MODE (x, VOIDmode);
229 last = add_to_sequence (x, &head, "");
232 last->c_test = c_test;
233 last->insn_code_number = next_insn_code;
234 last->num_clobbers_to_add = 0;
236 /* If this is not a DEFINE_SPLIT and X is a PARALLEL, see if it ends with a
237 group of CLOBBERs of (hard) registers or MATCH_SCRATCHes. If so, set up
238 to recognize the pattern without these CLOBBERs. */
240 if (type == RECOG && GET_CODE (x) == PARALLEL)
244 for (i = XVECLEN (x, 0); i > 0; i--)
245 if (GET_CODE (XVECEXP (x, 0, i - 1)) != CLOBBER
246 || (GET_CODE (XEXP (XVECEXP (x, 0, i - 1), 0)) != REG
247 && GET_CODE (XEXP (XVECEXP (x, 0, i - 1), 0)) != MATCH_SCRATCH))
250 if (i != XVECLEN (x, 0))
253 struct decision_head clobber_head;
256 new = XVECEXP (x, 0, 0);
261 new = rtx_alloc (PARALLEL);
262 XVEC (new, 0) = rtvec_alloc (i);
263 for (j = i - 1; j >= 0; j--)
264 XVECEXP (new, 0, j) = XVECEXP (x, 0, j);
267 last = add_to_sequence (new, &clobber_head, "");
270 last->c_test = c_test;
271 last->insn_code_number = next_insn_code;
272 last->num_clobbers_to_add = XVECLEN (x, 0) - i;
274 head = merge_trees (head, clobber_head);
281 /* Define the subroutine we will call below and emit in genemit. */
282 printf ("extern rtx gen_split_%d ();\n", last->insn_code_number);
287 /* Create a chain of nodes to verify that an rtl expression matches
290 LAST is a pointer to the listhead in the previous node in the chain (or
291 in the calling function, for the first node).
293 POSITION is the string representing the current position in the insn.
295 A pointer to the final node in the chain is returned. */
297 static struct decision *
298 add_to_sequence (pattern, last, position)
300 struct decision_head *last;
303 register RTX_CODE code;
304 register struct decision *new
305 = (struct decision *) xmalloc (sizeof (struct decision));
306 struct decision *this;
310 int depth = strlen (position);
313 if (depth > max_depth)
316 new->number = next_number++;
317 new->position = copystr (position);
318 new->ignore_code = 0;
319 new->ignore_mode = 0;
320 new->enforce_mode = 1;
321 new->retest_code = new->retest_mode = 0;
323 new->test_elt_zero_int = 0;
324 new->test_elt_one_int = 0;
325 new->test_elt_zero_wide = 0;
326 new->elt_zero_int = 0;
327 new->elt_one_int = 0;
328 new->elt_zero_wide = 0;
332 new->success.first = new->success.last = 0;
333 new->insn_code_number = -1;
334 new->num_clobbers_to_add = 0;
340 new->label_needed = 0;
341 new->subroutine_number = 0;
345 last->first = last->last = new;
347 newpos = (char *) alloca (depth + 2);
348 strcpy (newpos, position);
349 newpos[depth + 1] = 0;
353 new->mode = GET_MODE (pattern);
354 new->code = code = GET_CODE (pattern);
362 new->opno = XINT (pattern, 0);
363 new->code = (code == MATCH_PARALLEL ? PARALLEL : UNKNOWN);
364 new->enforce_mode = 0;
366 if (code == MATCH_SCRATCH)
367 new->tests = "scratch_operand";
369 new->tests = XSTR (pattern, 1);
371 if (*new->tests == 0)
374 /* See if we know about this predicate and save its number. If we do,
375 and it only accepts one code, note that fact. The predicate
376 `const_int_operand' only tests for a CONST_INT, so if we do so we
377 can avoid calling it at all.
379 Finally, if we know that the predicate does not allow CONST_INT, we
380 know that the only way the predicate can match is if the modes match
381 (here we use the kludge of relying on the fact that "address_operand"
382 accepts CONST_INT; otherwise, it would have to be a special case),
383 so we can test the mode (but we need not). This fact should
384 considerably simplify the generated code. */
388 for (i = 0; i < NUM_KNOWN_PREDS; i++)
389 if (! strcmp (preds[i].name, new->tests))
392 int allows_const_int = 0;
396 if (preds[i].codes[1] == 0 && new->code == UNKNOWN)
398 new->code = preds[i].codes[0];
399 if (! strcmp ("const_int_operand", new->tests))
400 new->tests = 0, new->pred = -1;
403 for (j = 0; j < NUM_RTX_CODE && preds[i].codes[j] != 0; j++)
404 if (preds[i].codes[j] == CONST_INT)
405 allows_const_int = 1;
407 if (! allows_const_int)
408 new->enforce_mode = new->ignore_mode= 1;
413 #ifdef PREDICATE_CODES
414 /* If the port has a list of the predicates it uses but omits
416 if (i == NUM_KNOWN_PREDS)
417 fprintf (stderr, "Warning: `%s' not in PREDICATE_CODES\n",
422 if (code == MATCH_OPERATOR || code == MATCH_PARALLEL)
424 for (i = 0; i < XVECLEN (pattern, 2); i++)
426 newpos[depth] = i + (code == MATCH_OPERATOR ? '0': 'a');
427 new = add_to_sequence (XVECEXP (pattern, 2, i),
428 &new->success, newpos);
435 new->opno = XINT (pattern, 0);
436 new->dupno = XINT (pattern, 0);
439 for (i = 0; i < XVECLEN (pattern, 1); i++)
441 newpos[depth] = i + '0';
442 new = add_to_sequence (XVECEXP (pattern, 1, i),
443 &new->success, newpos);
449 new->dupno = XINT (pattern, 0);
451 new->enforce_mode = 0;
455 pattern = XEXP (pattern, 0);
460 new = add_to_sequence (SET_DEST (pattern), &new->success, newpos);
461 this->success.first->enforce_mode = 1;
463 new = add_to_sequence (SET_SRC (pattern), &new->success, newpos);
465 /* If set are setting CC0 from anything other than a COMPARE, we
466 must enforce the mode so that we do not produce ambiguous insns. */
467 if (GET_CODE (SET_DEST (pattern)) == CC0
468 && GET_CODE (SET_SRC (pattern)) != COMPARE)
469 this->success.first->enforce_mode = 1;
474 case STRICT_LOW_PART:
476 new = add_to_sequence (XEXP (pattern, 0), &new->success, newpos);
477 this->success.first->enforce_mode = 1;
481 this->test_elt_one_int = 1;
482 this->elt_one_int = XINT (pattern, 1);
484 new = add_to_sequence (XEXP (pattern, 0), &new->success, newpos);
485 this->success.first->enforce_mode = 1;
491 new = add_to_sequence (XEXP (pattern, 0), &new->success, newpos);
492 this->success.first->enforce_mode = 1;
494 new = add_to_sequence (XEXP (pattern, 1), &new->success, newpos);
496 new = add_to_sequence (XEXP (pattern, 2), &new->success, newpos);
499 case EQ: case NE: case LE: case LT: case GE: case GT:
500 case LEU: case LTU: case GEU: case GTU:
501 /* If the first operand is (cc0), we don't have to do anything
503 if (GET_CODE (XEXP (pattern, 0)) == CC0)
506 /* ... fall through ... */
509 /* Enforce the mode on the first operand to avoid ambiguous insns. */
511 new = add_to_sequence (XEXP (pattern, 0), &new->success, newpos);
512 this->success.first->enforce_mode = 1;
514 new = add_to_sequence (XEXP (pattern, 1), &new->success, newpos);
521 fmt = GET_RTX_FORMAT (code);
522 len = GET_RTX_LENGTH (code);
523 for (i = 0; i < len; i++)
525 newpos[depth] = '0' + i;
526 if (fmt[i] == 'e' || fmt[i] == 'u')
527 new = add_to_sequence (XEXP (pattern, i), &new->success, newpos);
528 else if (fmt[i] == 'i' && i == 0)
530 this->test_elt_zero_int = 1;
531 this->elt_zero_int = XINT (pattern, i);
533 else if (fmt[i] == 'i' && i == 1)
535 this->test_elt_one_int = 1;
536 this->elt_one_int = XINT (pattern, i);
538 else if (fmt[i] == 'w' && i == 0)
540 this->test_elt_zero_wide = 1;
541 this->elt_zero_wide = XWINT (pattern, i);
543 else if (fmt[i] == 'E')
546 /* We do not handle a vector appearing as other than
547 the first item, just because nothing uses them
548 and by handling only the special case
549 we can use one element in newpos for either
550 the item number of a subexpression
551 or the element number in a vector. */
554 this->veclen = XVECLEN (pattern, i);
555 for (j = 0; j < XVECLEN (pattern, i); j++)
557 newpos[depth] = 'a' + j;
558 new = add_to_sequence (XVECEXP (pattern, i, j),
559 &new->success, newpos);
562 else if (fmt[i] != '0')
568 /* Return 1 if we can prove that there is no RTL that can match both
569 D1 and D2. Otherwise, return 0 (it may be that there is an RTL that
570 can match both or just that we couldn't prove there wasn't such an RTL).
572 TOPLEVEL is non-zero if we are to only look at the top level and not
573 recursively descend. */
576 not_both_true (d1, d2, toplevel)
577 struct decision *d1, *d2;
580 struct decision *p1, *p2;
582 /* If they are both to test modes and the modes are different, they aren't
583 both true. Similarly for codes, integer elements, and vector lengths. */
585 if ((d1->enforce_mode && d2->enforce_mode
586 && d1->mode != VOIDmode && d2->mode != VOIDmode && d1->mode != d2->mode)
587 || (d1->code != UNKNOWN && d2->code != UNKNOWN && d1->code != d2->code)
588 || (d1->test_elt_zero_int && d2->test_elt_zero_int
589 && d1->elt_zero_int != d2->elt_zero_int)
590 || (d1->test_elt_one_int && d2->test_elt_one_int
591 && d1->elt_one_int != d2->elt_one_int)
592 || (d1->test_elt_zero_wide && d2->test_elt_zero_wide
593 && d1->elt_zero_wide != d2->elt_zero_wide)
594 || (d1->veclen && d2->veclen && d1->veclen != d2->veclen))
597 /* If either is a wild-card MATCH_OPERAND without a predicate, it can match
598 absolutely anything, so we can't say that no intersection is possible.
599 This case is detected by having a zero TESTS field with a code of
602 if ((d1->tests == 0 && d1->code == UNKNOWN)
603 || (d2->tests == 0 && d2->code == UNKNOWN))
606 /* If either has a predicate that we know something about, set things up so
607 that D1 is the one that always has a known predicate. Then see if they
608 have any codes in common. */
610 if (d1->pred >= 0 || d2->pred >= 0)
615 p1 = d1, d1 = d2, d2 = p1;
617 /* If D2 tests an explicit code, see if it is in the list of valid codes
618 for D1's predicate. */
619 if (d2->code != UNKNOWN)
621 for (i = 0; i < NUM_RTX_CODE && preds[d1->pred].codes[i] != 0; i++)
622 if (preds[d1->pred].codes[i] == d2->code)
625 if (preds[d1->pred].codes[i] == 0)
629 /* Otherwise see if the predicates have any codes in common. */
631 else if (d2->pred >= 0)
633 for (i = 0; i < NUM_RTX_CODE && preds[d1->pred].codes[i] != 0; i++)
635 for (j = 0; j < NUM_RTX_CODE; j++)
636 if (preds[d2->pred].codes[j] == 0
637 || preds[d2->pred].codes[j] == preds[d1->pred].codes[i])
640 if (preds[d2->pred].codes[j] != 0)
644 if (preds[d1->pred].codes[i] == 0)
649 /* If we got here, we can't prove that D1 and D2 cannot both be true.
650 If we are only to check the top level, return 0. Otherwise, see if
651 we can prove that all choices in both successors are mutually
652 exclusive. If either does not have any successors, we can't prove
653 they can't both be true. */
655 if (toplevel || d1->success.first == 0 || d2->success.first == 0)
658 for (p1 = d1->success.first; p1; p1 = p1->next)
659 for (p2 = d2->success.first; p2; p2 = p2->next)
660 if (! not_both_true (p1, p2, 0))
666 /* Assuming that we can reorder all the alternatives at a specific point in
667 the tree (see discussion in merge_trees), we would prefer an ordering of
668 nodes where groups of consecutive nodes test the same mode and, within each
669 mode, groups of nodes test the same code. With this order, we can
670 construct nested switch statements, the inner one to test the code and
671 the outer one to test the mode.
673 We would like to list nodes testing for specific codes before those
674 that test predicates to avoid unnecessary function calls. Similarly,
675 tests for specific modes should precede nodes that allow any mode.
677 This function returns the merit (with 0 being the best) of inserting
678 a test involving the specified MODE and CODE after node P. If P is
679 zero, we are to determine the merit of inserting the test at the front
683 position_merit (p, mode, code)
685 enum machine_mode mode;
688 enum machine_mode p_mode;
690 /* The only time the front of the list is anything other than the worst
691 position is if we are testing a mode that isn't VOIDmode. */
693 return mode == VOIDmode ? 3 : 2;
695 p_mode = p->enforce_mode ? p->mode : VOIDmode;
697 /* The best case is if the codes and modes both match. */
698 if (p_mode == mode && p->code== code)
701 /* If the codes don't match, the next best case is if the modes match.
702 In that case, the best position for this node depends on whether
703 we are testing for a specific code or not. If we are, the best place
704 is after some other test for an explicit code and our mode or after
705 the last test in the previous mode if every test in our mode is for
708 If we are testing for UNKNOWN, then the next best case is at the end of
712 && ((p_mode == mode && p->code != UNKNOWN)
713 || (p_mode != mode && p->next
714 && (p->next->enforce_mode ? p->next->mode : VOIDmode) == mode
715 && (p->next->code == UNKNOWN))))
716 || (code == UNKNOWN && p_mode == mode
718 || (p->next->enforce_mode ? p->next->mode : VOIDmode) != mode)))
721 /* The third best case occurs when nothing is testing MODE. If MODE
722 is not VOIDmode, then the third best case is after something of any
723 mode that is not VOIDmode. If we are testing VOIDmode, the third best
724 place is the end of the list. */
727 && ((mode != VOIDmode && p_mode != VOIDmode)
728 || (mode == VOIDmode && p->next == 0)))
731 /* Otherwise, we have the worst case. */
735 /* Merge two decision tree listheads OLDH and ADDH,
736 modifying OLDH destructively, and return the merged tree. */
738 static struct decision_head
739 merge_trees (oldh, addh)
740 register struct decision_head oldh, addh;
742 struct decision *add, *next;
750 /* If we are adding things at different positions, something is wrong. */
751 if (strcmp (oldh.first->position, addh.first->position))
754 for (add = addh.first; add; add = next)
756 enum machine_mode add_mode = add->enforce_mode ? add->mode : VOIDmode;
757 struct decision *best_position = 0;
759 struct decision *old;
763 /* The semantics of pattern matching state that the tests are done in
764 the order given in the MD file so that if an insn matches two
765 patterns, the first one will be used. However, in practice, most,
766 if not all, patterns are unambiguous so that their order is
767 independent. In that case, we can merge identical tests and
768 group all similar modes and codes together.
770 Scan starting from the end of OLDH until we reach a point
771 where we reach the head of the list or where we pass a pattern
772 that could also be true if NEW is true. If we find an identical
773 pattern, we can merge them. Also, record the last node that tests
774 the same code and mode and the last one that tests just the same mode.
776 If we have no match, place NEW after the closest match we found. */
778 for (old = oldh.last; old; old = old->prev)
782 /* If we don't have anything to test except an additional test,
783 do not consider the two nodes equal. If we did, the test below
784 would cause an infinite recursion. */
785 if (old->tests == 0 && old->test_elt_zero_int == 0
786 && old->test_elt_one_int == 0 && old->veclen == 0
787 && old->test_elt_zero_wide == 0
788 && old->dupno == -1 && old->mode == VOIDmode
789 && old->code == UNKNOWN
790 && (old->c_test != 0 || add->c_test != 0))
793 else if ((old->tests == add->tests
794 || (old->pred >= 0 && old->pred == add->pred)
795 || (old->tests && add->tests
796 && !strcmp (old->tests, add->tests)))
797 && old->test_elt_zero_int == add->test_elt_zero_int
798 && old->elt_zero_int == add->elt_zero_int
799 && old->test_elt_one_int == add->test_elt_one_int
800 && old->elt_one_int == add->elt_one_int
801 && old->test_elt_zero_wide == add->test_elt_zero_wide
802 && old->elt_zero_wide == add->elt_zero_wide
803 && old->veclen == add->veclen
804 && old->dupno == add->dupno
805 && old->opno == add->opno
806 && old->code == add->code
807 && old->enforce_mode == add->enforce_mode
808 && old->mode == add->mode)
810 /* If the additional test is not the same, split both nodes
811 into nodes that just contain all things tested before the
812 additional test and nodes that contain the additional test
813 and actions when it is true. This optimization is important
814 because of the case where we have almost identical patterns
815 with different tests on target flags. */
817 if (old->c_test != add->c_test
818 && ! (old->c_test && add->c_test
819 && !strcmp (old->c_test, add->c_test)))
821 if (old->insn_code_number >= 0 || old->opno >= 0)
823 struct decision *split
824 = (struct decision *) xmalloc (sizeof (struct decision));
826 mybcopy ((char *) old, (char *) split,
827 sizeof (struct decision));
829 old->success.first = old->success.last = split;
832 old->insn_code_number = -1;
833 old->num_clobbers_to_add = 0;
835 split->number = next_number++;
836 split->next = split->prev = 0;
837 split->mode = VOIDmode;
838 split->code = UNKNOWN;
840 split->test_elt_zero_int = 0;
841 split->test_elt_one_int = 0;
842 split->test_elt_zero_wide = 0;
848 if (add->insn_code_number >= 0 || add->opno >= 0)
850 struct decision *split
851 = (struct decision *) xmalloc (sizeof (struct decision));
853 mybcopy ((char *) add, (char *) split,
854 sizeof (struct decision));
856 add->success.first = add->success.last = split;
859 add->insn_code_number = -1;
860 add->num_clobbers_to_add = 0;
862 split->number = next_number++;
863 split->next = split->prev = 0;
864 split->mode = VOIDmode;
865 split->code = UNKNOWN;
867 split->test_elt_zero_int = 0;
868 split->test_elt_one_int = 0;
869 split->test_elt_zero_wide = 0;
876 if (old->insn_code_number >= 0 && add->insn_code_number >= 0)
878 /* If one node is for a normal insn and the second is
879 for the base insn with clobbers stripped off, the
880 second node should be ignored. */
882 if (old->num_clobbers_to_add == 0
883 && add->num_clobbers_to_add > 0)
884 /* Nothing to do here. */
886 else if (old->num_clobbers_to_add > 0
887 && add->num_clobbers_to_add == 0)
889 /* In this case, replace OLD with ADD. */
890 old->insn_code_number = add->insn_code_number;
891 old->num_clobbers_to_add = 0;
894 fatal ("Two actions at one point in tree");
897 if (old->insn_code_number == -1)
898 old->insn_code_number = add->insn_code_number;
899 old->success = merge_trees (old->success, add->success);
904 /* Unless we have already found the best possible insert point,
905 see if this position is better. If so, record it. */
908 && ((our_merit = position_merit (old, add_mode, add->code))
910 best_merit = our_merit, best_position = old;
912 if (! not_both_true (old, add, 0))
916 /* If ADD was duplicate, we are done. */
920 /* Otherwise, find the best place to insert ADD. Normally this is
921 BEST_POSITION. However, if we went all the way to the top of
922 the list, it might be better to insert at the top. */
924 if (best_position == 0)
928 && position_merit (NULL_PTR, add_mode, add->code) < best_merit)
931 add->next = oldh.first;
932 oldh.first->prev = add;
938 add->prev = best_position;
939 add->next = best_position->next;
940 best_position->next = add;
941 if (best_position == oldh.last)
944 add->next->prev = add;
951 /* Count the number of subnodes of HEAD. If the number is high enough,
952 make the first node in HEAD start a separate subroutine in the C code
955 TYPE gives the type of routine we are writing.
957 INITIAL is non-zero if this is the highest-level node. We never write
961 break_out_subroutines (head, type, initial)
962 struct decision_head head;
963 enum routine_type type;
967 struct decision *sub;
969 for (sub = head.first; sub; sub = sub->next)
970 size += 1 + break_out_subroutines (sub->success, type, 0);
972 if (size > SUBROUTINE_THRESHOLD && ! initial)
974 head.first->subroutine_number = ++next_subroutine_number;
975 write_subroutine (head.first, type);
981 /* Write out a subroutine of type TYPE to do comparisons starting at node
985 write_subroutine (tree, type)
986 struct decision *tree;
987 enum routine_type type;
992 printf ("rtx\nsplit");
994 printf ("int\nrecog");
996 if (tree != 0 && tree->subroutine_number > 0)
997 printf ("_%d", tree->subroutine_number);
998 else if (type == SPLIT)
1001 printf (" (x0, insn");
1003 printf (", pnum_clobbers");
1006 printf (" register rtx x0;\n rtx insn;\n");
1008 printf (" int *pnum_clobbers;\n");
1011 printf (" register rtx *ro = &recog_operand[0];\n");
1013 printf (" register rtx ");
1014 for (i = 1; i < max_depth; i++)
1015 printf ("x%d, ", i);
1017 printf ("x%d;\n", max_depth);
1018 printf (" %s tem;\n", type == SPLIT ? "rtx" : "int");
1019 write_tree (tree, "", NULL_PTR, 1, type);
1020 printf (" ret0: return %d;\n}\n\n", type == SPLIT ? 0 : -1);
1023 /* This table is used to indent the recog_* functions when we are inside
1024 conditions or switch statements. We only support small indentations
1025 and always indent at least two spaces. */
1027 static char *indents[]
1028 = {" ", " ", " ", " ", " ", " ", " ", " ",
1029 "\t", "\t ", "\t ", "\t ", "\t ", "\t ", "\t ",
1030 "\t\t", "\t\t ", "\t\t ", "\t\t ", "\t\t ", "\t\t "};
1032 /* Write out C code to perform the decisions in TREE for a subroutine of
1033 type TYPE. If all of the choices fail, branch to node AFTERWARD, if
1034 non-zero, otherwise return. PREVPOS is the position of the node that
1035 branched to this test.
1037 When we merged all alternatives, we tried to set up a convenient order.
1038 Specifically, tests involving the same mode are all grouped together,
1039 followed by a group that does not contain a mode test. Within each group
1040 of the same mode, we also group tests with the same code, followed by a
1041 group that does not test a code.
1043 Occasionally, we cannot arbitrarily reorder the tests so that multiple
1044 sequence of groups as described above are present.
1046 We generate two nested switch statements, the outer statement for
1047 testing modes, and the inner switch for testing RTX codes. It is
1048 not worth optimizing cases when only a small number of modes or
1049 codes is tested, since the compiler can do that when compiling the
1050 resulting function. We do check for when every test is the same mode
1054 write_tree_1 (tree, prevpos, afterward, type)
1055 struct decision *tree;
1057 struct decision *afterward;
1058 enum routine_type type;
1060 register struct decision *p, *p1;
1061 register int depth = tree ? strlen (tree->position) : 0;
1062 enum machine_mode switch_mode = VOIDmode;
1063 RTX_CODE switch_code = UNKNOWN;
1065 char modemap[NUM_MACHINE_MODES];
1066 char codemap[NUM_RTX_CODE];
1070 /* One tricky area is what is the exact state when we branch to a
1071 node's label. There are two cases where we branch: when looking at
1072 successors to a node, or when a set of tests fails.
1074 In the former case, we are always branching to the first node in a
1075 decision list and we want all required tests to be performed. We
1076 put the labels for such nodes in front of any switch or test statements.
1077 These branches are done without updating the position to that of the
1080 In the latter case, we are branching to a node that is not the first
1081 node in a decision list. We have already checked that it is possible
1082 for both the node we originally tested at this level and the node we
1083 are branching to to be both match some pattern. That means that they
1084 usually will be testing the same mode and code. So it is normally safe
1085 for such labels to be inside switch statements, since the tests done
1086 by virtue of arriving at that label will usually already have been
1087 done. The exception is a branch from a node that does not test a
1088 mode or code to one that does. In such cases, we set the `retest_mode'
1089 or `retest_code' flags. That will ensure that we start a new switch
1090 at that position and put the label before the switch.
1092 The branches in the latter case must set the position to that of the
1097 if (tree && tree->subroutine_number == 0)
1099 printf (" L%d:\n", tree->number);
1100 tree->label_needed = 0;
1105 change_state (prevpos, tree->position, 2);
1106 prevpos = tree->position;
1109 for (p = tree; p; p = p->next)
1111 enum machine_mode mode = p->enforce_mode ? p->mode : VOIDmode;
1113 int wrote_bracket = 0;
1116 if (p->success.first == 0 && p->insn_code_number < 0)
1119 /* Find the next alternative to p that might be true when p is true.
1120 Test that one next if p's successors fail. */
1122 for (p1 = p->next; p1 && not_both_true (p, p1, 1); p1 = p1->next)
1128 if (mode == VOIDmode && p1->enforce_mode && p1->mode != VOIDmode)
1129 p1->retest_mode = 1;
1130 if (p->code == UNKNOWN && p1->code != UNKNOWN)
1131 p1->retest_code = 1;
1132 p1->label_needed = 1;
1135 /* If we have a different code or mode than the last node and
1136 are in a switch on codes, we must either end the switch or
1137 go to another case. We must also end the switch if this
1138 node needs a label and to retest either the mode or code. */
1140 if (switch_code != UNKNOWN
1141 && (switch_code != p->code || switch_mode != mode
1142 || (p->label_needed && (p->retest_mode || p->retest_code))))
1144 enum rtx_code code = p->code;
1146 /* If P is testing a predicate that we know about and we haven't
1147 seen any of the codes that are valid for the predicate, we
1148 can write a series of "case" statement, one for each possible
1149 code. Since we are already in a switch, these redundant tests
1150 are very cheap and will reduce the number of predicate called. */
1154 for (i = 0; i < NUM_RTX_CODE && preds[p->pred].codes[i] != 0; i++)
1155 if (codemap[(int) preds[p->pred].codes[i]])
1158 if (preds[p->pred].codes[i] == 0)
1159 code = MATCH_OPERAND;
1162 if (code == UNKNOWN || codemap[(int) code]
1163 || switch_mode != mode
1164 || (p->label_needed && (p->retest_mode || p->retest_code)))
1166 printf ("%s}\n", indents[indent - 2]);
1167 switch_code = UNKNOWN;
1173 printf ("%sbreak;\n", indents[indent]);
1175 if (code == MATCH_OPERAND)
1177 for (i = 0; i < NUM_RTX_CODE && preds[p->pred].codes[i] != 0; i++)
1179 printf ("%scase ", indents[indent - 2]);
1180 print_code (preds[p->pred].codes[i]);
1182 codemap[(int) preds[p->pred].codes[i]] = 1;
1187 printf ("%scase ", indents[indent - 2]);
1190 codemap[(int) p->code] = 1;
1199 /* If we were previously in a switch on modes and now have a different
1200 mode, end at least the case, and maybe end the switch if we are
1201 not testing a mode or testing a mode whose case we already saw. */
1203 if (switch_mode != VOIDmode
1204 && (switch_mode != mode || (p->label_needed && p->retest_mode)))
1206 if (mode == VOIDmode || modemap[(int) mode]
1207 || (p->label_needed && p->retest_mode))
1209 printf ("%s}\n", indents[indent - 2]);
1210 switch_mode = VOIDmode;
1216 printf (" break;\n");
1217 printf (" case %smode:\n", GET_MODE_NAME (mode));
1219 modemap[(int) mode] = 1;
1225 /* If we are about to write dead code, something went wrong. */
1226 if (! p->label_needed && uncond)
1229 /* If we need a label and we will want to retest the mode or code at
1230 that label, write the label now. We have already ensured that
1231 things will be valid for the test. */
1233 if (p->label_needed && (p->retest_mode || p->retest_code))
1235 printf ("%sL%d:\n", indents[indent - 2], p->number);
1236 p->label_needed = 0;
1241 /* If we are not in any switches, see if we can shortcut things
1242 by checking for identical modes and codes. */
1244 if (switch_mode == VOIDmode && switch_code == UNKNOWN)
1246 /* If p and its alternatives all want the same mode,
1247 reject all others at once, first, then ignore the mode. */
1249 if (mode != VOIDmode && p->next && same_modes (p, mode))
1251 printf (" if (GET_MODE (x%d) != %smode)\n",
1252 depth, GET_MODE_NAME (p->mode));
1256 change_state (p->position, afterward->position, 6);
1257 printf (" goto L%d;\n }\n", afterward->number);
1260 printf (" goto ret0;\n");
1265 /* If p and its alternatives all want the same code,
1266 reject all others at once, first, then ignore the code. */
1268 if (p->code != UNKNOWN && p->next && same_codes (p, p->code))
1270 printf (" if (GET_CODE (x%d) != ", depth);
1271 print_code (p->code);
1276 change_state (p->position, afterward->position, indent + 4);
1277 printf (" goto L%d;\n }\n", afterward->number);
1280 printf (" goto ret0;\n");
1285 /* If we are not in a mode switch and we are testing for a specific
1286 mode, start a mode switch unless we have just one node or the next
1287 node is not testing a mode (we have already tested for the case of
1288 more than one mode, but all of the same mode). */
1290 if (switch_mode == VOIDmode && mode != VOIDmode && p->next != 0
1291 && p->next->enforce_mode && p->next->mode != VOIDmode)
1293 mybzero (modemap, sizeof modemap);
1294 printf ("%sswitch (GET_MODE (x%d))\n", indents[indent], depth);
1295 printf ("%s{\n", indents[indent + 2]);
1297 printf ("%sdefault:\n%sbreak;\n", indents[indent - 2],
1299 printf ("%scase %smode:\n", indents[indent - 2],
1300 GET_MODE_NAME (mode));
1301 modemap[(int) mode] = 1;
1305 /* Similarly for testing codes. */
1307 if (switch_code == UNKNOWN && p->code != UNKNOWN && ! p->ignore_code
1308 && p->next != 0 && p->next->code != UNKNOWN)
1310 mybzero (codemap, sizeof codemap);
1311 printf ("%sswitch (GET_CODE (x%d))\n", indents[indent], depth);
1312 printf ("%s{\n", indents[indent + 2]);
1314 printf ("%sdefault:\n%sbreak;\n", indents[indent - 2],
1316 printf ("%scase ", indents[indent - 2]);
1317 print_code (p->code);
1319 codemap[(int) p->code] = 1;
1320 switch_code = p->code;
1323 /* Now that most mode and code tests have been done, we can write out
1324 a label for an inner node, if we haven't already. */
1325 if (p->label_needed)
1326 printf ("%sL%d:\n", indents[indent - 2], p->number);
1328 inner_indent = indent;
1330 /* The only way we can have to do a mode or code test here is if
1331 this node needs such a test but is the only node to be tested.
1332 In that case, we won't have started a switch. Note that this is
1333 the only way the switch and test modes can disagree. */
1335 if ((mode != switch_mode && ! p->ignore_mode)
1336 || (p->code != switch_code && p->code != UNKNOWN && ! p->ignore_code)
1337 || p->test_elt_zero_int || p->test_elt_one_int
1338 || p->test_elt_zero_wide || p->veclen
1339 || p->dupno >= 0 || p->tests || p->num_clobbers_to_add)
1341 printf ("%sif (", indents[indent]);
1343 if (mode != switch_mode && ! p->ignore_mode)
1344 printf ("GET_MODE (x%d) == %smode && ",
1345 depth, GET_MODE_NAME (mode));
1346 if (p->code != switch_code && p->code != UNKNOWN && ! p->ignore_code)
1348 printf ("GET_CODE (x%d) == ", depth);
1349 print_code (p->code);
1353 if (p->test_elt_zero_int)
1354 printf ("XINT (x%d, 0) == %d && ", depth, p->elt_zero_int);
1355 if (p->test_elt_one_int)
1356 printf ("XINT (x%d, 1) == %d && ", depth, p->elt_one_int);
1357 if (p->test_elt_zero_wide)
1359 /* Set offset to 1 iff the number might get propagated to
1360 unsigned long by ANSI C rules, else 0.
1361 Prospective hosts are required to have at least 32 bit
1362 ints, and integer constants in machine descriptions
1363 must fit in 32 bit, thus it suffices to check only
1365 HOST_WIDE_INT offset = p->elt_zero_wide == -2147483647 - 1;
1366 printf ("XWINT (x%d, 0) == ", depth);
1367 printf (HOST_WIDE_INT_PRINT_DEC, p->elt_zero_wide + offset);
1368 printf ("%s && ", offset ? "-1" : "");
1371 printf ("XVECLEN (x%d, 0) == %d && ", depth, p->veclen);
1373 printf ("rtx_equal_p (x%d, ro[%d]) && ", depth, p->dupno);
1374 if (p->num_clobbers_to_add)
1375 printf ("pnum_clobbers != 0 && ");
1377 printf ("%s (x%d, %smode)", p->tests, depth,
1378 GET_MODE_NAME (p->mode));
1388 need_bracket = ! uncond;
1394 printf ("%s{\n", indents[inner_indent]);
1400 printf ("%sro[%d] = x%d;\n", indents[inner_indent], p->opno, depth);
1405 printf ("%sif (%s)\n", indents[inner_indent], p->c_test);
1411 if (p->insn_code_number >= 0)
1414 printf ("%sreturn gen_split_%d (operands);\n",
1415 indents[inner_indent], p->insn_code_number);
1418 if (p->num_clobbers_to_add)
1422 printf ("%s{\n", indents[inner_indent]);
1426 printf ("%s*pnum_clobbers = %d;\n",
1427 indents[inner_indent], p->num_clobbers_to_add);
1428 printf ("%sreturn %d;\n",
1429 indents[inner_indent], p->insn_code_number);
1434 printf ("%s}\n", indents[inner_indent]);
1438 printf ("%sreturn %d;\n",
1439 indents[inner_indent], p->insn_code_number);
1443 printf ("%sgoto L%d;\n", indents[inner_indent],
1444 p->success.first->number);
1447 printf ("%s}\n", indents[inner_indent - 2]);
1450 /* We have now tested all alternatives. End any switches we have open
1451 and branch to the alternative node unless we know that we can't fall
1452 through to the branch. */
1454 if (switch_code != UNKNOWN)
1456 printf ("%s}\n", indents[indent - 2]);
1461 if (switch_mode != VOIDmode)
1463 printf ("%s}\n", indents[indent - 2]);
1476 change_state (prevpos, afterward->position, 2);
1477 printf (" goto L%d;\n", afterward->number);
1480 printf (" goto ret0;\n");
1488 for (p1 = GET_RTX_NAME (code); *p1; p1++)
1490 if (*p1 >= 'a' && *p1 <= 'z')
1491 putchar (*p1 + 'A' - 'a');
1498 same_codes (p, code)
1499 register struct decision *p;
1500 register enum rtx_code code;
1502 for (; p; p = p->next)
1503 if (p->code != code)
1511 register struct decision *p;
1513 for (; p; p = p->next)
1518 same_modes (p, mode)
1519 register struct decision *p;
1520 register enum machine_mode mode;
1522 for (; p; p = p->next)
1523 if ((p->enforce_mode ? p->mode : VOIDmode) != mode)
1531 register struct decision *p;
1533 for (; p; p = p->next)
1534 p->enforce_mode = 0;
1537 /* Write out the decision tree starting at TREE for a subroutine of type TYPE.
1539 PREVPOS is the position at the node that branched to this node.
1541 INITIAL is nonzero if this is the first node we are writing in a subroutine.
1543 If all nodes are false, branch to the node AFTERWARD. */
1546 write_tree (tree, prevpos, afterward, initial, type)
1547 struct decision *tree;
1549 struct decision *afterward;
1551 enum routine_type type;
1553 register struct decision *p;
1554 char *name_prefix = (type == SPLIT ? "split" : "recog");
1555 char *call_suffix = (type == SPLIT ? "" : ", pnum_clobbers");
1557 if (! initial && tree->subroutine_number > 0)
1559 printf (" L%d:\n", tree->number);
1563 printf (" tem = %s_%d (x0, insn%s);\n",
1564 name_prefix, tree->subroutine_number, call_suffix);
1566 printf (" if (tem != 0) return tem;\n");
1568 printf (" if (tem >= 0) return tem;\n");
1569 change_state (tree->position, afterward->position, 2);
1570 printf (" goto L%d;\n", afterward->number);
1573 printf (" return %s_%d (x0, insn%s);\n",
1574 name_prefix, tree->subroutine_number, call_suffix);
1578 write_tree_1 (tree, prevpos, afterward, type);
1580 for (p = tree; p; p = p->next)
1581 if (p->success.first)
1582 write_tree (p->success.first, p->position,
1583 p->afterward ? p->afterward : afterward, 0, type);
1587 /* Assuming that the state of argument is denoted by OLDPOS, take whatever
1588 actions are necessary to move to NEWPOS.
1590 INDENT says how many blanks to place at the front of lines. */
1593 change_state (oldpos, newpos, indent)
1598 int odepth = strlen (oldpos);
1600 int ndepth = strlen (newpos);
1602 /* Pop up as many levels as necessary. */
1604 while (strncmp (oldpos, newpos, depth))
1607 /* Go down to desired level. */
1609 while (depth < ndepth)
1611 if (newpos[depth] >= 'a' && newpos[depth] <= 'z')
1612 printf ("%sx%d = XVECEXP (x%d, 0, %d);\n",
1613 indents[indent], depth + 1, depth, newpos[depth] - 'a');
1615 printf ("%sx%d = XEXP (x%d, %c);\n",
1616 indents[indent], depth + 1, depth, newpos[depth]);
1630 tem = (char *) xmalloc (strlen (s1) + 1);
1639 register unsigned length;
1641 while (length-- > 0)
1646 mybcopy (in, out, length)
1647 register char *in, *out;
1648 register unsigned length;
1650 while (length-- > 0)
1655 xrealloc (ptr, size)
1659 char *result = (char *) realloc (ptr, size);
1661 fatal ("virtual memory exhausted");
1669 register char *val = (char *) malloc (size);
1672 fatal ("virtual memory exhausted");
1680 fprintf (stderr, "genrecog: ");
1681 fprintf (stderr, s);
1682 fprintf (stderr, "\n");
1683 fprintf (stderr, "after %d definitions\n", next_index);
1684 exit (FATAL_EXIT_CODE);
1687 /* More 'friendly' abort that prints the line and file.
1688 config.h can #define abort fancy_abort if you like that sort of thing. */
1693 fatal ("Internal gcc abort.");
1702 struct decision_head recog_tree;
1703 struct decision_head split_tree;
1707 obstack_init (rtl_obstack);
1708 recog_tree.first = recog_tree.last = split_tree.first = split_tree.last = 0;
1711 fatal ("No input file name.");
1713 infile = fopen (argv[1], "r");
1717 exit (FATAL_EXIT_CODE);
1724 printf ("/* Generated automatically by the program `genrecog'\n\
1725 from the machine description file `md'. */\n\n");
1727 printf ("#include \"config.h\"\n");
1728 printf ("#include <stdio.h>\n");
1729 printf ("#include \"rtl.h\"\n");
1730 printf ("#include \"insn-config.h\"\n");
1731 printf ("#include \"recog.h\"\n");
1732 printf ("#include \"real.h\"\n");
1733 printf ("#include \"output.h\"\n");
1734 printf ("#include \"flags.h\"\n");
1737 /* Read the machine description. */
1741 c = read_skip_spaces (infile);
1746 desc = read_rtx (infile);
1747 if (GET_CODE (desc) == DEFINE_INSN)
1748 recog_tree = merge_trees (recog_tree,
1749 make_insn_sequence (desc, RECOG));
1750 else if (GET_CODE (desc) == DEFINE_SPLIT)
1751 split_tree = merge_trees (split_tree,
1752 make_insn_sequence (desc, SPLIT));
1753 if (GET_CODE (desc) == DEFINE_PEEPHOLE
1754 || GET_CODE (desc) == DEFINE_EXPAND)
1760 /* `recog' contains a decision tree\n\
1761 that recognizes whether the rtx X0 is a valid instruction.\n\
1763 recog returns -1 if the rtx is not valid.\n\
1764 If the rtx is valid, recog returns a nonnegative number\n\
1765 which is the insn code number for the pattern that matched.\n");
1766 printf (" This is the same as the order in the machine description of\n\
1767 the entry that matched. This number can be used as an index into various\n\
1768 insn_* tables, such as insn_templates, insn_outfun, and insn_n_operands\n\
1769 (found in insn-output.c).\n\n");
1770 printf (" The third argument to recog is an optional pointer to an int.\n\
1771 If present, recog will accept a pattern if it matches except for\n\
1772 missing CLOBBER expressions at the end. In that case, the value\n\
1773 pointed to by the optional pointer will be set to the number of\n\
1774 CLOBBERs that need to be added (it should be initialized to zero by\n\
1775 the caller). If it is set nonzero, the caller should allocate a\n\
1776 PARALLEL of the appropriate size, copy the initial entries, and call\n\
1777 add_clobbers (found in insn-emit.c) to fill in the CLOBBERs.");
1779 if (split_tree.first)
1780 printf ("\n\n The function split_insns returns 0 if the rtl could not\n\
1781 be split or the split rtl in a SEQUENCE if it can be.");
1785 printf ("rtx recog_operand[MAX_RECOG_OPERANDS];\n\n");
1786 printf ("rtx *recog_operand_loc[MAX_RECOG_OPERANDS];\n\n");
1787 printf ("rtx *recog_dup_loc[MAX_DUP_OPERANDS];\n\n");
1788 printf ("char recog_dup_num[MAX_DUP_OPERANDS];\n\n");
1789 printf ("#define operands recog_operand\n\n");
1791 next_subroutine_number = 0;
1792 break_out_subroutines (recog_tree, RECOG, 1);
1793 write_subroutine (recog_tree.first, RECOG);
1795 next_subroutine_number = 0;
1796 break_out_subroutines (split_tree, SPLIT, 1);
1797 write_subroutine (split_tree.first, SPLIT);
1800 exit (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);