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 {"pop_operand", {MEM}},
165 {"memory_operand", {SUBREG, MEM}},
166 {"indirect_operand", {SUBREG, MEM}},
167 {"comparison_operator", {EQ, NE, LE, LT, GE, GT, LEU, LTU, GEU, GTU}},
168 {"mode_independent_operand", {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF,
169 LABEL_REF, SUBREG, REG, MEM}}};
171 #define NUM_KNOWN_PREDS (sizeof preds / sizeof preds[0])
173 static struct decision_head make_insn_sequence PROTO((rtx, enum routine_type));
174 static struct decision *add_to_sequence PROTO((rtx, struct decision_head *,
176 static int not_both_true PROTO((struct decision *, struct decision *,
178 static int position_merit PROTO((struct decision *, enum machine_mode,
180 static struct decision_head merge_trees PROTO((struct decision_head,
181 struct decision_head));
182 static int break_out_subroutines PROTO((struct decision_head,
183 enum routine_type, int));
184 static void write_subroutine PROTO((struct decision *, enum routine_type));
185 static void write_tree_1 PROTO((struct decision *, const char *,
186 struct decision *, enum routine_type));
187 static void print_code PROTO((enum rtx_code));
188 static int same_codes PROTO((struct decision *, enum rtx_code));
189 static void clear_codes PROTO((struct decision *));
190 static int same_modes PROTO((struct decision *, enum machine_mode));
191 static void clear_modes PROTO((struct decision *));
192 static void write_tree PROTO((struct decision *, const char *,
193 struct decision *, int,
195 static void change_state PROTO((const char *, const char *, int));
196 void fatal PVPROTO((const char *, ...))
197 ATTRIBUTE_PRINTF_1 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 const 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);
224 (char **) xrealloc (insn_name_ptr, sizeof(char *) * new_size);
225 bzero ((PTR)(insn_name_ptr + insn_name_ptr_size),
226 sizeof(char *) * (new_size - insn_name_ptr_size));
227 insn_name_ptr_size = new_size;
230 name = XSTR (insn, 0);
231 if (!name || name[0] == '\0')
233 name = xmalloc (strlen (last_real_name) + 10);
234 sprintf (name, "%s+%d", last_real_name,
235 next_insn_code - last_real_code);
239 last_real_name = name;
240 last_real_code = next_insn_code;
243 insn_name_ptr[next_insn_code] = name;
246 if (XVECLEN (insn, type == RECOG) == 1)
247 x = XVECEXP (insn, type == RECOG, 0);
250 x = rtx_alloc (PARALLEL);
251 XVEC (x, 0) = XVEC (insn, type == RECOG);
252 PUT_MODE (x, VOIDmode);
255 last = add_to_sequence (x, &head, "");
258 last->c_test = c_test;
259 last->insn_code_number = next_insn_code;
260 last->num_clobbers_to_add = 0;
262 /* If this is not a DEFINE_SPLIT and X is a PARALLEL, see if it ends with a
263 group of CLOBBERs of (hard) registers or MATCH_SCRATCHes. If so, set up
264 to recognize the pattern without these CLOBBERs. */
266 if (type == RECOG && GET_CODE (x) == PARALLEL)
270 for (i = XVECLEN (x, 0); i > 0; i--)
271 if (GET_CODE (XVECEXP (x, 0, i - 1)) != CLOBBER
272 || (GET_CODE (XEXP (XVECEXP (x, 0, i - 1), 0)) != REG
273 && GET_CODE (XEXP (XVECEXP (x, 0, i - 1), 0)) != MATCH_SCRATCH))
276 if (i != XVECLEN (x, 0))
279 struct decision_head clobber_head;
282 new = XVECEXP (x, 0, 0);
287 new = rtx_alloc (PARALLEL);
288 XVEC (new, 0) = rtvec_alloc (i);
289 for (j = i - 1; j >= 0; j--)
290 XVECEXP (new, 0, j) = XVECEXP (x, 0, j);
293 last = add_to_sequence (new, &clobber_head, "");
296 last->c_test = c_test;
297 last->insn_code_number = next_insn_code;
298 last->num_clobbers_to_add = XVECLEN (x, 0) - i;
300 head = merge_trees (head, clobber_head);
307 /* Define the subroutine we will call below and emit in genemit. */
308 printf ("extern rtx gen_split_%d PROTO ((rtx *));\n", last->insn_code_number);
313 /* Create a chain of nodes to verify that an rtl expression matches
316 LAST is a pointer to the listhead in the previous node in the chain (or
317 in the calling function, for the first node).
319 POSITION is the string representing the current position in the insn.
321 A pointer to the final node in the chain is returned. */
323 static struct decision *
324 add_to_sequence (pattern, last, position)
326 struct decision_head *last;
327 const char *position;
329 register RTX_CODE code;
330 register struct decision *new
331 = (struct decision *) xmalloc (sizeof (struct decision));
332 struct decision *this;
334 register const char *fmt;
336 int depth = strlen (position);
339 if (depth > max_depth)
342 new->number = next_number++;
343 new->position = xstrdup (position);
344 new->ignore_code = 0;
345 new->ignore_mode = 0;
346 new->enforce_mode = 1;
347 new->retest_code = new->retest_mode = 0;
349 new->test_elt_zero_int = 0;
350 new->test_elt_one_int = 0;
351 new->test_elt_zero_wide = 0;
352 new->elt_zero_int = 0;
353 new->elt_one_int = 0;
354 new->elt_zero_wide = 0;
358 new->success.first = new->success.last = 0;
359 new->insn_code_number = -1;
360 new->num_clobbers_to_add = 0;
366 new->label_needed = 0;
367 new->subroutine_number = 0;
371 last->first = last->last = new;
373 newpos = (char *) alloca (depth + 2);
374 strcpy (newpos, position);
375 newpos[depth + 1] = 0;
379 new->mode = GET_MODE (pattern);
380 new->code = code = GET_CODE (pattern);
389 new->opno = XINT (pattern, 0);
390 new->code = (code == MATCH_PARALLEL ? PARALLEL : UNKNOWN);
391 new->enforce_mode = 0;
393 if (code == MATCH_SCRATCH)
394 new->tests = "scratch_operand";
396 new->tests = XSTR (pattern, 1);
398 if (*new->tests == 0)
401 /* See if we know about this predicate and save its number. If we do,
402 and it only accepts one code, note that fact. The predicate
403 `const_int_operand' only tests for a CONST_INT, so if we do so we
404 can avoid calling it at all.
406 Finally, if we know that the predicate does not allow CONST_INT, we
407 know that the only way the predicate can match is if the modes match
408 (here we use the kludge of relying on the fact that "address_operand"
409 accepts CONST_INT; otherwise, it would have to be a special case),
410 so we can test the mode (but we need not). This fact should
411 considerably simplify the generated code. */
415 for (i = 0; i < NUM_KNOWN_PREDS; i++)
416 if (! strcmp (preds[i].name, new->tests))
419 int allows_const_int = 0;
423 if (preds[i].codes[1] == 0 && new->code == UNKNOWN)
425 new->code = preds[i].codes[0];
426 if (! strcmp ("const_int_operand", new->tests))
427 new->tests = 0, new->pred = -1;
430 for (j = 0; j < NUM_RTX_CODE && preds[i].codes[j] != 0; j++)
431 if (preds[i].codes[j] == CONST_INT)
432 allows_const_int = 1;
434 if (! allows_const_int)
435 new->enforce_mode = new->ignore_mode= 1;
440 #ifdef PREDICATE_CODES
441 /* If the port has a list of the predicates it uses but omits
443 if (i == NUM_KNOWN_PREDS)
444 fprintf (stderr, "Warning: `%s' not in PREDICATE_CODES\n",
449 if (code == MATCH_OPERATOR || code == MATCH_PARALLEL)
451 for (i = 0; i < (size_t) XVECLEN (pattern, 2); i++)
453 newpos[depth] = i + (code == MATCH_OPERATOR ? '0': 'a');
454 new = add_to_sequence (XVECEXP (pattern, 2, i),
455 &new->success, newpos);
462 new->opno = XINT (pattern, 0);
463 new->dupno = XINT (pattern, 0);
466 for (i = 0; i < (size_t) XVECLEN (pattern, 1); i++)
468 newpos[depth] = i + '0';
469 new = add_to_sequence (XVECEXP (pattern, 1, i),
470 &new->success, newpos);
476 new->dupno = XINT (pattern, 0);
478 new->enforce_mode = 0;
482 pattern = XEXP (pattern, 0);
486 /* The operands of a SET must have the same mode unless one is VOIDmode. */
487 if (GET_MODE (SET_SRC (pattern)) != VOIDmode
488 && GET_MODE (SET_DEST (pattern)) != VOIDmode
489 && GET_MODE (SET_SRC (pattern)) != GET_MODE (SET_DEST (pattern))
490 /* The mode of an ADDRESS_OPERAND is the mode of the memory reference,
491 not the mode of the address. */
492 && ! (GET_CODE (SET_SRC (pattern)) == MATCH_OPERAND
493 && ! strcmp (XSTR (SET_SRC (pattern), 1), "address_operand")))
495 print_rtl (stderr, pattern);
496 fputc ('\n', stderr);
497 fatal ("mode mismatch in SET");
500 new = add_to_sequence (SET_DEST (pattern), &new->success, newpos);
501 this->success.first->enforce_mode = 1;
503 new = add_to_sequence (SET_SRC (pattern), &new->success, newpos);
505 /* If set are setting CC0 from anything other than a COMPARE, we
506 must enforce the mode so that we do not produce ambiguous insns. */
507 if (GET_CODE (SET_DEST (pattern)) == CC0
508 && GET_CODE (SET_SRC (pattern)) != COMPARE)
509 this->success.first->enforce_mode = 1;
514 case STRICT_LOW_PART:
516 new = add_to_sequence (XEXP (pattern, 0), &new->success, newpos);
517 this->success.first->enforce_mode = 1;
521 this->test_elt_one_int = 1;
522 this->elt_one_int = XINT (pattern, 1);
524 new = add_to_sequence (XEXP (pattern, 0), &new->success, newpos);
525 this->success.first->enforce_mode = 1;
531 new = add_to_sequence (XEXP (pattern, 0), &new->success, newpos);
532 this->success.first->enforce_mode = 1;
534 new = add_to_sequence (XEXP (pattern, 1), &new->success, newpos);
536 new = add_to_sequence (XEXP (pattern, 2), &new->success, newpos);
539 case EQ: case NE: case LE: case LT: case GE: case GT:
540 case LEU: case LTU: case GEU: case GTU:
541 /* If the first operand is (cc0), we don't have to do anything
543 if (GET_CODE (XEXP (pattern, 0)) == CC0)
546 /* ... fall through ... */
549 /* Enforce the mode on the first operand to avoid ambiguous insns. */
551 new = add_to_sequence (XEXP (pattern, 0), &new->success, newpos);
552 this->success.first->enforce_mode = 1;
554 new = add_to_sequence (XEXP (pattern, 1), &new->success, newpos);
561 fmt = GET_RTX_FORMAT (code);
562 len = GET_RTX_LENGTH (code);
563 for (i = 0; i < (size_t) len; i++)
565 newpos[depth] = '0' + i;
566 if (fmt[i] == 'e' || fmt[i] == 'u')
567 new = add_to_sequence (XEXP (pattern, i), &new->success, newpos);
568 else if (fmt[i] == 'i' && i == 0)
570 this->test_elt_zero_int = 1;
571 this->elt_zero_int = XINT (pattern, i);
573 else if (fmt[i] == 'i' && i == 1)
575 this->test_elt_one_int = 1;
576 this->elt_one_int = XINT (pattern, i);
578 else if (fmt[i] == 'w' && i == 0)
580 this->test_elt_zero_wide = 1;
581 this->elt_zero_wide = XWINT (pattern, i);
583 else if (fmt[i] == 'E')
586 /* We do not handle a vector appearing as other than
587 the first item, just because nothing uses them
588 and by handling only the special case
589 we can use one element in newpos for either
590 the item number of a subexpression
591 or the element number in a vector. */
594 this->veclen = XVECLEN (pattern, i);
595 for (j = 0; j < XVECLEN (pattern, i); j++)
597 newpos[depth] = 'a' + j;
598 new = add_to_sequence (XVECEXP (pattern, i, j),
599 &new->success, newpos);
602 else if (fmt[i] != '0')
608 /* Return 1 if we can prove that there is no RTL that can match both
609 D1 and D2. Otherwise, return 0 (it may be that there is an RTL that
610 can match both or just that we couldn't prove there wasn't such an RTL).
612 TOPLEVEL is non-zero if we are to only look at the top level and not
613 recursively descend. */
616 not_both_true (d1, d2, toplevel)
617 struct decision *d1, *d2;
620 struct decision *p1, *p2;
622 /* If they are both to test modes and the modes are different, they aren't
623 both true. Similarly for codes, integer elements, and vector lengths. */
625 if ((d1->enforce_mode && d2->enforce_mode
626 && d1->mode != VOIDmode && d2->mode != VOIDmode && d1->mode != d2->mode)
627 || (d1->code != UNKNOWN && d2->code != UNKNOWN && d1->code != d2->code)
628 || (d1->test_elt_zero_int && d2->test_elt_zero_int
629 && d1->elt_zero_int != d2->elt_zero_int)
630 || (d1->test_elt_one_int && d2->test_elt_one_int
631 && d1->elt_one_int != d2->elt_one_int)
632 || (d1->test_elt_zero_wide && d2->test_elt_zero_wide
633 && d1->elt_zero_wide != d2->elt_zero_wide)
634 || (d1->veclen && d2->veclen && d1->veclen != d2->veclen))
637 /* If either is a wild-card MATCH_OPERAND without a predicate, it can match
638 absolutely anything, so we can't say that no intersection is possible.
639 This case is detected by having a zero TESTS field with a code of
642 if ((d1->tests == 0 && d1->code == UNKNOWN)
643 || (d2->tests == 0 && d2->code == UNKNOWN))
646 /* If either has a predicate that we know something about, set things up so
647 that D1 is the one that always has a known predicate. Then see if they
648 have any codes in common. */
650 if (d1->pred >= 0 || d2->pred >= 0)
655 p1 = d1, d1 = d2, d2 = p1;
657 /* If D2 tests an explicit code, see if it is in the list of valid codes
658 for D1's predicate. */
659 if (d2->code != UNKNOWN)
661 for (i = 0; i < NUM_RTX_CODE && preds[d1->pred].codes[i] != 0; i++)
662 if (preds[d1->pred].codes[i] == d2->code)
665 if (preds[d1->pred].codes[i] == 0)
669 /* Otherwise see if the predicates have any codes in common. */
671 else if (d2->pred >= 0)
673 for (i = 0; i < NUM_RTX_CODE && preds[d1->pred].codes[i] != 0; i++)
675 for (j = 0; j < NUM_RTX_CODE; j++)
676 if (preds[d2->pred].codes[j] == 0
677 || preds[d2->pred].codes[j] == preds[d1->pred].codes[i])
680 if (preds[d2->pred].codes[j] != 0)
684 if (preds[d1->pred].codes[i] == 0)
689 /* If we got here, we can't prove that D1 and D2 cannot both be true.
690 If we are only to check the top level, return 0. Otherwise, see if
691 we can prove that all choices in both successors are mutually
692 exclusive. If either does not have any successors, we can't prove
693 they can't both be true. */
695 if (toplevel || d1->success.first == 0 || d2->success.first == 0)
698 for (p1 = d1->success.first; p1; p1 = p1->next)
699 for (p2 = d2->success.first; p2; p2 = p2->next)
700 if (! not_both_true (p1, p2, 0))
706 /* Assuming that we can reorder all the alternatives at a specific point in
707 the tree (see discussion in merge_trees), we would prefer an ordering of
708 nodes where groups of consecutive nodes test the same mode and, within each
709 mode, groups of nodes test the same code. With this order, we can
710 construct nested switch statements, the inner one to test the code and
711 the outer one to test the mode.
713 We would like to list nodes testing for specific codes before those
714 that test predicates to avoid unnecessary function calls. Similarly,
715 tests for specific modes should precede nodes that allow any mode.
717 This function returns the merit (with 0 being the best) of inserting
718 a test involving the specified MODE and CODE after node P. If P is
719 zero, we are to determine the merit of inserting the test at the front
723 position_merit (p, mode, code)
725 enum machine_mode mode;
728 enum machine_mode p_mode;
730 /* The only time the front of the list is anything other than the worst
731 position is if we are testing a mode that isn't VOIDmode. */
733 return mode == VOIDmode ? 3 : 2;
735 p_mode = p->enforce_mode ? p->mode : VOIDmode;
737 /* The best case is if the codes and modes both match. */
738 if (p_mode == mode && p->code== code)
741 /* If the codes don't match, the next best case is if the modes match.
742 In that case, the best position for this node depends on whether
743 we are testing for a specific code or not. If we are, the best place
744 is after some other test for an explicit code and our mode or after
745 the last test in the previous mode if every test in our mode is for
748 If we are testing for UNKNOWN, then the next best case is at the end of
752 && ((p_mode == mode && p->code != UNKNOWN)
753 || (p_mode != mode && p->next
754 && (p->next->enforce_mode ? p->next->mode : VOIDmode) == mode
755 && (p->next->code == UNKNOWN))))
756 || (code == UNKNOWN && p_mode == mode
758 || (p->next->enforce_mode ? p->next->mode : VOIDmode) != mode)))
761 /* The third best case occurs when nothing is testing MODE. If MODE
762 is not VOIDmode, then the third best case is after something of any
763 mode that is not VOIDmode. If we are testing VOIDmode, the third best
764 place is the end of the list. */
767 && ((mode != VOIDmode && p_mode != VOIDmode)
768 || (mode == VOIDmode && p->next == 0)))
771 /* Otherwise, we have the worst case. */
775 /* Merge two decision tree listheads OLDH and ADDH,
776 modifying OLDH destructively, and return the merged tree. */
778 static struct decision_head
779 merge_trees (oldh, addh)
780 register struct decision_head oldh, addh;
782 struct decision *add, *next;
790 /* If we are adding things at different positions, something is wrong. */
791 if (strcmp (oldh.first->position, addh.first->position))
794 for (add = addh.first; add; add = next)
796 enum machine_mode add_mode = add->enforce_mode ? add->mode : VOIDmode;
797 struct decision *best_position = 0;
799 struct decision *old;
803 /* The semantics of pattern matching state that the tests are done in
804 the order given in the MD file so that if an insn matches two
805 patterns, the first one will be used. However, in practice, most,
806 if not all, patterns are unambiguous so that their order is
807 independent. In that case, we can merge identical tests and
808 group all similar modes and codes together.
810 Scan starting from the end of OLDH until we reach a point
811 where we reach the head of the list or where we pass a pattern
812 that could also be true if NEW is true. If we find an identical
813 pattern, we can merge them. Also, record the last node that tests
814 the same code and mode and the last one that tests just the same mode.
816 If we have no match, place NEW after the closest match we found. */
818 for (old = oldh.last; old; old = old->prev)
822 /* If we don't have anything to test except an additional test,
823 do not consider the two nodes equal. If we did, the test below
824 would cause an infinite recursion. */
825 if (old->tests == 0 && old->test_elt_zero_int == 0
826 && old->test_elt_one_int == 0 && old->veclen == 0
827 && old->test_elt_zero_wide == 0
828 && old->dupno == -1 && old->mode == VOIDmode
829 && old->code == UNKNOWN
830 && (old->c_test != 0 || add->c_test != 0))
833 else if ((old->tests == add->tests
834 || (old->pred >= 0 && old->pred == add->pred)
835 || (old->tests && add->tests
836 && !strcmp (old->tests, add->tests)))
837 && old->test_elt_zero_int == add->test_elt_zero_int
838 && old->elt_zero_int == add->elt_zero_int
839 && old->test_elt_one_int == add->test_elt_one_int
840 && old->elt_one_int == add->elt_one_int
841 && old->test_elt_zero_wide == add->test_elt_zero_wide
842 && old->elt_zero_wide == add->elt_zero_wide
843 && old->veclen == add->veclen
844 && old->dupno == add->dupno
845 && old->opno == add->opno
846 && old->code == add->code
847 && old->enforce_mode == add->enforce_mode
848 && old->mode == add->mode)
850 /* If the additional test is not the same, split both nodes
851 into nodes that just contain all things tested before the
852 additional test and nodes that contain the additional test
853 and actions when it is true. This optimization is important
854 because of the case where we have almost identical patterns
855 with different tests on target flags. */
857 if (old->c_test != add->c_test
858 && ! (old->c_test && add->c_test
859 && !strcmp (old->c_test, add->c_test)))
861 if (old->insn_code_number >= 0 || old->opno >= 0)
863 struct decision *split
864 = (struct decision *) xmalloc (sizeof (struct decision));
866 memcpy (split, old, sizeof (struct decision));
868 old->success.first = old->success.last = split;
871 old->insn_code_number = -1;
872 old->num_clobbers_to_add = 0;
874 split->number = next_number++;
875 split->next = split->prev = 0;
876 split->mode = VOIDmode;
877 split->code = UNKNOWN;
879 split->test_elt_zero_int = 0;
880 split->test_elt_one_int = 0;
881 split->test_elt_zero_wide = 0;
887 if (add->insn_code_number >= 0 || add->opno >= 0)
889 struct decision *split
890 = (struct decision *) xmalloc (sizeof (struct decision));
892 memcpy (split, add, sizeof (struct decision));
894 add->success.first = add->success.last = split;
897 add->insn_code_number = -1;
898 add->num_clobbers_to_add = 0;
900 split->number = next_number++;
901 split->next = split->prev = 0;
902 split->mode = VOIDmode;
903 split->code = UNKNOWN;
905 split->test_elt_zero_int = 0;
906 split->test_elt_one_int = 0;
907 split->test_elt_zero_wide = 0;
914 if (old->insn_code_number >= 0 && add->insn_code_number >= 0)
916 /* If one node is for a normal insn and the second is
917 for the base insn with clobbers stripped off, the
918 second node should be ignored. */
920 if (old->num_clobbers_to_add == 0
921 && add->num_clobbers_to_add > 0)
922 /* Nothing to do here. */
924 else if (old->num_clobbers_to_add > 0
925 && add->num_clobbers_to_add == 0)
927 /* In this case, replace OLD with ADD. */
928 old->insn_code_number = add->insn_code_number;
929 old->num_clobbers_to_add = 0;
932 fatal ("Two actions at one point in tree for insns \"%s\" (%d) and \"%s\" (%d)",
933 insn_name_ptr[old->insn_code_number],
934 old->insn_code_number,
935 insn_name_ptr[add->insn_code_number],
936 add->insn_code_number);
939 if (old->insn_code_number == -1)
940 old->insn_code_number = add->insn_code_number;
941 old->success = merge_trees (old->success, add->success);
946 /* Unless we have already found the best possible insert point,
947 see if this position is better. If so, record it. */
950 && ((our_merit = position_merit (old, add_mode, add->code))
952 best_merit = our_merit, best_position = old;
954 if (! not_both_true (old, add, 0))
958 /* If ADD was duplicate, we are done. */
962 /* Otherwise, find the best place to insert ADD. Normally this is
963 BEST_POSITION. However, if we went all the way to the top of
964 the list, it might be better to insert at the top. */
966 if (best_position == 0)
970 && position_merit (NULL_PTR, add_mode, add->code) < best_merit)
973 add->next = oldh.first;
974 oldh.first->prev = add;
980 add->prev = best_position;
981 add->next = best_position->next;
982 best_position->next = add;
983 if (best_position == oldh.last)
986 add->next->prev = add;
993 /* Count the number of subnodes of HEAD. If the number is high enough,
994 make the first node in HEAD start a separate subroutine in the C code
997 TYPE gives the type of routine we are writing.
999 INITIAL is non-zero if this is the highest-level node. We never write
1003 break_out_subroutines (head, type, initial)
1004 struct decision_head head;
1005 enum routine_type type;
1009 struct decision *sub;
1011 for (sub = head.first; sub; sub = sub->next)
1012 size += 1 + break_out_subroutines (sub->success, type, 0);
1014 if (size > SUBROUTINE_THRESHOLD && ! initial)
1016 head.first->subroutine_number = ++next_subroutine_number;
1017 write_subroutine (head.first, type);
1023 /* Write out a subroutine of type TYPE to do comparisons starting at node
1027 write_subroutine (tree, type)
1028 struct decision *tree;
1029 enum routine_type type;
1034 printf ("extern rtx split");
1036 printf ("extern int recog");
1037 if (tree != 0 && tree->subroutine_number > 0)
1038 printf ("_%d", tree->subroutine_number);
1039 else if (type == SPLIT)
1041 printf (" PROTO ((rtx, rtx");
1047 printf ("rtx\nsplit");
1049 printf ("int\nrecog");
1051 if (tree != 0 && tree->subroutine_number > 0)
1052 printf ("_%d", tree->subroutine_number);
1053 else if (type == SPLIT)
1056 printf (" (x0, insn");
1058 printf (", pnum_clobbers");
1061 printf (" register rtx x0;\n rtx insn ATTRIBUTE_UNUSED;\n");
1063 printf (" int *pnum_clobbers ATTRIBUTE_UNUSED;\n");
1066 printf (" register rtx *ro = &recog_operand[0];\n");
1068 printf (" register rtx ");
1069 for (i = 1; i < max_depth; i++)
1070 printf ("x%d ATTRIBUTE_UNUSED, ", i);
1072 printf ("x%d ATTRIBUTE_UNUSED;\n", max_depth);
1073 printf (" %s tem ATTRIBUTE_UNUSED;\n", type == SPLIT ? "rtx" : "int");
1074 write_tree (tree, "", NULL_PTR, 1, type);
1075 printf (" ret0: return %d;\n}\n\n", type == SPLIT ? 0 : -1);
1078 /* This table is used to indent the recog_* functions when we are inside
1079 conditions or switch statements. We only support small indentations
1080 and always indent at least two spaces. */
1082 static const char *indents[]
1083 = {" ", " ", " ", " ", " ", " ", " ", " ",
1084 "\t", "\t ", "\t ", "\t ", "\t ", "\t ", "\t ",
1085 "\t\t", "\t\t ", "\t\t ", "\t\t ", "\t\t ", "\t\t "};
1087 /* Write out C code to perform the decisions in TREE for a subroutine of
1088 type TYPE. If all of the choices fail, branch to node AFTERWARD, if
1089 non-zero, otherwise return. PREVPOS is the position of the node that
1090 branched to this test.
1092 When we merged all alternatives, we tried to set up a convenient order.
1093 Specifically, tests involving the same mode are all grouped together,
1094 followed by a group that does not contain a mode test. Within each group
1095 of the same mode, we also group tests with the same code, followed by a
1096 group that does not test a code.
1098 Occasionally, we cannot arbitrarily reorder the tests so that multiple
1099 sequence of groups as described above are present.
1101 We generate two nested switch statements, the outer statement for
1102 testing modes, and the inner switch for testing RTX codes. It is
1103 not worth optimizing cases when only a small number of modes or
1104 codes is tested, since the compiler can do that when compiling the
1105 resulting function. We do check for when every test is the same mode
1109 write_tree_1 (tree, prevpos, afterward, type)
1110 struct decision *tree;
1111 const char *prevpos;
1112 struct decision *afterward;
1113 enum routine_type type;
1115 register struct decision *p, *p1;
1116 register int depth = tree ? strlen (tree->position) : 0;
1117 enum machine_mode switch_mode = VOIDmode;
1118 RTX_CODE switch_code = UNKNOWN;
1120 char modemap[NUM_MACHINE_MODES];
1121 char codemap[NUM_RTX_CODE];
1125 /* One tricky area is what is the exact state when we branch to a
1126 node's label. There are two cases where we branch: when looking at
1127 successors to a node, or when a set of tests fails.
1129 In the former case, we are always branching to the first node in a
1130 decision list and we want all required tests to be performed. We
1131 put the labels for such nodes in front of any switch or test statements.
1132 These branches are done without updating the position to that of the
1135 In the latter case, we are branching to a node that is not the first
1136 node in a decision list. We have already checked that it is possible
1137 for both the node we originally tested at this level and the node we
1138 are branching to to both match some pattern. That means that they
1139 usually will be testing the same mode and code. So it is normally safe
1140 for such labels to be inside switch statements, since the tests done
1141 by virtue of arriving at that label will usually already have been
1142 done. The exception is a branch from a node that does not test a
1143 mode or code to one that does. In such cases, we set the `retest_mode'
1144 or `retest_code' flags. That will ensure that we start a new switch
1145 at that position and put the label before the switch.
1147 The branches in the latter case must set the position to that of the
1152 if (tree && tree->subroutine_number == 0)
1154 OUTPUT_LABEL (" ", tree->number);
1155 tree->label_needed = 0;
1160 change_state (prevpos, tree->position, 2);
1161 prevpos = tree->position;
1164 for (p = tree; p; p = p->next)
1166 enum machine_mode mode = p->enforce_mode ? p->mode : VOIDmode;
1168 int wrote_bracket = 0;
1171 if (p->success.first == 0 && p->insn_code_number < 0)
1174 /* Find the next alternative to p that might be true when p is true.
1175 Test that one next if p's successors fail. */
1177 for (p1 = p->next; p1 && not_both_true (p, p1, 1); p1 = p1->next)
1183 if (mode == VOIDmode && p1->enforce_mode && p1->mode != VOIDmode)
1184 p1->retest_mode = 1;
1185 if (p->code == UNKNOWN && p1->code != UNKNOWN)
1186 p1->retest_code = 1;
1187 p1->label_needed = 1;
1190 /* If we have a different code or mode than the last node and
1191 are in a switch on codes, we must either end the switch or
1192 go to another case. We must also end the switch if this
1193 node needs a label and to retest either the mode or code. */
1195 if (switch_code != UNKNOWN
1196 && (switch_code != p->code || switch_mode != mode
1197 || (p->label_needed && (p->retest_mode || p->retest_code))))
1199 enum rtx_code code = p->code;
1201 /* If P is testing a predicate that we know about and we haven't
1202 seen any of the codes that are valid for the predicate, we
1203 can write a series of "case" statement, one for each possible
1204 code. Since we are already in a switch, these redundant tests
1205 are very cheap and will reduce the number of predicate called. */
1209 for (i = 0; i < NUM_RTX_CODE && preds[p->pred].codes[i] != 0; i++)
1210 if (codemap[(int) preds[p->pred].codes[i]])
1213 if (preds[p->pred].codes[i] == 0)
1214 code = MATCH_OPERAND;
1217 if (code == UNKNOWN || codemap[(int) code]
1218 || switch_mode != mode
1219 || (p->label_needed && (p->retest_mode || p->retest_code)))
1221 printf ("%s}\n", indents[indent - 2]);
1222 switch_code = UNKNOWN;
1228 printf ("%sbreak;\n", indents[indent]);
1230 if (code == MATCH_OPERAND)
1232 for (i = 0; i < NUM_RTX_CODE && preds[p->pred].codes[i] != 0; i++)
1234 printf ("%scase ", indents[indent - 2]);
1235 print_code (preds[p->pred].codes[i]);
1237 codemap[(int) preds[p->pred].codes[i]] = 1;
1242 printf ("%scase ", indents[indent - 2]);
1245 codemap[(int) p->code] = 1;
1254 /* If we were previously in a switch on modes and now have a different
1255 mode, end at least the case, and maybe end the switch if we are
1256 not testing a mode or testing a mode whose case we already saw. */
1258 if (switch_mode != VOIDmode
1259 && (switch_mode != mode || (p->label_needed && p->retest_mode)))
1261 if (mode == VOIDmode || modemap[(int) mode]
1262 || (p->label_needed && p->retest_mode))
1264 printf ("%s}\n", indents[indent - 2]);
1265 switch_mode = VOIDmode;
1271 printf (" break;\n");
1272 printf (" case %smode:\n", GET_MODE_NAME (mode));
1274 modemap[(int) mode] = 1;
1280 /* If we are about to write dead code, something went wrong. */
1281 if (! p->label_needed && uncond)
1284 /* If we need a label and we will want to retest the mode or code at
1285 that label, write the label now. We have already ensured that
1286 things will be valid for the test. */
1288 if (p->label_needed && (p->retest_mode || p->retest_code))
1290 OUTPUT_LABEL (indents[indent - 2], p->number);
1291 p->label_needed = 0;
1296 /* If we are not in any switches, see if we can shortcut things
1297 by checking for identical modes and codes. */
1299 if (switch_mode == VOIDmode && switch_code == UNKNOWN)
1301 /* If p and its alternatives all want the same mode,
1302 reject all others at once, first, then ignore the mode. */
1304 if (mode != VOIDmode && p->next && same_modes (p, mode))
1306 printf (" if (GET_MODE (x%d) != %smode)\n",
1307 depth, GET_MODE_NAME (p->mode));
1311 change_state (p->position, afterward->position, 6);
1312 printf (" goto L%d;\n }\n", afterward->number);
1315 printf (" goto ret0;\n");
1320 /* If p and its alternatives all want the same code,
1321 reject all others at once, first, then ignore the code. */
1323 if (p->code != UNKNOWN && p->next && same_codes (p, p->code))
1325 printf (" if (GET_CODE (x%d) != ", depth);
1326 print_code (p->code);
1331 change_state (p->position, afterward->position, indent + 4);
1332 printf (" goto L%d;\n }\n", afterward->number);
1335 printf (" goto ret0;\n");
1340 /* If we are not in a mode switch and we are testing for a specific
1341 mode, start a mode switch unless we have just one node or the next
1342 node is not testing a mode (we have already tested for the case of
1343 more than one mode, but all of the same mode). */
1345 if (switch_mode == VOIDmode && mode != VOIDmode && p->next != 0
1346 && p->next->enforce_mode && p->next->mode != VOIDmode)
1348 memset (modemap, 0, sizeof modemap);
1349 printf ("%sswitch (GET_MODE (x%d))\n", indents[indent], depth);
1350 printf ("%s{\n", indents[indent + 2]);
1352 printf ("%sdefault:\n%sbreak;\n", indents[indent - 2],
1354 printf ("%scase %smode:\n", indents[indent - 2],
1355 GET_MODE_NAME (mode));
1356 modemap[(int) mode] = 1;
1360 /* Similarly for testing codes. */
1362 if (switch_code == UNKNOWN && p->code != UNKNOWN && ! p->ignore_code
1363 && p->next != 0 && p->next->code != UNKNOWN)
1365 memset (codemap, 0, sizeof codemap);
1366 printf ("%sswitch (GET_CODE (x%d))\n", indents[indent], depth);
1367 printf ("%s{\n", indents[indent + 2]);
1369 printf ("%sdefault:\n%sbreak;\n", indents[indent - 2],
1371 printf ("%scase ", indents[indent - 2]);
1372 print_code (p->code);
1374 codemap[(int) p->code] = 1;
1375 switch_code = p->code;
1378 /* Now that most mode and code tests have been done, we can write out
1379 a label for an inner node, if we haven't already. */
1380 if (p->label_needed)
1381 OUTPUT_LABEL (indents[indent - 2], p->number);
1383 inner_indent = indent;
1385 /* The only way we can have to do a mode or code test here is if
1386 this node needs such a test but is the only node to be tested.
1387 In that case, we won't have started a switch. Note that this is
1388 the only way the switch and test modes can disagree. */
1390 if ((mode != switch_mode && ! p->ignore_mode)
1391 || (p->code != switch_code && p->code != UNKNOWN && ! p->ignore_code)
1392 || p->test_elt_zero_int || p->test_elt_one_int
1393 || p->test_elt_zero_wide || p->veclen
1394 || p->dupno >= 0 || p->tests || p->num_clobbers_to_add)
1396 printf ("%sif (", indents[indent]);
1398 if (mode != switch_mode && ! p->ignore_mode)
1399 printf ("GET_MODE (x%d) == %smode && ",
1400 depth, GET_MODE_NAME (mode));
1401 if (p->code != switch_code && p->code != UNKNOWN && ! p->ignore_code)
1403 printf ("GET_CODE (x%d) == ", depth);
1404 print_code (p->code);
1408 if (p->test_elt_zero_int)
1409 printf ("XINT (x%d, 0) == %d && ", depth, p->elt_zero_int);
1410 if (p->test_elt_one_int)
1411 printf ("XINT (x%d, 1) == %d && ", depth, p->elt_one_int);
1412 if (p->test_elt_zero_wide)
1414 /* Set offset to 1 iff the number might get propagated to
1415 unsigned long by ANSI C rules, else 0.
1416 Prospective hosts are required to have at least 32 bit
1417 ints, and integer constants in machine descriptions
1418 must fit in 32 bit, thus it suffices to check only
1420 HOST_WIDE_INT offset = p->elt_zero_wide == -2147483647 - 1;
1421 printf ("XWINT (x%d, 0) == ", depth);
1422 printf (HOST_WIDE_INT_PRINT_DEC, p->elt_zero_wide + offset);
1423 printf ("%s && ", offset ? "-1" : "");
1426 printf ("XVECLEN (x%d, 0) == %d && ", depth, p->veclen);
1428 printf ("rtx_equal_p (x%d, ro[%d]) && ", depth, p->dupno);
1429 if (p->num_clobbers_to_add)
1430 printf ("pnum_clobbers != 0 && ");
1432 printf ("%s (x%d, %smode)", p->tests, depth,
1433 GET_MODE_NAME (p->mode));
1443 need_bracket = ! uncond;
1449 printf ("%s{\n", indents[inner_indent]);
1455 printf ("%sro[%d] = x%d;\n", indents[inner_indent], p->opno, depth);
1460 printf ("%sif (%s)\n", indents[inner_indent], p->c_test);
1466 if (p->insn_code_number >= 0)
1469 printf ("%sreturn gen_split_%d (operands);\n",
1470 indents[inner_indent], p->insn_code_number);
1473 if (p->num_clobbers_to_add)
1477 printf ("%s{\n", indents[inner_indent]);
1481 printf ("%s*pnum_clobbers = %d;\n",
1482 indents[inner_indent], p->num_clobbers_to_add);
1483 printf ("%sreturn %d;\n",
1484 indents[inner_indent], p->insn_code_number);
1489 printf ("%s}\n", indents[inner_indent]);
1493 printf ("%sreturn %d;\n",
1494 indents[inner_indent], p->insn_code_number);
1498 printf ("%sgoto L%d;\n", indents[inner_indent],
1499 p->success.first->number);
1502 printf ("%s}\n", indents[inner_indent - 2]);
1505 /* We have now tested all alternatives. End any switches we have open
1506 and branch to the alternative node unless we know that we can't fall
1507 through to the branch. */
1509 if (switch_code != UNKNOWN)
1511 printf ("%s}\n", indents[indent - 2]);
1516 if (switch_mode != VOIDmode)
1518 printf ("%s}\n", indents[indent - 2]);
1531 change_state (prevpos, afterward->position, 2);
1532 printf (" goto L%d;\n", afterward->number);
1535 printf (" goto ret0;\n");
1542 register const char *p1;
1543 for (p1 = GET_RTX_NAME (code); *p1; p1++)
1545 if (*p1 >= 'a' && *p1 <= 'z')
1546 putchar (*p1 + 'A' - 'a');
1553 same_codes (p, code)
1554 register struct decision *p;
1555 register enum rtx_code code;
1557 for (; p; p = p->next)
1558 if (p->code != code)
1566 register struct decision *p;
1568 for (; p; p = p->next)
1573 same_modes (p, mode)
1574 register struct decision *p;
1575 register enum machine_mode mode;
1577 for (; p; p = p->next)
1578 if ((p->enforce_mode ? p->mode : VOIDmode) != mode)
1586 register struct decision *p;
1588 for (; p; p = p->next)
1589 p->enforce_mode = 0;
1592 /* Write out the decision tree starting at TREE for a subroutine of type TYPE.
1594 PREVPOS is the position at the node that branched to this node.
1596 INITIAL is nonzero if this is the first node we are writing in a subroutine.
1598 If all nodes are false, branch to the node AFTERWARD. */
1601 write_tree (tree, prevpos, afterward, initial, type)
1602 struct decision *tree;
1603 const char *prevpos;
1604 struct decision *afterward;
1606 enum routine_type type;
1608 register struct decision *p;
1609 const char *name_prefix = (type == SPLIT ? "split" : "recog");
1610 const char *call_suffix = (type == SPLIT ? "" : ", pnum_clobbers");
1612 if (! initial && tree->subroutine_number > 0)
1614 OUTPUT_LABEL (" ", tree->number);
1618 printf (" tem = %s_%d (x0, insn%s);\n",
1619 name_prefix, tree->subroutine_number, call_suffix);
1621 printf (" if (tem != 0) return tem;\n");
1623 printf (" if (tem >= 0) return tem;\n");
1624 change_state (tree->position, afterward->position, 2);
1625 printf (" goto L%d;\n", afterward->number);
1628 printf (" return %s_%d (x0, insn%s);\n",
1629 name_prefix, tree->subroutine_number, call_suffix);
1633 write_tree_1 (tree, prevpos, afterward, type);
1635 for (p = tree; p; p = p->next)
1636 if (p->success.first)
1637 write_tree (p->success.first, p->position,
1638 p->afterward ? p->afterward : afterward, 0, type);
1642 /* Assuming that the state of argument is denoted by OLDPOS, take whatever
1643 actions are necessary to move to NEWPOS.
1645 INDENT says how many blanks to place at the front of lines. */
1648 change_state (oldpos, newpos, indent)
1653 int odepth = strlen (oldpos);
1655 int ndepth = strlen (newpos);
1657 /* Pop up as many levels as necessary. */
1659 while (strncmp (oldpos, newpos, depth))
1662 /* Go down to desired level. */
1664 while (depth < ndepth)
1666 if (newpos[depth] >= 'a' && newpos[depth] <= 'z')
1667 printf ("%sx%d = XVECEXP (x%d, 0, %d);\n",
1668 indents[indent], depth + 1, depth, newpos[depth] - 'a');
1670 printf ("%sx%d = XEXP (x%d, %c);\n",
1671 indents[indent], depth + 1, depth, newpos[depth]);
1680 register size_t len = strlen (input) + 1;
1681 register char *output = xmalloc (len);
1682 memcpy (output, input, len);
1687 xrealloc (old, size)
1693 ptr = (PTR) realloc (old, size);
1695 ptr = (PTR) malloc (size);
1697 fatal ("virtual memory exhausted");
1705 register PTR val = (PTR) malloc (size);
1708 fatal ("virtual memory exhausted");
1713 fatal VPROTO ((const char *format, ...))
1715 #ifndef ANSI_PROTOTYPES
1720 VA_START (ap, format);
1722 #ifndef ANSI_PROTOTYPES
1723 format = va_arg (ap, const char *);
1726 fprintf (stderr, "genrecog: ");
1727 vfprintf (stderr, format, ap);
1729 fprintf (stderr, "\n");
1730 fprintf (stderr, "after %d definitions\n", next_index);
1731 exit (FATAL_EXIT_CODE);
1740 struct decision_head recog_tree;
1741 struct decision_head split_tree;
1745 obstack_init (rtl_obstack);
1746 recog_tree.first = recog_tree.last = split_tree.first = split_tree.last = 0;
1749 fatal ("No input file name.");
1751 infile = fopen (argv[1], "r");
1755 exit (FATAL_EXIT_CODE);
1762 printf ("/* Generated automatically by the program `genrecog'\n\
1763 from the machine description file `md'. */\n\n");
1765 printf ("#include \"config.h\"\n");
1766 printf ("#include \"system.h\"\n");
1767 printf ("#include \"rtl.h\"\n");
1768 printf ("#include \"function.h\"\n");
1769 printf ("#include \"insn-config.h\"\n");
1770 printf ("#include \"recog.h\"\n");
1771 printf ("#include \"real.h\"\n");
1772 printf ("#include \"output.h\"\n");
1773 printf ("#include \"flags.h\"\n");
1776 /* Read the machine description. */
1780 c = read_skip_spaces (infile);
1785 desc = read_rtx (infile);
1786 if (GET_CODE (desc) == DEFINE_INSN)
1787 recog_tree = merge_trees (recog_tree,
1788 make_insn_sequence (desc, RECOG));
1789 else if (GET_CODE (desc) == DEFINE_SPLIT)
1790 split_tree = merge_trees (split_tree,
1791 make_insn_sequence (desc, SPLIT));
1792 if (GET_CODE (desc) == DEFINE_PEEPHOLE
1793 || GET_CODE (desc) == DEFINE_EXPAND)
1799 /* `recog' contains a decision tree\n\
1800 that recognizes whether the rtx X0 is a valid instruction.\n\
1802 recog returns -1 if the rtx is not valid.\n\
1803 If the rtx is valid, recog returns a nonnegative number\n\
1804 which is the insn code number for the pattern that matched.\n");
1805 printf (" This is the same as the order in the machine description of\n\
1806 the entry that matched. This number can be used as an index into various\n\
1807 insn_* tables, such as insn_templates, insn_outfun, and insn_n_operands\n\
1808 (found in insn-output.c).\n\n");
1809 printf (" The third argument to recog is an optional pointer to an int.\n\
1810 If present, recog will accept a pattern if it matches except for\n\
1811 missing CLOBBER expressions at the end. In that case, the value\n\
1812 pointed to by the optional pointer will be set to the number of\n\
1813 CLOBBERs that need to be added (it should be initialized to zero by\n\
1814 the caller). If it is set nonzero, the caller should allocate a\n\
1815 PARALLEL of the appropriate size, copy the initial entries, and call\n\
1816 add_clobbers (found in insn-emit.c) to fill in the CLOBBERs.");
1818 if (split_tree.first)
1819 printf ("\n\n The function split_insns returns 0 if the rtl could not\n\
1820 be split or the split rtl in a SEQUENCE if it can be.");
1824 printf ("#define operands recog_operand\n\n");
1826 next_subroutine_number = 0;
1827 break_out_subroutines (recog_tree, RECOG, 1);
1828 write_subroutine (recog_tree.first, RECOG);
1830 next_subroutine_number = 0;
1831 break_out_subroutines (split_tree, SPLIT, 1);
1832 write_subroutine (split_tree.first, SPLIT);
1835 exit (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);