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. */
54 #define OUTPUT_LABEL(INDENT_STRING, LABEL_NUMBER) \
55 printf("%sL%d: ATTRIBUTE_UNUSED_LABEL\n", (INDENT_STRING), (LABEL_NUMBER))
57 static struct obstack obstack;
58 struct obstack *rtl_obstack = &obstack;
60 #define obstack_chunk_alloc xmalloc
61 #define obstack_chunk_free free
63 /* Holds an array of names indexed by insn_code_number. */
64 char **insn_name_ptr = 0;
65 int insn_name_ptr_size = 0;
67 /* Data structure for a listhead of decision trees. The alternatives
68 to a node are kept in a doublely-linked list so we can easily add nodes
69 to the proper place when merging. */
71 struct decision_head { struct decision *first, *last; };
73 /* Data structure for decision tree for recognizing
74 legitimate instructions. */
78 int number; /* Node number, used for labels */
79 char *position; /* String denoting position in pattern */
80 RTX_CODE code; /* Code to test for or UNKNOWN to suppress */
81 char ignore_code; /* If non-zero, need not test code */
82 char ignore_mode; /* If non-zero, need not test mode */
83 int veclen; /* Length of vector, if nonzero */
84 enum machine_mode mode; /* Machine mode of node */
85 char enforce_mode; /* If non-zero, test `mode' */
86 char retest_code, retest_mode; /* See write_tree_1 */
87 int test_elt_zero_int; /* Nonzero if should test XINT (rtl, 0) */
88 int elt_zero_int; /* Required value for XINT (rtl, 0) */
89 int test_elt_one_int; /* Nonzero if should test XINT (rtl, 1) */
90 int elt_one_int; /* Required value for XINT (rtl, 1) */
91 int test_elt_zero_wide; /* Nonzero if should test XWINT (rtl, 0) */
92 HOST_WIDE_INT elt_zero_wide; /* Required value for XWINT (rtl, 0) */
93 const char *tests; /* If nonzero predicate to call */
94 int pred; /* `preds' index of predicate or -1 */
95 char *c_test; /* Additional test to perform */
96 struct decision_head success; /* Nodes to test on success */
97 int insn_code_number; /* Insn number matched, if success */
98 int num_clobbers_to_add; /* Number of CLOBBERs to be added to pattern */
99 struct decision *next; /* Node to test on failure */
100 struct decision *prev; /* Node whose failure tests us */
101 struct decision *afterward; /* Node to test on success, but failure of
103 int opno; /* Operand number, if >= 0 */
104 int dupno; /* Number of operand to compare against */
105 int label_needed; /* Nonzero if label needed when writing tree */
106 int subroutine_number; /* Number of subroutine this node starts */
109 #define SUBROUTINE_THRESHOLD 50
111 static int next_subroutine_number;
113 /* We can write two types of subroutines: One for insn recognition and
114 one to split insns. This defines which type is being written. */
116 enum routine_type {RECOG, SPLIT};
118 /* Next available node number for tree nodes. */
120 static int next_number;
122 /* Next number to use as an insn_code. */
124 static int next_insn_code;
126 /* Similar, but counts all expressions in the MD file; used for
129 static int next_index;
131 /* Record the highest depth we ever have so we know how many variables to
132 allocate in each subroutine we make. */
134 static int max_depth;
136 /* This table contains a list of the rtl codes that can possibly match a
137 predicate defined in recog.c. The function `not_both_true' uses it to
138 deduce that there are no expressions that can be matches by certain pairs
139 of tree nodes. Also, if a predicate can match only one code, we can
140 hardwire that code into the node testing the predicate. */
142 static struct pred_table
145 RTX_CODE codes[NUM_RTX_CODE];
147 = {{"general_operand", {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF,
148 LABEL_REF, SUBREG, REG, MEM}},
149 #ifdef PREDICATE_CODES
152 {"address_operand", {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF,
153 LABEL_REF, SUBREG, REG, MEM, PLUS, MINUS, MULT}},
154 {"register_operand", {SUBREG, REG}},
155 {"scratch_operand", {SCRATCH, REG}},
156 {"immediate_operand", {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF,
158 {"const_int_operand", {CONST_INT}},
159 {"const_double_operand", {CONST_INT, CONST_DOUBLE}},
160 {"nonimmediate_operand", {SUBREG, REG, MEM}},
161 {"nonmemory_operand", {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF,
162 LABEL_REF, SUBREG, REG}},
163 {"push_operand", {MEM}},
164 {"memory_operand", {SUBREG, MEM}},
165 {"indirect_operand", {SUBREG, MEM}},
166 {"comparison_operator", {EQ, NE, LE, LT, GE, GT, LEU, LTU, GEU, GTU}},
167 {"mode_independent_operand", {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF,
168 LABEL_REF, SUBREG, REG, MEM}}};
170 #define NUM_KNOWN_PREDS (sizeof preds / sizeof preds[0])
172 static struct decision_head make_insn_sequence PROTO((rtx, enum routine_type));
173 static struct decision *add_to_sequence PROTO((rtx, struct decision_head *,
175 static int not_both_true PROTO((struct decision *, struct decision *,
177 static int position_merit PROTO((struct decision *, enum machine_mode,
179 static struct decision_head merge_trees PROTO((struct decision_head,
180 struct decision_head));
181 static int break_out_subroutines PROTO((struct decision_head,
182 enum routine_type, int));
183 static void write_subroutine PROTO((struct decision *, enum routine_type));
184 static void write_tree_1 PROTO((struct decision *, const char *,
185 struct decision *, enum routine_type));
186 static void print_code PROTO((enum rtx_code));
187 static int same_codes PROTO((struct decision *, enum rtx_code));
188 static void clear_codes PROTO((struct decision *));
189 static int same_modes PROTO((struct decision *, enum machine_mode));
190 static void clear_modes PROTO((struct decision *));
191 static void write_tree PROTO((struct decision *, const char *,
192 struct decision *, int,
194 static void change_state PROTO((const char *, const char *, int));
195 static void fatal PVPROTO((const char *, ...))
196 ATTRIBUTE_PRINTF_1 ATTRIBUTE_NORETURN;
197 void fancy_abort PROTO((void)) ATTRIBUTE_NORETURN;
199 /* Construct and return a sequence of decisions
200 that will recognize INSN.
202 TYPE says what type of routine we are recognizing (RECOG or SPLIT). */
204 static struct decision_head
205 make_insn_sequence (insn, type)
207 enum routine_type type;
210 char *c_test = XSTR (insn, type == RECOG ? 2 : 1);
211 struct decision *last;
212 struct decision_head head;
215 static char *last_real_name = "insn";
216 static int last_real_code = 0;
219 if (insn_name_ptr_size <= next_insn_code)
222 new_size = (insn_name_ptr_size ? insn_name_ptr_size * 2 : 512);
223 insn_name_ptr = xrealloc (insn_name_ptr, sizeof(char *) * new_size);
224 bzero (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 ();\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;
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 ("rtx\nsplit");
1035 printf ("int\nrecog");
1037 if (tree != 0 && tree->subroutine_number > 0)
1038 printf ("_%d", tree->subroutine_number);
1039 else if (type == SPLIT)
1042 printf (" (x0, insn");
1044 printf (", pnum_clobbers");
1047 printf (" register rtx x0;\n rtx insn ATTRIBUTE_UNUSED;\n");
1049 printf (" int *pnum_clobbers ATTRIBUTE_UNUSED;\n");
1052 printf (" register rtx *ro = &recog_operand[0];\n");
1054 printf (" register rtx ");
1055 for (i = 1; i < max_depth; i++)
1056 printf ("x%d ATTRIBUTE_UNUSED, ", i);
1058 printf ("x%d ATTRIBUTE_UNUSED;\n", max_depth);
1059 printf (" %s tem ATTRIBUTE_UNUSED;\n", type == SPLIT ? "rtx" : "int");
1060 write_tree (tree, "", NULL_PTR, 1, type);
1061 printf (" ret0: return %d;\n}\n\n", type == SPLIT ? 0 : -1);
1064 /* This table is used to indent the recog_* functions when we are inside
1065 conditions or switch statements. We only support small indentations
1066 and always indent at least two spaces. */
1068 static const char *indents[]
1069 = {" ", " ", " ", " ", " ", " ", " ", " ",
1070 "\t", "\t ", "\t ", "\t ", "\t ", "\t ", "\t ",
1071 "\t\t", "\t\t ", "\t\t ", "\t\t ", "\t\t ", "\t\t "};
1073 /* Write out C code to perform the decisions in TREE for a subroutine of
1074 type TYPE. If all of the choices fail, branch to node AFTERWARD, if
1075 non-zero, otherwise return. PREVPOS is the position of the node that
1076 branched to this test.
1078 When we merged all alternatives, we tried to set up a convenient order.
1079 Specifically, tests involving the same mode are all grouped together,
1080 followed by a group that does not contain a mode test. Within each group
1081 of the same mode, we also group tests with the same code, followed by a
1082 group that does not test a code.
1084 Occasionally, we cannot arbitrarily reorder the tests so that multiple
1085 sequence of groups as described above are present.
1087 We generate two nested switch statements, the outer statement for
1088 testing modes, and the inner switch for testing RTX codes. It is
1089 not worth optimizing cases when only a small number of modes or
1090 codes is tested, since the compiler can do that when compiling the
1091 resulting function. We do check for when every test is the same mode
1095 write_tree_1 (tree, prevpos, afterward, type)
1096 struct decision *tree;
1097 const char *prevpos;
1098 struct decision *afterward;
1099 enum routine_type type;
1101 register struct decision *p, *p1;
1102 register int depth = tree ? strlen (tree->position) : 0;
1103 enum machine_mode switch_mode = VOIDmode;
1104 RTX_CODE switch_code = UNKNOWN;
1106 char modemap[NUM_MACHINE_MODES];
1107 char codemap[NUM_RTX_CODE];
1111 /* One tricky area is what is the exact state when we branch to a
1112 node's label. There are two cases where we branch: when looking at
1113 successors to a node, or when a set of tests fails.
1115 In the former case, we are always branching to the first node in a
1116 decision list and we want all required tests to be performed. We
1117 put the labels for such nodes in front of any switch or test statements.
1118 These branches are done without updating the position to that of the
1121 In the latter case, we are branching to a node that is not the first
1122 node in a decision list. We have already checked that it is possible
1123 for both the node we originally tested at this level and the node we
1124 are branching to to both match some pattern. That means that they
1125 usually will be testing the same mode and code. So it is normally safe
1126 for such labels to be inside switch statements, since the tests done
1127 by virtue of arriving at that label will usually already have been
1128 done. The exception is a branch from a node that does not test a
1129 mode or code to one that does. In such cases, we set the `retest_mode'
1130 or `retest_code' flags. That will ensure that we start a new switch
1131 at that position and put the label before the switch.
1133 The branches in the latter case must set the position to that of the
1138 if (tree && tree->subroutine_number == 0)
1140 OUTPUT_LABEL (" ", tree->number);
1141 tree->label_needed = 0;
1146 change_state (prevpos, tree->position, 2);
1147 prevpos = tree->position;
1150 for (p = tree; p; p = p->next)
1152 enum machine_mode mode = p->enforce_mode ? p->mode : VOIDmode;
1154 int wrote_bracket = 0;
1157 if (p->success.first == 0 && p->insn_code_number < 0)
1160 /* Find the next alternative to p that might be true when p is true.
1161 Test that one next if p's successors fail. */
1163 for (p1 = p->next; p1 && not_both_true (p, p1, 1); p1 = p1->next)
1169 if (mode == VOIDmode && p1->enforce_mode && p1->mode != VOIDmode)
1170 p1->retest_mode = 1;
1171 if (p->code == UNKNOWN && p1->code != UNKNOWN)
1172 p1->retest_code = 1;
1173 p1->label_needed = 1;
1176 /* If we have a different code or mode than the last node and
1177 are in a switch on codes, we must either end the switch or
1178 go to another case. We must also end the switch if this
1179 node needs a label and to retest either the mode or code. */
1181 if (switch_code != UNKNOWN
1182 && (switch_code != p->code || switch_mode != mode
1183 || (p->label_needed && (p->retest_mode || p->retest_code))))
1185 enum rtx_code code = p->code;
1187 /* If P is testing a predicate that we know about and we haven't
1188 seen any of the codes that are valid for the predicate, we
1189 can write a series of "case" statement, one for each possible
1190 code. Since we are already in a switch, these redundant tests
1191 are very cheap and will reduce the number of predicate called. */
1195 for (i = 0; i < NUM_RTX_CODE && preds[p->pred].codes[i] != 0; i++)
1196 if (codemap[(int) preds[p->pred].codes[i]])
1199 if (preds[p->pred].codes[i] == 0)
1200 code = MATCH_OPERAND;
1203 if (code == UNKNOWN || codemap[(int) code]
1204 || switch_mode != mode
1205 || (p->label_needed && (p->retest_mode || p->retest_code)))
1207 printf ("%s}\n", indents[indent - 2]);
1208 switch_code = UNKNOWN;
1214 printf ("%sbreak;\n", indents[indent]);
1216 if (code == MATCH_OPERAND)
1218 for (i = 0; i < NUM_RTX_CODE && preds[p->pred].codes[i] != 0; i++)
1220 printf ("%scase ", indents[indent - 2]);
1221 print_code (preds[p->pred].codes[i]);
1223 codemap[(int) preds[p->pred].codes[i]] = 1;
1228 printf ("%scase ", indents[indent - 2]);
1231 codemap[(int) p->code] = 1;
1240 /* If we were previously in a switch on modes and now have a different
1241 mode, end at least the case, and maybe end the switch if we are
1242 not testing a mode or testing a mode whose case we already saw. */
1244 if (switch_mode != VOIDmode
1245 && (switch_mode != mode || (p->label_needed && p->retest_mode)))
1247 if (mode == VOIDmode || modemap[(int) mode]
1248 || (p->label_needed && p->retest_mode))
1250 printf ("%s}\n", indents[indent - 2]);
1251 switch_mode = VOIDmode;
1257 printf (" break;\n");
1258 printf (" case %smode:\n", GET_MODE_NAME (mode));
1260 modemap[(int) mode] = 1;
1266 /* If we are about to write dead code, something went wrong. */
1267 if (! p->label_needed && uncond)
1270 /* If we need a label and we will want to retest the mode or code at
1271 that label, write the label now. We have already ensured that
1272 things will be valid for the test. */
1274 if (p->label_needed && (p->retest_mode || p->retest_code))
1276 OUTPUT_LABEL (indents[indent - 2], p->number);
1277 p->label_needed = 0;
1282 /* If we are not in any switches, see if we can shortcut things
1283 by checking for identical modes and codes. */
1285 if (switch_mode == VOIDmode && switch_code == UNKNOWN)
1287 /* If p and its alternatives all want the same mode,
1288 reject all others at once, first, then ignore the mode. */
1290 if (mode != VOIDmode && p->next && same_modes (p, mode))
1292 printf (" if (GET_MODE (x%d) != %smode)\n",
1293 depth, GET_MODE_NAME (p->mode));
1297 change_state (p->position, afterward->position, 6);
1298 printf (" goto L%d;\n }\n", afterward->number);
1301 printf (" goto ret0;\n");
1306 /* If p and its alternatives all want the same code,
1307 reject all others at once, first, then ignore the code. */
1309 if (p->code != UNKNOWN && p->next && same_codes (p, p->code))
1311 printf (" if (GET_CODE (x%d) != ", depth);
1312 print_code (p->code);
1317 change_state (p->position, afterward->position, indent + 4);
1318 printf (" goto L%d;\n }\n", afterward->number);
1321 printf (" goto ret0;\n");
1326 /* If we are not in a mode switch and we are testing for a specific
1327 mode, start a mode switch unless we have just one node or the next
1328 node is not testing a mode (we have already tested for the case of
1329 more than one mode, but all of the same mode). */
1331 if (switch_mode == VOIDmode && mode != VOIDmode && p->next != 0
1332 && p->next->enforce_mode && p->next->mode != VOIDmode)
1334 memset (modemap, 0, sizeof modemap);
1335 printf ("%sswitch (GET_MODE (x%d))\n", indents[indent], depth);
1336 printf ("%s{\n", indents[indent + 2]);
1338 printf ("%sdefault:\n%sbreak;\n", indents[indent - 2],
1340 printf ("%scase %smode:\n", indents[indent - 2],
1341 GET_MODE_NAME (mode));
1342 modemap[(int) mode] = 1;
1346 /* Similarly for testing codes. */
1348 if (switch_code == UNKNOWN && p->code != UNKNOWN && ! p->ignore_code
1349 && p->next != 0 && p->next->code != UNKNOWN)
1351 memset (codemap, 0, sizeof codemap);
1352 printf ("%sswitch (GET_CODE (x%d))\n", indents[indent], depth);
1353 printf ("%s{\n", indents[indent + 2]);
1355 printf ("%sdefault:\n%sbreak;\n", indents[indent - 2],
1357 printf ("%scase ", indents[indent - 2]);
1358 print_code (p->code);
1360 codemap[(int) p->code] = 1;
1361 switch_code = p->code;
1364 /* Now that most mode and code tests have been done, we can write out
1365 a label for an inner node, if we haven't already. */
1366 if (p->label_needed)
1367 OUTPUT_LABEL (indents[indent - 2], p->number);
1369 inner_indent = indent;
1371 /* The only way we can have to do a mode or code test here is if
1372 this node needs such a test but is the only node to be tested.
1373 In that case, we won't have started a switch. Note that this is
1374 the only way the switch and test modes can disagree. */
1376 if ((mode != switch_mode && ! p->ignore_mode)
1377 || (p->code != switch_code && p->code != UNKNOWN && ! p->ignore_code)
1378 || p->test_elt_zero_int || p->test_elt_one_int
1379 || p->test_elt_zero_wide || p->veclen
1380 || p->dupno >= 0 || p->tests || p->num_clobbers_to_add)
1382 printf ("%sif (", indents[indent]);
1384 if (mode != switch_mode && ! p->ignore_mode)
1385 printf ("GET_MODE (x%d) == %smode && ",
1386 depth, GET_MODE_NAME (mode));
1387 if (p->code != switch_code && p->code != UNKNOWN && ! p->ignore_code)
1389 printf ("GET_CODE (x%d) == ", depth);
1390 print_code (p->code);
1394 if (p->test_elt_zero_int)
1395 printf ("XINT (x%d, 0) == %d && ", depth, p->elt_zero_int);
1396 if (p->test_elt_one_int)
1397 printf ("XINT (x%d, 1) == %d && ", depth, p->elt_one_int);
1398 if (p->test_elt_zero_wide)
1400 /* Set offset to 1 iff the number might get propagated to
1401 unsigned long by ANSI C rules, else 0.
1402 Prospective hosts are required to have at least 32 bit
1403 ints, and integer constants in machine descriptions
1404 must fit in 32 bit, thus it suffices to check only
1406 HOST_WIDE_INT offset = p->elt_zero_wide == -2147483647 - 1;
1407 printf ("XWINT (x%d, 0) == ", depth);
1408 printf (HOST_WIDE_INT_PRINT_DEC, p->elt_zero_wide + offset);
1409 printf ("%s && ", offset ? "-1" : "");
1412 printf ("XVECLEN (x%d, 0) == %d && ", depth, p->veclen);
1414 printf ("rtx_equal_p (x%d, ro[%d]) && ", depth, p->dupno);
1415 if (p->num_clobbers_to_add)
1416 printf ("pnum_clobbers != 0 && ");
1418 printf ("%s (x%d, %smode)", p->tests, depth,
1419 GET_MODE_NAME (p->mode));
1429 need_bracket = ! uncond;
1435 printf ("%s{\n", indents[inner_indent]);
1441 printf ("%sro[%d] = x%d;\n", indents[inner_indent], p->opno, depth);
1446 printf ("%sif (%s)\n", indents[inner_indent], p->c_test);
1452 if (p->insn_code_number >= 0)
1455 printf ("%sreturn gen_split_%d (operands);\n",
1456 indents[inner_indent], p->insn_code_number);
1459 if (p->num_clobbers_to_add)
1463 printf ("%s{\n", indents[inner_indent]);
1467 printf ("%s*pnum_clobbers = %d;\n",
1468 indents[inner_indent], p->num_clobbers_to_add);
1469 printf ("%sreturn %d;\n",
1470 indents[inner_indent], p->insn_code_number);
1475 printf ("%s}\n", indents[inner_indent]);
1479 printf ("%sreturn %d;\n",
1480 indents[inner_indent], p->insn_code_number);
1484 printf ("%sgoto L%d;\n", indents[inner_indent],
1485 p->success.first->number);
1488 printf ("%s}\n", indents[inner_indent - 2]);
1491 /* We have now tested all alternatives. End any switches we have open
1492 and branch to the alternative node unless we know that we can't fall
1493 through to the branch. */
1495 if (switch_code != UNKNOWN)
1497 printf ("%s}\n", indents[indent - 2]);
1502 if (switch_mode != VOIDmode)
1504 printf ("%s}\n", indents[indent - 2]);
1517 change_state (prevpos, afterward->position, 2);
1518 printf (" goto L%d;\n", afterward->number);
1521 printf (" goto ret0;\n");
1529 for (p1 = GET_RTX_NAME (code); *p1; p1++)
1531 if (*p1 >= 'a' && *p1 <= 'z')
1532 putchar (*p1 + 'A' - 'a');
1539 same_codes (p, code)
1540 register struct decision *p;
1541 register enum rtx_code code;
1543 for (; p; p = p->next)
1544 if (p->code != code)
1552 register struct decision *p;
1554 for (; p; p = p->next)
1559 same_modes (p, mode)
1560 register struct decision *p;
1561 register enum machine_mode mode;
1563 for (; p; p = p->next)
1564 if ((p->enforce_mode ? p->mode : VOIDmode) != mode)
1572 register struct decision *p;
1574 for (; p; p = p->next)
1575 p->enforce_mode = 0;
1578 /* Write out the decision tree starting at TREE for a subroutine of type TYPE.
1580 PREVPOS is the position at the node that branched to this node.
1582 INITIAL is nonzero if this is the first node we are writing in a subroutine.
1584 If all nodes are false, branch to the node AFTERWARD. */
1587 write_tree (tree, prevpos, afterward, initial, type)
1588 struct decision *tree;
1589 const char *prevpos;
1590 struct decision *afterward;
1592 enum routine_type type;
1594 register struct decision *p;
1595 const char *name_prefix = (type == SPLIT ? "split" : "recog");
1596 const char *call_suffix = (type == SPLIT ? "" : ", pnum_clobbers");
1598 if (! initial && tree->subroutine_number > 0)
1600 OUTPUT_LABEL (" ", tree->number);
1604 printf (" tem = %s_%d (x0, insn%s);\n",
1605 name_prefix, tree->subroutine_number, call_suffix);
1607 printf (" if (tem != 0) return tem;\n");
1609 printf (" if (tem >= 0) return tem;\n");
1610 change_state (tree->position, afterward->position, 2);
1611 printf (" goto L%d;\n", afterward->number);
1614 printf (" return %s_%d (x0, insn%s);\n",
1615 name_prefix, tree->subroutine_number, call_suffix);
1619 write_tree_1 (tree, prevpos, afterward, type);
1621 for (p = tree; p; p = p->next)
1622 if (p->success.first)
1623 write_tree (p->success.first, p->position,
1624 p->afterward ? p->afterward : afterward, 0, type);
1628 /* Assuming that the state of argument is denoted by OLDPOS, take whatever
1629 actions are necessary to move to NEWPOS.
1631 INDENT says how many blanks to place at the front of lines. */
1634 change_state (oldpos, newpos, indent)
1639 int odepth = strlen (oldpos);
1641 int ndepth = strlen (newpos);
1643 /* Pop up as many levels as necessary. */
1645 while (strncmp (oldpos, newpos, depth))
1648 /* Go down to desired level. */
1650 while (depth < ndepth)
1652 if (newpos[depth] >= 'a' && newpos[depth] <= 'z')
1653 printf ("%sx%d = XVECEXP (x%d, 0, %d);\n",
1654 indents[indent], depth + 1, depth, newpos[depth] - 'a');
1656 printf ("%sx%d = XEXP (x%d, %c);\n",
1657 indents[indent], depth + 1, depth, newpos[depth]);
1666 register size_t len = strlen (input) + 1;
1667 register char *output = xmalloc (len);
1668 memcpy (output, input, len);
1673 xrealloc (ptr, size)
1677 register PTR result = (PTR) realloc (ptr, size);
1679 fatal ("virtual memory exhausted");
1687 register PTR val = (PTR) malloc (size);
1690 fatal ("virtual memory exhausted");
1695 fatal VPROTO ((const char *format, ...))
1697 #ifndef ANSI_PROTOTYPES
1702 VA_START (ap, format);
1704 #ifndef ANSI_PROTOTYPES
1705 format = va_arg (ap, const char *);
1708 fprintf (stderr, "genrecog: ");
1709 vfprintf (stderr, format, ap);
1711 fprintf (stderr, "\n");
1712 fprintf (stderr, "after %d definitions\n", next_index);
1713 exit (FATAL_EXIT_CODE);
1716 /* More 'friendly' abort that prints the line and file.
1717 config.h can #define abort fancy_abort if you like that sort of thing. */
1722 fatal ("Internal gcc abort.");
1731 struct decision_head recog_tree;
1732 struct decision_head split_tree;
1736 obstack_init (rtl_obstack);
1737 recog_tree.first = recog_tree.last = split_tree.first = split_tree.last = 0;
1740 fatal ("No input file name.");
1742 infile = fopen (argv[1], "r");
1746 exit (FATAL_EXIT_CODE);
1753 printf ("/* Generated automatically by the program `genrecog'\n\
1754 from the machine description file `md'. */\n\n");
1756 printf ("#include \"config.h\"\n");
1757 printf ("#include \"system.h\"\n");
1758 printf ("#include \"rtl.h\"\n");
1759 printf ("#include \"insn-config.h\"\n");
1760 printf ("#include \"recog.h\"\n");
1761 printf ("#include \"real.h\"\n");
1762 printf ("#include \"output.h\"\n");
1763 printf ("#include \"flags.h\"\n");
1766 /* Read the machine description. */
1770 c = read_skip_spaces (infile);
1775 desc = read_rtx (infile);
1776 if (GET_CODE (desc) == DEFINE_INSN)
1777 recog_tree = merge_trees (recog_tree,
1778 make_insn_sequence (desc, RECOG));
1779 else if (GET_CODE (desc) == DEFINE_SPLIT)
1780 split_tree = merge_trees (split_tree,
1781 make_insn_sequence (desc, SPLIT));
1782 if (GET_CODE (desc) == DEFINE_PEEPHOLE
1783 || GET_CODE (desc) == DEFINE_EXPAND)
1789 /* `recog' contains a decision tree\n\
1790 that recognizes whether the rtx X0 is a valid instruction.\n\
1792 recog returns -1 if the rtx is not valid.\n\
1793 If the rtx is valid, recog returns a nonnegative number\n\
1794 which is the insn code number for the pattern that matched.\n");
1795 printf (" This is the same as the order in the machine description of\n\
1796 the entry that matched. This number can be used as an index into various\n\
1797 insn_* tables, such as insn_templates, insn_outfun, and insn_n_operands\n\
1798 (found in insn-output.c).\n\n");
1799 printf (" The third argument to recog is an optional pointer to an int.\n\
1800 If present, recog will accept a pattern if it matches except for\n\
1801 missing CLOBBER expressions at the end. In that case, the value\n\
1802 pointed to by the optional pointer will be set to the number of\n\
1803 CLOBBERs that need to be added (it should be initialized to zero by\n\
1804 the caller). If it is set nonzero, the caller should allocate a\n\
1805 PARALLEL of the appropriate size, copy the initial entries, and call\n\
1806 add_clobbers (found in insn-emit.c) to fill in the CLOBBERs.");
1808 if (split_tree.first)
1809 printf ("\n\n The function split_insns returns 0 if the rtl could not\n\
1810 be split or the split rtl in a SEQUENCE if it can be.");
1814 printf ("#define operands recog_operand\n\n");
1816 next_subroutine_number = 0;
1817 break_out_subroutines (recog_tree, RECOG, 1);
1818 write_subroutine (recog_tree.first, RECOG);
1820 next_subroutine_number = 0;
1821 break_out_subroutines (split_tree, SPLIT, 1);
1822 write_subroutine (split_tree.first, SPLIT);
1825 exit (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);