1 /* Generate code from machine description to recognize rtl as insns.
2 Copyright (C) 1987, 88, 92-95, 97-98, 1999 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. */
55 #define OUTPUT_LABEL(INDENT_STRING, LABEL_NUMBER) \
56 printf("%sL%d: ATTRIBUTE_UNUSED_LABEL\n", (INDENT_STRING), (LABEL_NUMBER))
58 static struct obstack obstack;
59 struct obstack *rtl_obstack = &obstack;
61 #define obstack_chunk_alloc xmalloc
62 #define obstack_chunk_free free
64 /* Holds an array of names indexed by insn_code_number. */
65 char **insn_name_ptr = 0;
66 int insn_name_ptr_size = 0;
68 /* Data structure for a listhead of decision trees. The alternatives
69 to a node are kept in a doublely-linked list so we can easily add nodes
70 to the proper place when merging. */
72 struct decision_head { struct decision *first, *last; };
74 /* Data structure for decision tree for recognizing
75 legitimate instructions. */
79 int number; /* Node number, used for labels */
80 char *position; /* String denoting position in pattern */
81 RTX_CODE code; /* Code to test for or UNKNOWN to suppress */
82 char ignore_code; /* If non-zero, need not test code */
83 char ignore_mode; /* If non-zero, need not test mode */
84 int veclen; /* Length of vector, if nonzero */
85 enum machine_mode mode; /* Machine mode of node */
86 char enforce_mode; /* If non-zero, test `mode' */
87 char retest_code, retest_mode; /* See write_tree_1 */
88 int test_elt_zero_int; /* Nonzero if should test XINT (rtl, 0) */
89 int elt_zero_int; /* Required value for XINT (rtl, 0) */
90 int test_elt_one_int; /* Nonzero if should test XINT (rtl, 1) */
91 int elt_one_int; /* Required value for XINT (rtl, 1) */
92 int test_elt_zero_wide; /* Nonzero if should test XWINT (rtl, 0) */
93 HOST_WIDE_INT elt_zero_wide; /* Required value for XWINT (rtl, 0) */
94 const char *tests; /* If nonzero predicate to call */
95 int pred; /* `preds' index of predicate or -1 */
96 char *c_test; /* Additional test to perform */
97 struct decision_head success; /* Nodes to test on success */
98 int insn_code_number; /* Insn number matched, if success */
99 int num_clobbers_to_add; /* Number of CLOBBERs to be added to pattern */
100 struct decision *next; /* Node to test on failure */
101 struct decision *prev; /* Node whose failure tests us */
102 struct decision *afterward; /* Node to test on success, but failure of
104 int opno; /* Operand number, if >= 0 */
105 int dupno; /* Number of operand to compare against */
106 int label_needed; /* Nonzero if label needed when writing tree */
107 int subroutine_number; /* Number of subroutine this node starts */
110 #define SUBROUTINE_THRESHOLD 50
112 static int next_subroutine_number;
114 /* We can write two types of subroutines: One for insn recognition and
115 one to split insns. This defines which type is being written. */
117 enum routine_type {RECOG, SPLIT};
119 /* Next available node number for tree nodes. */
121 static int next_number;
123 /* Next number to use as an insn_code. */
125 static int next_insn_code;
127 /* Similar, but counts all expressions in the MD file; used for
130 static int next_index;
132 /* Record the highest depth we ever have so we know how many variables to
133 allocate in each subroutine we make. */
135 static int max_depth;
137 /* This table contains a list of the rtl codes that can possibly match a
138 predicate defined in recog.c. The function `not_both_true' uses it to
139 deduce that there are no expressions that can be matches by certain pairs
140 of tree nodes. Also, if a predicate can match only one code, we can
141 hardwire that code into the node testing the predicate. */
143 static struct pred_table
146 RTX_CODE codes[NUM_RTX_CODE];
148 = {{"general_operand", {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF,
149 LABEL_REF, SUBREG, REG, MEM}},
150 #ifdef PREDICATE_CODES
153 {"address_operand", {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF,
154 LABEL_REF, SUBREG, REG, MEM, PLUS, MINUS, MULT}},
155 {"register_operand", {SUBREG, REG}},
156 {"scratch_operand", {SCRATCH, REG}},
157 {"immediate_operand", {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF,
159 {"const_int_operand", {CONST_INT}},
160 {"const_double_operand", {CONST_INT, CONST_DOUBLE}},
161 {"nonimmediate_operand", {SUBREG, REG, MEM}},
162 {"nonmemory_operand", {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF,
163 LABEL_REF, SUBREG, REG}},
164 {"push_operand", {MEM}},
165 {"pop_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 *, const 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 *, const char *,
194 struct decision *, int,
196 static void change_state PROTO((const char *, const char *, int));
198 /* Construct and return a sequence of decisions
199 that will recognize INSN.
201 TYPE says what type of routine we are recognizing (RECOG or SPLIT). */
203 static struct decision_head
204 make_insn_sequence (insn, type)
206 enum routine_type type;
209 char *c_test = XSTR (insn, type == RECOG ? 2 : 1);
210 struct decision *last;
211 struct decision_head head;
214 static const char *last_real_name = "insn";
215 static int last_real_code = 0;
218 if (insn_name_ptr_size <= next_insn_code)
221 new_size = (insn_name_ptr_size ? insn_name_ptr_size * 2 : 512);
223 (char **) xrealloc (insn_name_ptr, sizeof(char *) * new_size);
224 bzero ((PTR)(insn_name_ptr + insn_name_ptr_size),
225 sizeof(char *) * (new_size - insn_name_ptr_size));
226 insn_name_ptr_size = new_size;
229 name = XSTR (insn, 0);
230 if (!name || name[0] == '\0')
232 name = xmalloc (strlen (last_real_name) + 10);
233 sprintf (name, "%s+%d", last_real_name,
234 next_insn_code - last_real_code);
238 last_real_name = name;
239 last_real_code = next_insn_code;
242 insn_name_ptr[next_insn_code] = name;
245 if (XVECLEN (insn, type == RECOG) == 1)
246 x = XVECEXP (insn, type == RECOG, 0);
249 x = rtx_alloc (PARALLEL);
250 XVEC (x, 0) = XVEC (insn, type == RECOG);
251 PUT_MODE (x, VOIDmode);
254 last = add_to_sequence (x, &head, "");
257 last->c_test = c_test;
258 last->insn_code_number = next_insn_code;
259 last->num_clobbers_to_add = 0;
261 /* If this is not a DEFINE_SPLIT and X is a PARALLEL, see if it ends with a
262 group of CLOBBERs of (hard) registers or MATCH_SCRATCHes. If so, set up
263 to recognize the pattern without these CLOBBERs. */
265 if (type == RECOG && GET_CODE (x) == PARALLEL)
269 for (i = XVECLEN (x, 0); i > 0; i--)
270 if (GET_CODE (XVECEXP (x, 0, i - 1)) != CLOBBER
271 || (GET_CODE (XEXP (XVECEXP (x, 0, i - 1), 0)) != REG
272 && GET_CODE (XEXP (XVECEXP (x, 0, i - 1), 0)) != MATCH_SCRATCH))
275 if (i != XVECLEN (x, 0))
278 struct decision_head clobber_head;
281 new = XVECEXP (x, 0, 0);
286 new = rtx_alloc (PARALLEL);
287 XVEC (new, 0) = rtvec_alloc (i);
288 for (j = i - 1; j >= 0; j--)
289 XVECEXP (new, 0, j) = XVECEXP (x, 0, j);
292 last = add_to_sequence (new, &clobber_head, "");
295 last->c_test = c_test;
296 last->insn_code_number = next_insn_code;
297 last->num_clobbers_to_add = XVECLEN (x, 0) - i;
299 head = merge_trees (head, clobber_head);
306 /* Define the subroutine we will call below and emit in genemit. */
307 printf ("extern rtx gen_split_%d PROTO ((rtx *));\n", last->insn_code_number);
312 /* Create a chain of nodes to verify that an rtl expression matches
315 LAST is a pointer to the listhead in the previous node in the chain (or
316 in the calling function, for the first node).
318 POSITION is the string representing the current position in the insn.
320 A pointer to the final node in the chain is returned. */
322 static struct decision *
323 add_to_sequence (pattern, last, position)
325 struct decision_head *last;
326 const char *position;
328 register RTX_CODE code;
329 register struct decision *new
330 = (struct decision *) xmalloc (sizeof (struct decision));
331 struct decision *this;
333 register const char *fmt;
335 int depth = strlen (position);
338 if (depth > max_depth)
341 new->number = next_number++;
342 new->position = xstrdup (position);
343 new->ignore_code = 0;
344 new->ignore_mode = 0;
345 new->enforce_mode = 1;
346 new->retest_code = new->retest_mode = 0;
348 new->test_elt_zero_int = 0;
349 new->test_elt_one_int = 0;
350 new->test_elt_zero_wide = 0;
351 new->elt_zero_int = 0;
352 new->elt_one_int = 0;
353 new->elt_zero_wide = 0;
357 new->success.first = new->success.last = 0;
358 new->insn_code_number = -1;
359 new->num_clobbers_to_add = 0;
365 new->label_needed = 0;
366 new->subroutine_number = 0;
370 last->first = last->last = new;
372 newpos = (char *) alloca (depth + 2);
373 strcpy (newpos, position);
374 newpos[depth + 1] = 0;
378 new->mode = GET_MODE (pattern);
379 new->code = code = GET_CODE (pattern);
388 new->opno = XINT (pattern, 0);
389 new->code = (code == MATCH_PARALLEL ? PARALLEL : UNKNOWN);
390 new->enforce_mode = 0;
392 if (code == MATCH_SCRATCH)
393 new->tests = "scratch_operand";
395 new->tests = XSTR (pattern, 1);
397 if (*new->tests == 0)
400 /* See if we know about this predicate and save its number. If we do,
401 and it only accepts one code, note that fact. The predicate
402 `const_int_operand' only tests for a CONST_INT, so if we do so we
403 can avoid calling it at all.
405 Finally, if we know that the predicate does not allow CONST_INT, we
406 know that the only way the predicate can match is if the modes match
407 (here we use the kludge of relying on the fact that "address_operand"
408 accepts CONST_INT; otherwise, it would have to be a special case),
409 so we can test the mode (but we need not). This fact should
410 considerably simplify the generated code. */
414 for (i = 0; i < NUM_KNOWN_PREDS; i++)
415 if (! strcmp (preds[i].name, new->tests))
418 int allows_const_int = 0;
422 if (preds[i].codes[1] == 0 && new->code == UNKNOWN)
424 new->code = preds[i].codes[0];
425 if (! strcmp ("const_int_operand", new->tests))
426 new->tests = 0, new->pred = -1;
429 for (j = 0; j < NUM_RTX_CODE && preds[i].codes[j] != 0; j++)
430 if (preds[i].codes[j] == CONST_INT)
431 allows_const_int = 1;
433 if (! allows_const_int)
434 new->enforce_mode = new->ignore_mode= 1;
439 #ifdef PREDICATE_CODES
440 /* If the port has a list of the predicates it uses but omits
442 if (i == NUM_KNOWN_PREDS)
443 fprintf (stderr, "Warning: `%s' not in PREDICATE_CODES\n",
448 if (code == MATCH_OPERATOR || code == MATCH_PARALLEL)
450 for (i = 0; i < (size_t) XVECLEN (pattern, 2); i++)
452 newpos[depth] = i + (code == MATCH_OPERATOR ? '0': 'a');
453 new = add_to_sequence (XVECEXP (pattern, 2, i),
454 &new->success, newpos);
461 new->opno = XINT (pattern, 0);
462 new->dupno = XINT (pattern, 0);
465 for (i = 0; i < (size_t) XVECLEN (pattern, 1); i++)
467 newpos[depth] = i + '0';
468 new = add_to_sequence (XVECEXP (pattern, 1, i),
469 &new->success, newpos);
475 new->dupno = XINT (pattern, 0);
477 new->enforce_mode = 0;
481 pattern = XEXP (pattern, 0);
485 /* The operands of a SET must have the same mode unless one is VOIDmode. */
486 if (GET_MODE (SET_SRC (pattern)) != VOIDmode
487 && GET_MODE (SET_DEST (pattern)) != VOIDmode
488 && GET_MODE (SET_SRC (pattern)) != GET_MODE (SET_DEST (pattern))
489 /* The mode of an ADDRESS_OPERAND is the mode of the memory reference,
490 not the mode of the address. */
491 && ! (GET_CODE (SET_SRC (pattern)) == MATCH_OPERAND
492 && ! strcmp (XSTR (SET_SRC (pattern), 1), "address_operand")))
494 print_rtl (stderr, pattern);
495 fputc ('\n', stderr);
496 fatal ("mode mismatch in SET");
499 new = add_to_sequence (SET_DEST (pattern), &new->success, newpos);
500 this->success.first->enforce_mode = 1;
502 new = add_to_sequence (SET_SRC (pattern), &new->success, newpos);
504 /* If set are setting CC0 from anything other than a COMPARE, we
505 must enforce the mode so that we do not produce ambiguous insns. */
506 if (GET_CODE (SET_DEST (pattern)) == CC0
507 && GET_CODE (SET_SRC (pattern)) != COMPARE)
508 this->success.first->enforce_mode = 1;
513 case STRICT_LOW_PART:
515 new = add_to_sequence (XEXP (pattern, 0), &new->success, newpos);
516 this->success.first->enforce_mode = 1;
520 this->test_elt_one_int = 1;
521 this->elt_one_int = XINT (pattern, 1);
523 new = add_to_sequence (XEXP (pattern, 0), &new->success, newpos);
524 this->success.first->enforce_mode = 1;
530 new = add_to_sequence (XEXP (pattern, 0), &new->success, newpos);
531 this->success.first->enforce_mode = 1;
533 new = add_to_sequence (XEXP (pattern, 1), &new->success, newpos);
535 new = add_to_sequence (XEXP (pattern, 2), &new->success, newpos);
538 case EQ: case NE: case LE: case LT: case GE: case GT:
539 case LEU: case LTU: case GEU: case GTU:
540 /* If the first operand is (cc0), we don't have to do anything
542 if (GET_CODE (XEXP (pattern, 0)) == CC0)
545 /* ... fall through ... */
548 /* Enforce the mode on the first operand to avoid ambiguous insns. */
550 new = add_to_sequence (XEXP (pattern, 0), &new->success, newpos);
551 this->success.first->enforce_mode = 1;
553 new = add_to_sequence (XEXP (pattern, 1), &new->success, newpos);
560 fmt = GET_RTX_FORMAT (code);
561 len = GET_RTX_LENGTH (code);
562 for (i = 0; i < (size_t) len; i++)
564 newpos[depth] = '0' + i;
565 if (fmt[i] == 'e' || fmt[i] == 'u')
566 new = add_to_sequence (XEXP (pattern, i), &new->success, newpos);
567 else if (fmt[i] == 'i' && i == 0)
569 this->test_elt_zero_int = 1;
570 this->elt_zero_int = XINT (pattern, i);
572 else if (fmt[i] == 'i' && i == 1)
574 this->test_elt_one_int = 1;
575 this->elt_one_int = XINT (pattern, i);
577 else if (fmt[i] == 'w' && i == 0)
579 this->test_elt_zero_wide = 1;
580 this->elt_zero_wide = XWINT (pattern, i);
582 else if (fmt[i] == 'E')
585 /* We do not handle a vector appearing as other than
586 the first item, just because nothing uses them
587 and by handling only the special case
588 we can use one element in newpos for either
589 the item number of a subexpression
590 or the element number in a vector. */
593 this->veclen = XVECLEN (pattern, i);
594 for (j = 0; j < XVECLEN (pattern, i); j++)
596 newpos[depth] = 'a' + j;
597 new = add_to_sequence (XVECEXP (pattern, i, j),
598 &new->success, newpos);
601 else if (fmt[i] != '0')
607 /* Return 1 if we can prove that there is no RTL that can match both
608 D1 and D2. Otherwise, return 0 (it may be that there is an RTL that
609 can match both or just that we couldn't prove there wasn't such an RTL).
611 TOPLEVEL is non-zero if we are to only look at the top level and not
612 recursively descend. */
615 not_both_true (d1, d2, toplevel)
616 struct decision *d1, *d2;
619 struct decision *p1, *p2;
621 /* If they are both to test modes and the modes are different, they aren't
622 both true. Similarly for codes, integer elements, and vector lengths. */
624 if ((d1->enforce_mode && d2->enforce_mode
625 && d1->mode != VOIDmode && d2->mode != VOIDmode && d1->mode != d2->mode)
626 || (d1->code != UNKNOWN && d2->code != UNKNOWN && d1->code != d2->code)
627 || (d1->test_elt_zero_int && d2->test_elt_zero_int
628 && d1->elt_zero_int != d2->elt_zero_int)
629 || (d1->test_elt_one_int && d2->test_elt_one_int
630 && d1->elt_one_int != d2->elt_one_int)
631 || (d1->test_elt_zero_wide && d2->test_elt_zero_wide
632 && d1->elt_zero_wide != d2->elt_zero_wide)
633 || (d1->veclen && d2->veclen && d1->veclen != d2->veclen))
636 /* If either is a wild-card MATCH_OPERAND without a predicate, it can match
637 absolutely anything, so we can't say that no intersection is possible.
638 This case is detected by having a zero TESTS field with a code of
641 if ((d1->tests == 0 && d1->code == UNKNOWN)
642 || (d2->tests == 0 && d2->code == UNKNOWN))
645 /* If either has a predicate that we know something about, set things up so
646 that D1 is the one that always has a known predicate. Then see if they
647 have any codes in common. */
649 if (d1->pred >= 0 || d2->pred >= 0)
654 p1 = d1, d1 = d2, d2 = p1;
656 /* If D2 tests an explicit code, see if it is in the list of valid codes
657 for D1's predicate. */
658 if (d2->code != UNKNOWN)
660 for (i = 0; i < NUM_RTX_CODE && preds[d1->pred].codes[i] != 0; i++)
661 if (preds[d1->pred].codes[i] == d2->code)
664 if (preds[d1->pred].codes[i] == 0)
668 /* Otherwise see if the predicates have any codes in common. */
670 else if (d2->pred >= 0)
672 for (i = 0; i < NUM_RTX_CODE && preds[d1->pred].codes[i] != 0; i++)
674 for (j = 0; j < NUM_RTX_CODE; j++)
675 if (preds[d2->pred].codes[j] == 0
676 || preds[d2->pred].codes[j] == preds[d1->pred].codes[i])
679 if (preds[d2->pred].codes[j] != 0)
683 if (preds[d1->pred].codes[i] == 0)
688 /* If we got here, we can't prove that D1 and D2 cannot both be true.
689 If we are only to check the top level, return 0. Otherwise, see if
690 we can prove that all choices in both successors are mutually
691 exclusive. If either does not have any successors, we can't prove
692 they can't both be true. */
694 if (toplevel || d1->success.first == 0 || d2->success.first == 0)
697 for (p1 = d1->success.first; p1; p1 = p1->next)
698 for (p2 = d2->success.first; p2; p2 = p2->next)
699 if (! not_both_true (p1, p2, 0))
705 /* Assuming that we can reorder all the alternatives at a specific point in
706 the tree (see discussion in merge_trees), we would prefer an ordering of
707 nodes where groups of consecutive nodes test the same mode and, within each
708 mode, groups of nodes test the same code. With this order, we can
709 construct nested switch statements, the inner one to test the code and
710 the outer one to test the mode.
712 We would like to list nodes testing for specific codes before those
713 that test predicates to avoid unnecessary function calls. Similarly,
714 tests for specific modes should precede nodes that allow any mode.
716 This function returns the merit (with 0 being the best) of inserting
717 a test involving the specified MODE and CODE after node P. If P is
718 zero, we are to determine the merit of inserting the test at the front
722 position_merit (p, mode, code)
724 enum machine_mode mode;
727 enum machine_mode p_mode;
729 /* The only time the front of the list is anything other than the worst
730 position is if we are testing a mode that isn't VOIDmode. */
732 return mode == VOIDmode ? 3 : 2;
734 p_mode = p->enforce_mode ? p->mode : VOIDmode;
736 /* The best case is if the codes and modes both match. */
737 if (p_mode == mode && p->code== code)
740 /* If the codes don't match, the next best case is if the modes match.
741 In that case, the best position for this node depends on whether
742 we are testing for a specific code or not. If we are, the best place
743 is after some other test for an explicit code and our mode or after
744 the last test in the previous mode if every test in our mode is for
747 If we are testing for UNKNOWN, then the next best case is at the end of
751 && ((p_mode == mode && p->code != UNKNOWN)
752 || (p_mode != mode && p->next
753 && (p->next->enforce_mode ? p->next->mode : VOIDmode) == mode
754 && (p->next->code == UNKNOWN))))
755 || (code == UNKNOWN && p_mode == mode
757 || (p->next->enforce_mode ? p->next->mode : VOIDmode) != mode)))
760 /* The third best case occurs when nothing is testing MODE. If MODE
761 is not VOIDmode, then the third best case is after something of any
762 mode that is not VOIDmode. If we are testing VOIDmode, the third best
763 place is the end of the list. */
766 && ((mode != VOIDmode && p_mode != VOIDmode)
767 || (mode == VOIDmode && p->next == 0)))
770 /* Otherwise, we have the worst case. */
774 /* Merge two decision tree listheads OLDH and ADDH,
775 modifying OLDH destructively, and return the merged tree. */
777 static struct decision_head
778 merge_trees (oldh, addh)
779 register struct decision_head oldh, addh;
781 struct decision *add, *next;
789 /* If we are adding things at different positions, something is wrong. */
790 if (strcmp (oldh.first->position, addh.first->position))
793 for (add = addh.first; add; add = next)
795 enum machine_mode add_mode = add->enforce_mode ? add->mode : VOIDmode;
796 struct decision *best_position = 0;
798 struct decision *old;
802 /* The semantics of pattern matching state that the tests are done in
803 the order given in the MD file so that if an insn matches two
804 patterns, the first one will be used. However, in practice, most,
805 if not all, patterns are unambiguous so that their order is
806 independent. In that case, we can merge identical tests and
807 group all similar modes and codes together.
809 Scan starting from the end of OLDH until we reach a point
810 where we reach the head of the list or where we pass a pattern
811 that could also be true if NEW is true. If we find an identical
812 pattern, we can merge them. Also, record the last node that tests
813 the same code and mode and the last one that tests just the same mode.
815 If we have no match, place NEW after the closest match we found. */
817 for (old = oldh.last; old; old = old->prev)
821 /* If we don't have anything to test except an additional test,
822 do not consider the two nodes equal. If we did, the test below
823 would cause an infinite recursion. */
824 if (old->tests == 0 && old->test_elt_zero_int == 0
825 && old->test_elt_one_int == 0 && old->veclen == 0
826 && old->test_elt_zero_wide == 0
827 && old->dupno == -1 && old->mode == VOIDmode
828 && old->code == UNKNOWN
829 && (old->c_test != 0 || add->c_test != 0))
832 else if ((old->tests == add->tests
833 || (old->pred >= 0 && old->pred == add->pred)
834 || (old->tests && add->tests
835 && !strcmp (old->tests, add->tests)))
836 && old->test_elt_zero_int == add->test_elt_zero_int
837 && old->elt_zero_int == add->elt_zero_int
838 && old->test_elt_one_int == add->test_elt_one_int
839 && old->elt_one_int == add->elt_one_int
840 && old->test_elt_zero_wide == add->test_elt_zero_wide
841 && old->elt_zero_wide == add->elt_zero_wide
842 && old->veclen == add->veclen
843 && old->dupno == add->dupno
844 && old->opno == add->opno
845 && old->code == add->code
846 && old->enforce_mode == add->enforce_mode
847 && old->mode == add->mode)
849 /* If the additional test is not the same, split both nodes
850 into nodes that just contain all things tested before the
851 additional test and nodes that contain the additional test
852 and actions when it is true. This optimization is important
853 because of the case where we have almost identical patterns
854 with different tests on target flags. */
856 if (old->c_test != add->c_test
857 && ! (old->c_test && add->c_test
858 && !strcmp (old->c_test, add->c_test)))
860 if (old->insn_code_number >= 0 || old->opno >= 0)
862 struct decision *split
863 = (struct decision *) xmalloc (sizeof (struct decision));
865 memcpy (split, old, sizeof (struct decision));
867 old->success.first = old->success.last = split;
870 old->insn_code_number = -1;
871 old->num_clobbers_to_add = 0;
873 split->number = next_number++;
874 split->next = split->prev = 0;
875 split->mode = VOIDmode;
876 split->code = UNKNOWN;
878 split->test_elt_zero_int = 0;
879 split->test_elt_one_int = 0;
880 split->test_elt_zero_wide = 0;
886 if (add->insn_code_number >= 0 || add->opno >= 0)
888 struct decision *split
889 = (struct decision *) xmalloc (sizeof (struct decision));
891 memcpy (split, add, sizeof (struct decision));
893 add->success.first = add->success.last = split;
896 add->insn_code_number = -1;
897 add->num_clobbers_to_add = 0;
899 split->number = next_number++;
900 split->next = split->prev = 0;
901 split->mode = VOIDmode;
902 split->code = UNKNOWN;
904 split->test_elt_zero_int = 0;
905 split->test_elt_one_int = 0;
906 split->test_elt_zero_wide = 0;
913 if (old->insn_code_number >= 0 && add->insn_code_number >= 0)
915 /* If one node is for a normal insn and the second is
916 for the base insn with clobbers stripped off, the
917 second node should be ignored. */
919 if (old->num_clobbers_to_add == 0
920 && add->num_clobbers_to_add > 0)
921 /* Nothing to do here. */
923 else if (old->num_clobbers_to_add > 0
924 && add->num_clobbers_to_add == 0)
926 /* In this case, replace OLD with ADD. */
927 old->insn_code_number = add->insn_code_number;
928 old->num_clobbers_to_add = 0;
931 fatal ("Two actions at one point in tree for insns \"%s\" (%d) and \"%s\" (%d)",
932 insn_name_ptr[old->insn_code_number],
933 old->insn_code_number,
934 insn_name_ptr[add->insn_code_number],
935 add->insn_code_number);
938 if (old->insn_code_number == -1)
939 old->insn_code_number = add->insn_code_number;
940 old->success = merge_trees (old->success, add->success);
945 /* Unless we have already found the best possible insert point,
946 see if this position is better. If so, record it. */
949 && ((our_merit = position_merit (old, add_mode, add->code))
951 best_merit = our_merit, best_position = old;
953 if (! not_both_true (old, add, 0))
957 /* If ADD was duplicate, we are done. */
961 /* Otherwise, find the best place to insert ADD. Normally this is
962 BEST_POSITION. However, if we went all the way to the top of
963 the list, it might be better to insert at the top. */
965 if (best_position == 0)
969 && position_merit (NULL_PTR, add_mode, add->code) < best_merit)
972 add->next = oldh.first;
973 oldh.first->prev = add;
979 add->prev = best_position;
980 add->next = best_position->next;
981 best_position->next = add;
982 if (best_position == oldh.last)
985 add->next->prev = add;
992 /* Count the number of subnodes of HEAD. If the number is high enough,
993 make the first node in HEAD start a separate subroutine in the C code
996 TYPE gives the type of routine we are writing.
998 INITIAL is non-zero if this is the highest-level node. We never write
1002 break_out_subroutines (head, type, initial)
1003 struct decision_head head;
1004 enum routine_type type;
1008 struct decision *sub;
1010 for (sub = head.first; sub; sub = sub->next)
1011 size += 1 + break_out_subroutines (sub->success, type, 0);
1013 if (size > SUBROUTINE_THRESHOLD && ! initial)
1015 head.first->subroutine_number = ++next_subroutine_number;
1016 write_subroutine (head.first, type);
1022 /* Write out a subroutine of type TYPE to do comparisons starting at node
1026 write_subroutine (tree, type)
1027 struct decision *tree;
1028 enum routine_type type;
1033 printf ("extern rtx split");
1035 printf ("extern int recog");
1036 if (tree != 0 && tree->subroutine_number > 0)
1037 printf ("_%d", tree->subroutine_number);
1038 else if (type == SPLIT)
1040 printf (" PROTO ((rtx, rtx");
1046 printf ("rtx\nsplit");
1048 printf ("int\nrecog");
1050 if (tree != 0 && tree->subroutine_number > 0)
1051 printf ("_%d", tree->subroutine_number);
1052 else if (type == SPLIT)
1055 printf (" (x0, insn");
1057 printf (", pnum_clobbers");
1060 printf (" register rtx x0;\n rtx insn ATTRIBUTE_UNUSED;\n");
1062 printf (" int *pnum_clobbers ATTRIBUTE_UNUSED;\n");
1065 printf (" register rtx *ro = &recog_operand[0];\n");
1067 printf (" register rtx ");
1068 for (i = 1; i < max_depth; i++)
1069 printf ("x%d ATTRIBUTE_UNUSED, ", i);
1071 printf ("x%d ATTRIBUTE_UNUSED;\n", max_depth);
1072 printf (" %s tem ATTRIBUTE_UNUSED;\n", type == SPLIT ? "rtx" : "int");
1073 write_tree (tree, "", NULL_PTR, 1, type);
1074 printf (" ret0: return %d;\n}\n\n", type == SPLIT ? 0 : -1);
1077 /* This table is used to indent the recog_* functions when we are inside
1078 conditions or switch statements. We only support small indentations
1079 and always indent at least two spaces. */
1081 static const char *indents[]
1082 = {" ", " ", " ", " ", " ", " ", " ", " ",
1083 "\t", "\t ", "\t ", "\t ", "\t ", "\t ", "\t ",
1084 "\t\t", "\t\t ", "\t\t ", "\t\t ", "\t\t ", "\t\t "};
1086 /* Write out C code to perform the decisions in TREE for a subroutine of
1087 type TYPE. If all of the choices fail, branch to node AFTERWARD, if
1088 non-zero, otherwise return. PREVPOS is the position of the node that
1089 branched to this test.
1091 When we merged all alternatives, we tried to set up a convenient order.
1092 Specifically, tests involving the same mode are all grouped together,
1093 followed by a group that does not contain a mode test. Within each group
1094 of the same mode, we also group tests with the same code, followed by a
1095 group that does not test a code.
1097 Occasionally, we cannot arbitrarily reorder the tests so that multiple
1098 sequence of groups as described above are present.
1100 We generate two nested switch statements, the outer statement for
1101 testing modes, and the inner switch for testing RTX codes. It is
1102 not worth optimizing cases when only a small number of modes or
1103 codes is tested, since the compiler can do that when compiling the
1104 resulting function. We do check for when every test is the same mode
1108 write_tree_1 (tree, prevpos, afterward, type)
1109 struct decision *tree;
1110 const char *prevpos;
1111 struct decision *afterward;
1112 enum routine_type type;
1114 register struct decision *p, *p1;
1115 register int depth = tree ? strlen (tree->position) : 0;
1116 enum machine_mode switch_mode = VOIDmode;
1117 RTX_CODE switch_code = UNKNOWN;
1119 char modemap[NUM_MACHINE_MODES];
1120 char codemap[NUM_RTX_CODE];
1124 /* One tricky area is what is the exact state when we branch to a
1125 node's label. There are two cases where we branch: when looking at
1126 successors to a node, or when a set of tests fails.
1128 In the former case, we are always branching to the first node in a
1129 decision list and we want all required tests to be performed. We
1130 put the labels for such nodes in front of any switch or test statements.
1131 These branches are done without updating the position to that of the
1134 In the latter case, we are branching to a node that is not the first
1135 node in a decision list. We have already checked that it is possible
1136 for both the node we originally tested at this level and the node we
1137 are branching to to both match some pattern. That means that they
1138 usually will be testing the same mode and code. So it is normally safe
1139 for such labels to be inside switch statements, since the tests done
1140 by virtue of arriving at that label will usually already have been
1141 done. The exception is a branch from a node that does not test a
1142 mode or code to one that does. In such cases, we set the `retest_mode'
1143 or `retest_code' flags. That will ensure that we start a new switch
1144 at that position and put the label before the switch.
1146 The branches in the latter case must set the position to that of the
1151 if (tree && tree->subroutine_number == 0)
1153 OUTPUT_LABEL (" ", tree->number);
1154 tree->label_needed = 0;
1159 change_state (prevpos, tree->position, 2);
1160 prevpos = tree->position;
1163 for (p = tree; p; p = p->next)
1165 enum machine_mode mode = p->enforce_mode ? p->mode : VOIDmode;
1167 int wrote_bracket = 0;
1170 if (p->success.first == 0 && p->insn_code_number < 0)
1173 /* Find the next alternative to p that might be true when p is true.
1174 Test that one next if p's successors fail. */
1176 for (p1 = p->next; p1 && not_both_true (p, p1, 1); p1 = p1->next)
1182 if (mode == VOIDmode && p1->enforce_mode && p1->mode != VOIDmode)
1183 p1->retest_mode = 1;
1184 if (p->code == UNKNOWN && p1->code != UNKNOWN)
1185 p1->retest_code = 1;
1186 p1->label_needed = 1;
1189 /* If we have a different code or mode than the last node and
1190 are in a switch on codes, we must either end the switch or
1191 go to another case. We must also end the switch if this
1192 node needs a label and to retest either the mode or code. */
1194 if (switch_code != UNKNOWN
1195 && (switch_code != p->code || switch_mode != mode
1196 || (p->label_needed && (p->retest_mode || p->retest_code))))
1198 enum rtx_code code = p->code;
1200 /* If P is testing a predicate that we know about and we haven't
1201 seen any of the codes that are valid for the predicate, we
1202 can write a series of "case" statement, one for each possible
1203 code. Since we are already in a switch, these redundant tests
1204 are very cheap and will reduce the number of predicate called. */
1208 for (i = 0; i < NUM_RTX_CODE && preds[p->pred].codes[i] != 0; i++)
1209 if (codemap[(int) preds[p->pred].codes[i]])
1212 if (preds[p->pred].codes[i] == 0)
1213 code = MATCH_OPERAND;
1216 if (code == UNKNOWN || codemap[(int) code]
1217 || switch_mode != mode
1218 || (p->label_needed && (p->retest_mode || p->retest_code)))
1220 printf ("%s}\n", indents[indent - 2]);
1221 switch_code = UNKNOWN;
1227 printf ("%sbreak;\n", indents[indent]);
1229 if (code == MATCH_OPERAND)
1231 for (i = 0; i < NUM_RTX_CODE && preds[p->pred].codes[i] != 0; i++)
1233 printf ("%scase ", indents[indent - 2]);
1234 print_code (preds[p->pred].codes[i]);
1236 codemap[(int) preds[p->pred].codes[i]] = 1;
1241 printf ("%scase ", indents[indent - 2]);
1244 codemap[(int) p->code] = 1;
1253 /* If we were previously in a switch on modes and now have a different
1254 mode, end at least the case, and maybe end the switch if we are
1255 not testing a mode or testing a mode whose case we already saw. */
1257 if (switch_mode != VOIDmode
1258 && (switch_mode != mode || (p->label_needed && p->retest_mode)))
1260 if (mode == VOIDmode || modemap[(int) mode]
1261 || (p->label_needed && p->retest_mode))
1263 printf ("%s}\n", indents[indent - 2]);
1264 switch_mode = VOIDmode;
1270 printf (" break;\n");
1271 printf (" case %smode:\n", GET_MODE_NAME (mode));
1273 modemap[(int) mode] = 1;
1279 /* If we are about to write dead code, something went wrong. */
1280 if (! p->label_needed && uncond)
1283 /* If we need a label and we will want to retest the mode or code at
1284 that label, write the label now. We have already ensured that
1285 things will be valid for the test. */
1287 if (p->label_needed && (p->retest_mode || p->retest_code))
1289 OUTPUT_LABEL (indents[indent - 2], p->number);
1290 p->label_needed = 0;
1295 /* If we are not in any switches, see if we can shortcut things
1296 by checking for identical modes and codes. */
1298 if (switch_mode == VOIDmode && switch_code == UNKNOWN)
1300 /* If p and its alternatives all want the same mode,
1301 reject all others at once, first, then ignore the mode. */
1303 if (mode != VOIDmode && p->next && same_modes (p, mode))
1305 printf (" if (GET_MODE (x%d) != %smode)\n",
1306 depth, GET_MODE_NAME (p->mode));
1310 change_state (p->position, afterward->position, 6);
1311 printf (" goto L%d;\n }\n", afterward->number);
1314 printf (" goto ret0;\n");
1319 /* If p and its alternatives all want the same code,
1320 reject all others at once, first, then ignore the code. */
1322 if (p->code != UNKNOWN && p->next && same_codes (p, p->code))
1324 printf (" if (GET_CODE (x%d) != ", depth);
1325 print_code (p->code);
1330 change_state (p->position, afterward->position, indent + 4);
1331 printf (" goto L%d;\n }\n", afterward->number);
1334 printf (" goto ret0;\n");
1339 /* If we are not in a mode switch and we are testing for a specific
1340 mode, start a mode switch unless we have just one node or the next
1341 node is not testing a mode (we have already tested for the case of
1342 more than one mode, but all of the same mode). */
1344 if (switch_mode == VOIDmode && mode != VOIDmode && p->next != 0
1345 && p->next->enforce_mode && p->next->mode != VOIDmode)
1347 memset (modemap, 0, sizeof modemap);
1348 printf ("%sswitch (GET_MODE (x%d))\n", indents[indent], depth);
1349 printf ("%s{\n", indents[indent + 2]);
1351 printf ("%sdefault:\n%sbreak;\n", indents[indent - 2],
1353 printf ("%scase %smode:\n", indents[indent - 2],
1354 GET_MODE_NAME (mode));
1355 modemap[(int) mode] = 1;
1359 /* Similarly for testing codes. */
1361 if (switch_code == UNKNOWN && p->code != UNKNOWN && ! p->ignore_code
1362 && p->next != 0 && p->next->code != UNKNOWN)
1364 memset (codemap, 0, sizeof codemap);
1365 printf ("%sswitch (GET_CODE (x%d))\n", indents[indent], depth);
1366 printf ("%s{\n", indents[indent + 2]);
1368 printf ("%sdefault:\n%sbreak;\n", indents[indent - 2],
1370 printf ("%scase ", indents[indent - 2]);
1371 print_code (p->code);
1373 codemap[(int) p->code] = 1;
1374 switch_code = p->code;
1377 /* Now that most mode and code tests have been done, we can write out
1378 a label for an inner node, if we haven't already. */
1379 if (p->label_needed)
1380 OUTPUT_LABEL (indents[indent - 2], p->number);
1382 inner_indent = indent;
1384 /* The only way we can have to do a mode or code test here is if
1385 this node needs such a test but is the only node to be tested.
1386 In that case, we won't have started a switch. Note that this is
1387 the only way the switch and test modes can disagree. */
1389 if ((mode != switch_mode && ! p->ignore_mode)
1390 || (p->code != switch_code && p->code != UNKNOWN && ! p->ignore_code)
1391 || p->test_elt_zero_int || p->test_elt_one_int
1392 || p->test_elt_zero_wide || p->veclen
1393 || p->dupno >= 0 || p->tests || p->num_clobbers_to_add)
1395 printf ("%sif (", indents[indent]);
1397 if (mode != switch_mode && ! p->ignore_mode)
1398 printf ("GET_MODE (x%d) == %smode && ",
1399 depth, GET_MODE_NAME (mode));
1400 if (p->code != switch_code && p->code != UNKNOWN && ! p->ignore_code)
1402 printf ("GET_CODE (x%d) == ", depth);
1403 print_code (p->code);
1407 if (p->test_elt_zero_int)
1408 printf ("XINT (x%d, 0) == %d && ", depth, p->elt_zero_int);
1409 if (p->test_elt_one_int)
1410 printf ("XINT (x%d, 1) == %d && ", depth, p->elt_one_int);
1411 if (p->test_elt_zero_wide)
1413 /* Set offset to 1 iff the number might get propagated to
1414 unsigned long by ANSI C rules, else 0.
1415 Prospective hosts are required to have at least 32 bit
1416 ints, and integer constants in machine descriptions
1417 must fit in 32 bit, thus it suffices to check only
1419 HOST_WIDE_INT offset = p->elt_zero_wide == -2147483647 - 1;
1420 printf ("XWINT (x%d, 0) == ", depth);
1421 printf (HOST_WIDE_INT_PRINT_DEC, p->elt_zero_wide + offset);
1422 printf ("%s && ", offset ? "-1" : "");
1425 printf ("XVECLEN (x%d, 0) == %d && ", depth, p->veclen);
1427 printf ("rtx_equal_p (x%d, ro[%d]) && ", depth, p->dupno);
1428 if (p->num_clobbers_to_add)
1429 printf ("pnum_clobbers != 0 && ");
1431 printf ("%s (x%d, %smode)", p->tests, depth,
1432 GET_MODE_NAME (p->mode));
1442 need_bracket = ! uncond;
1448 printf ("%s{\n", indents[inner_indent]);
1454 printf ("%sro[%d] = x%d;\n", indents[inner_indent], p->opno, depth);
1459 printf ("%sif (%s)\n", indents[inner_indent], p->c_test);
1465 if (p->insn_code_number >= 0)
1468 printf ("%sreturn gen_split_%d (operands);\n",
1469 indents[inner_indent], p->insn_code_number);
1472 if (p->num_clobbers_to_add)
1476 printf ("%s{\n", indents[inner_indent]);
1480 printf ("%s*pnum_clobbers = %d;\n",
1481 indents[inner_indent], p->num_clobbers_to_add);
1482 printf ("%sreturn %d;\n",
1483 indents[inner_indent], p->insn_code_number);
1488 printf ("%s}\n", indents[inner_indent]);
1492 printf ("%sreturn %d;\n",
1493 indents[inner_indent], p->insn_code_number);
1497 printf ("%sgoto L%d;\n", indents[inner_indent],
1498 p->success.first->number);
1501 printf ("%s}\n", indents[inner_indent - 2]);
1504 /* We have now tested all alternatives. End any switches we have open
1505 and branch to the alternative node unless we know that we can't fall
1506 through to the branch. */
1508 if (switch_code != UNKNOWN)
1510 printf ("%s}\n", indents[indent - 2]);
1515 if (switch_mode != VOIDmode)
1517 printf ("%s}\n", indents[indent - 2]);
1530 change_state (prevpos, afterward->position, 2);
1531 printf (" goto L%d;\n", afterward->number);
1534 printf (" goto ret0;\n");
1541 register const char *p1;
1542 for (p1 = GET_RTX_NAME (code); *p1; p1++)
1544 if (*p1 >= 'a' && *p1 <= 'z')
1545 putchar (*p1 + 'A' - 'a');
1552 same_codes (p, code)
1553 register struct decision *p;
1554 register enum rtx_code code;
1556 for (; p; p = p->next)
1557 if (p->code != code)
1565 register struct decision *p;
1567 for (; p; p = p->next)
1572 same_modes (p, mode)
1573 register struct decision *p;
1574 register enum machine_mode mode;
1576 for (; p; p = p->next)
1577 if ((p->enforce_mode ? p->mode : VOIDmode) != mode)
1585 register struct decision *p;
1587 for (; p; p = p->next)
1588 p->enforce_mode = 0;
1591 /* Write out the decision tree starting at TREE for a subroutine of type TYPE.
1593 PREVPOS is the position at the node that branched to this node.
1595 INITIAL is nonzero if this is the first node we are writing in a subroutine.
1597 If all nodes are false, branch to the node AFTERWARD. */
1600 write_tree (tree, prevpos, afterward, initial, type)
1601 struct decision *tree;
1602 const char *prevpos;
1603 struct decision *afterward;
1605 enum routine_type type;
1607 register struct decision *p;
1608 const char *name_prefix = (type == SPLIT ? "split" : "recog");
1609 const char *call_suffix = (type == SPLIT ? "" : ", pnum_clobbers");
1611 if (! initial && tree->subroutine_number > 0)
1613 OUTPUT_LABEL (" ", tree->number);
1617 printf (" tem = %s_%d (x0, insn%s);\n",
1618 name_prefix, tree->subroutine_number, call_suffix);
1620 printf (" if (tem != 0) return tem;\n");
1622 printf (" if (tem >= 0) return tem;\n");
1623 change_state (tree->position, afterward->position, 2);
1624 printf (" goto L%d;\n", afterward->number);
1627 printf (" return %s_%d (x0, insn%s);\n",
1628 name_prefix, tree->subroutine_number, call_suffix);
1632 write_tree_1 (tree, prevpos, afterward, type);
1634 for (p = tree; p; p = p->next)
1635 if (p->success.first)
1636 write_tree (p->success.first, p->position,
1637 p->afterward ? p->afterward : afterward, 0, type);
1641 /* Assuming that the state of argument is denoted by OLDPOS, take whatever
1642 actions are necessary to move to NEWPOS.
1644 INDENT says how many blanks to place at the front of lines. */
1647 change_state (oldpos, newpos, indent)
1652 int odepth = strlen (oldpos);
1654 int ndepth = strlen (newpos);
1656 /* Pop up as many levels as necessary. */
1658 while (strncmp (oldpos, newpos, depth))
1661 /* Go down to desired level. */
1663 while (depth < ndepth)
1665 if (newpos[depth] >= 'a' && newpos[depth] <= 'z')
1666 printf ("%sx%d = XVECEXP (x%d, 0, %d);\n",
1667 indents[indent], depth + 1, depth, newpos[depth] - 'a');
1669 printf ("%sx%d = XEXP (x%d, %c);\n",
1670 indents[indent], depth + 1, depth, newpos[depth]);
1679 register size_t len = strlen (input) + 1;
1680 register char *output = xmalloc (len);
1681 memcpy (output, input, len);
1686 xrealloc (old, size)
1692 ptr = (PTR) realloc (old, size);
1694 ptr = (PTR) malloc (size);
1696 fatal ("virtual memory exhausted");
1704 register PTR val = (PTR) malloc (size);
1707 fatal ("virtual memory exhausted");
1717 struct decision_head recog_tree;
1718 struct decision_head split_tree;
1722 progname = "genrecog";
1723 obstack_init (rtl_obstack);
1724 recog_tree.first = recog_tree.last = split_tree.first = split_tree.last = 0;
1727 fatal ("No input file name.");
1729 infile = fopen (argv[1], "r");
1733 exit (FATAL_EXIT_CODE);
1740 printf ("/* Generated automatically by the program `genrecog'\n\
1741 from the machine description file `md'. */\n\n");
1743 printf ("#include \"config.h\"\n");
1744 printf ("#include \"system.h\"\n");
1745 printf ("#include \"rtl.h\"\n");
1746 printf ("#include \"function.h\"\n");
1747 printf ("#include \"insn-config.h\"\n");
1748 printf ("#include \"recog.h\"\n");
1749 printf ("#include \"real.h\"\n");
1750 printf ("#include \"output.h\"\n");
1751 printf ("#include \"flags.h\"\n");
1754 /* Read the machine description. */
1758 c = read_skip_spaces (infile);
1763 desc = read_rtx (infile);
1764 if (GET_CODE (desc) == DEFINE_INSN)
1765 recog_tree = merge_trees (recog_tree,
1766 make_insn_sequence (desc, RECOG));
1767 else if (GET_CODE (desc) == DEFINE_SPLIT)
1768 split_tree = merge_trees (split_tree,
1769 make_insn_sequence (desc, SPLIT));
1770 if (GET_CODE (desc) == DEFINE_PEEPHOLE
1771 || GET_CODE (desc) == DEFINE_EXPAND)
1777 /* `recog' contains a decision tree\n\
1778 that recognizes whether the rtx X0 is a valid instruction.\n\
1780 recog returns -1 if the rtx is not valid.\n\
1781 If the rtx is valid, recog returns a nonnegative number\n\
1782 which is the insn code number for the pattern that matched.\n");
1783 printf (" This is the same as the order in the machine description of\n\
1784 the entry that matched. This number can be used as an index into various\n\
1785 insn_* tables, such as insn_templates, insn_outfun, and insn_n_operands\n\
1786 (found in insn-output.c).\n\n");
1787 printf (" The third argument to recog is an optional pointer to an int.\n\
1788 If present, recog will accept a pattern if it matches except for\n\
1789 missing CLOBBER expressions at the end. In that case, the value\n\
1790 pointed to by the optional pointer will be set to the number of\n\
1791 CLOBBERs that need to be added (it should be initialized to zero by\n\
1792 the caller). If it is set nonzero, the caller should allocate a\n\
1793 PARALLEL of the appropriate size, copy the initial entries, and call\n\
1794 add_clobbers (found in insn-emit.c) to fill in the CLOBBERs.");
1796 if (split_tree.first)
1797 printf ("\n\n The function split_insns returns 0 if the rtl could not\n\
1798 be split or the split rtl in a SEQUENCE if it can be.");
1802 printf ("#define operands recog_operand\n\n");
1804 next_subroutine_number = 0;
1805 break_out_subroutines (recog_tree, RECOG, 1);
1806 write_subroutine (recog_tree.first, RECOG);
1808 next_subroutine_number = 0;
1809 break_out_subroutines (split_tree, SPLIT, 1);
1810 write_subroutine (split_tree.first, SPLIT);
1813 exit (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);