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;
198 void fancy_abort PROTO((void)) ATTRIBUTE_NORETURN;
200 /* Construct and return a sequence of decisions
201 that will recognize INSN.
203 TYPE says what type of routine we are recognizing (RECOG or SPLIT). */
205 static struct decision_head
206 make_insn_sequence (insn, type)
208 enum routine_type type;
211 char *c_test = XSTR (insn, type == RECOG ? 2 : 1);
212 struct decision *last;
213 struct decision_head head;
216 static const char *last_real_name = "insn";
217 static int last_real_code = 0;
220 if (insn_name_ptr_size <= next_insn_code)
223 new_size = (insn_name_ptr_size ? insn_name_ptr_size * 2 : 512);
225 (char **) xrealloc (insn_name_ptr, sizeof(char *) * new_size);
226 bzero ((PTR)(insn_name_ptr + insn_name_ptr_size),
227 sizeof(char *) * (new_size - insn_name_ptr_size));
228 insn_name_ptr_size = new_size;
231 name = XSTR (insn, 0);
232 if (!name || name[0] == '\0')
234 name = xmalloc (strlen (last_real_name) + 10);
235 sprintf (name, "%s+%d", last_real_name,
236 next_insn_code - last_real_code);
240 last_real_name = name;
241 last_real_code = next_insn_code;
244 insn_name_ptr[next_insn_code] = name;
247 if (XVECLEN (insn, type == RECOG) == 1)
248 x = XVECEXP (insn, type == RECOG, 0);
251 x = rtx_alloc (PARALLEL);
252 XVEC (x, 0) = XVEC (insn, type == RECOG);
253 PUT_MODE (x, VOIDmode);
256 last = add_to_sequence (x, &head, "");
259 last->c_test = c_test;
260 last->insn_code_number = next_insn_code;
261 last->num_clobbers_to_add = 0;
263 /* If this is not a DEFINE_SPLIT and X is a PARALLEL, see if it ends with a
264 group of CLOBBERs of (hard) registers or MATCH_SCRATCHes. If so, set up
265 to recognize the pattern without these CLOBBERs. */
267 if (type == RECOG && GET_CODE (x) == PARALLEL)
271 for (i = XVECLEN (x, 0); i > 0; i--)
272 if (GET_CODE (XVECEXP (x, 0, i - 1)) != CLOBBER
273 || (GET_CODE (XEXP (XVECEXP (x, 0, i - 1), 0)) != REG
274 && GET_CODE (XEXP (XVECEXP (x, 0, i - 1), 0)) != MATCH_SCRATCH))
277 if (i != XVECLEN (x, 0))
280 struct decision_head clobber_head;
283 new = XVECEXP (x, 0, 0);
288 new = rtx_alloc (PARALLEL);
289 XVEC (new, 0) = rtvec_alloc (i);
290 for (j = i - 1; j >= 0; j--)
291 XVECEXP (new, 0, j) = XVECEXP (x, 0, j);
294 last = add_to_sequence (new, &clobber_head, "");
297 last->c_test = c_test;
298 last->insn_code_number = next_insn_code;
299 last->num_clobbers_to_add = XVECLEN (x, 0) - i;
301 head = merge_trees (head, clobber_head);
308 /* Define the subroutine we will call below and emit in genemit. */
309 printf ("extern rtx gen_split_%d PROTO ((rtx *));\n", last->insn_code_number);
314 /* Create a chain of nodes to verify that an rtl expression matches
317 LAST is a pointer to the listhead in the previous node in the chain (or
318 in the calling function, for the first node).
320 POSITION is the string representing the current position in the insn.
322 A pointer to the final node in the chain is returned. */
324 static struct decision *
325 add_to_sequence (pattern, last, position)
327 struct decision_head *last;
328 const char *position;
330 register RTX_CODE code;
331 register struct decision *new
332 = (struct decision *) xmalloc (sizeof (struct decision));
333 struct decision *this;
335 register const char *fmt;
337 int depth = strlen (position);
340 if (depth > max_depth)
343 new->number = next_number++;
344 new->position = xstrdup (position);
345 new->ignore_code = 0;
346 new->ignore_mode = 0;
347 new->enforce_mode = 1;
348 new->retest_code = new->retest_mode = 0;
350 new->test_elt_zero_int = 0;
351 new->test_elt_one_int = 0;
352 new->test_elt_zero_wide = 0;
353 new->elt_zero_int = 0;
354 new->elt_one_int = 0;
355 new->elt_zero_wide = 0;
359 new->success.first = new->success.last = 0;
360 new->insn_code_number = -1;
361 new->num_clobbers_to_add = 0;
367 new->label_needed = 0;
368 new->subroutine_number = 0;
372 last->first = last->last = new;
374 newpos = (char *) alloca (depth + 2);
375 strcpy (newpos, position);
376 newpos[depth + 1] = 0;
380 new->mode = GET_MODE (pattern);
381 new->code = code = GET_CODE (pattern);
390 new->opno = XINT (pattern, 0);
391 new->code = (code == MATCH_PARALLEL ? PARALLEL : UNKNOWN);
392 new->enforce_mode = 0;
394 if (code == MATCH_SCRATCH)
395 new->tests = "scratch_operand";
397 new->tests = XSTR (pattern, 1);
399 if (*new->tests == 0)
402 /* See if we know about this predicate and save its number. If we do,
403 and it only accepts one code, note that fact. The predicate
404 `const_int_operand' only tests for a CONST_INT, so if we do so we
405 can avoid calling it at all.
407 Finally, if we know that the predicate does not allow CONST_INT, we
408 know that the only way the predicate can match is if the modes match
409 (here we use the kludge of relying on the fact that "address_operand"
410 accepts CONST_INT; otherwise, it would have to be a special case),
411 so we can test the mode (but we need not). This fact should
412 considerably simplify the generated code. */
416 for (i = 0; i < NUM_KNOWN_PREDS; i++)
417 if (! strcmp (preds[i].name, new->tests))
420 int allows_const_int = 0;
424 if (preds[i].codes[1] == 0 && new->code == UNKNOWN)
426 new->code = preds[i].codes[0];
427 if (! strcmp ("const_int_operand", new->tests))
428 new->tests = 0, new->pred = -1;
431 for (j = 0; j < NUM_RTX_CODE && preds[i].codes[j] != 0; j++)
432 if (preds[i].codes[j] == CONST_INT)
433 allows_const_int = 1;
435 if (! allows_const_int)
436 new->enforce_mode = new->ignore_mode= 1;
441 #ifdef PREDICATE_CODES
442 /* If the port has a list of the predicates it uses but omits
444 if (i == NUM_KNOWN_PREDS)
445 fprintf (stderr, "Warning: `%s' not in PREDICATE_CODES\n",
450 if (code == MATCH_OPERATOR || code == MATCH_PARALLEL)
452 for (i = 0; i < (size_t) XVECLEN (pattern, 2); i++)
454 newpos[depth] = i + (code == MATCH_OPERATOR ? '0': 'a');
455 new = add_to_sequence (XVECEXP (pattern, 2, i),
456 &new->success, newpos);
463 new->opno = XINT (pattern, 0);
464 new->dupno = XINT (pattern, 0);
467 for (i = 0; i < (size_t) XVECLEN (pattern, 1); i++)
469 newpos[depth] = i + '0';
470 new = add_to_sequence (XVECEXP (pattern, 1, i),
471 &new->success, newpos);
477 new->dupno = XINT (pattern, 0);
479 new->enforce_mode = 0;
483 pattern = XEXP (pattern, 0);
487 /* The operands of a SET must have the same mode unless one is VOIDmode. */
488 if (GET_MODE (SET_SRC (pattern)) != VOIDmode
489 && GET_MODE (SET_DEST (pattern)) != VOIDmode
490 && GET_MODE (SET_SRC (pattern)) != GET_MODE (SET_DEST (pattern))
491 /* The mode of an ADDRESS_OPERAND is the mode of the memory reference,
492 not the mode of the address. */
493 && ! (GET_CODE (SET_SRC (pattern)) == MATCH_OPERAND
494 && ! strcmp (XSTR (SET_SRC (pattern), 1), "address_operand")))
496 print_rtl (stderr, pattern);
497 fputc ('\n', stderr);
498 fatal ("mode mismatch in SET");
501 new = add_to_sequence (SET_DEST (pattern), &new->success, newpos);
502 this->success.first->enforce_mode = 1;
504 new = add_to_sequence (SET_SRC (pattern), &new->success, newpos);
506 /* If set are setting CC0 from anything other than a COMPARE, we
507 must enforce the mode so that we do not produce ambiguous insns. */
508 if (GET_CODE (SET_DEST (pattern)) == CC0
509 && GET_CODE (SET_SRC (pattern)) != COMPARE)
510 this->success.first->enforce_mode = 1;
515 case STRICT_LOW_PART:
517 new = add_to_sequence (XEXP (pattern, 0), &new->success, newpos);
518 this->success.first->enforce_mode = 1;
522 this->test_elt_one_int = 1;
523 this->elt_one_int = XINT (pattern, 1);
525 new = add_to_sequence (XEXP (pattern, 0), &new->success, newpos);
526 this->success.first->enforce_mode = 1;
532 new = add_to_sequence (XEXP (pattern, 0), &new->success, newpos);
533 this->success.first->enforce_mode = 1;
535 new = add_to_sequence (XEXP (pattern, 1), &new->success, newpos);
537 new = add_to_sequence (XEXP (pattern, 2), &new->success, newpos);
540 case EQ: case NE: case LE: case LT: case GE: case GT:
541 case LEU: case LTU: case GEU: case GTU:
542 /* If the first operand is (cc0), we don't have to do anything
544 if (GET_CODE (XEXP (pattern, 0)) == CC0)
547 /* ... fall through ... */
550 /* Enforce the mode on the first operand to avoid ambiguous insns. */
552 new = add_to_sequence (XEXP (pattern, 0), &new->success, newpos);
553 this->success.first->enforce_mode = 1;
555 new = add_to_sequence (XEXP (pattern, 1), &new->success, newpos);
562 fmt = GET_RTX_FORMAT (code);
563 len = GET_RTX_LENGTH (code);
564 for (i = 0; i < (size_t) len; i++)
566 newpos[depth] = '0' + i;
567 if (fmt[i] == 'e' || fmt[i] == 'u')
568 new = add_to_sequence (XEXP (pattern, i), &new->success, newpos);
569 else if (fmt[i] == 'i' && i == 0)
571 this->test_elt_zero_int = 1;
572 this->elt_zero_int = XINT (pattern, i);
574 else if (fmt[i] == 'i' && i == 1)
576 this->test_elt_one_int = 1;
577 this->elt_one_int = XINT (pattern, i);
579 else if (fmt[i] == 'w' && i == 0)
581 this->test_elt_zero_wide = 1;
582 this->elt_zero_wide = XWINT (pattern, i);
584 else if (fmt[i] == 'E')
587 /* We do not handle a vector appearing as other than
588 the first item, just because nothing uses them
589 and by handling only the special case
590 we can use one element in newpos for either
591 the item number of a subexpression
592 or the element number in a vector. */
595 this->veclen = XVECLEN (pattern, i);
596 for (j = 0; j < XVECLEN (pattern, i); j++)
598 newpos[depth] = 'a' + j;
599 new = add_to_sequence (XVECEXP (pattern, i, j),
600 &new->success, newpos);
603 else if (fmt[i] != '0')
609 /* Return 1 if we can prove that there is no RTL that can match both
610 D1 and D2. Otherwise, return 0 (it may be that there is an RTL that
611 can match both or just that we couldn't prove there wasn't such an RTL).
613 TOPLEVEL is non-zero if we are to only look at the top level and not
614 recursively descend. */
617 not_both_true (d1, d2, toplevel)
618 struct decision *d1, *d2;
621 struct decision *p1, *p2;
623 /* If they are both to test modes and the modes are different, they aren't
624 both true. Similarly for codes, integer elements, and vector lengths. */
626 if ((d1->enforce_mode && d2->enforce_mode
627 && d1->mode != VOIDmode && d2->mode != VOIDmode && d1->mode != d2->mode)
628 || (d1->code != UNKNOWN && d2->code != UNKNOWN && d1->code != d2->code)
629 || (d1->test_elt_zero_int && d2->test_elt_zero_int
630 && d1->elt_zero_int != d2->elt_zero_int)
631 || (d1->test_elt_one_int && d2->test_elt_one_int
632 && d1->elt_one_int != d2->elt_one_int)
633 || (d1->test_elt_zero_wide && d2->test_elt_zero_wide
634 && d1->elt_zero_wide != d2->elt_zero_wide)
635 || (d1->veclen && d2->veclen && d1->veclen != d2->veclen))
638 /* If either is a wild-card MATCH_OPERAND without a predicate, it can match
639 absolutely anything, so we can't say that no intersection is possible.
640 This case is detected by having a zero TESTS field with a code of
643 if ((d1->tests == 0 && d1->code == UNKNOWN)
644 || (d2->tests == 0 && d2->code == UNKNOWN))
647 /* If either has a predicate that we know something about, set things up so
648 that D1 is the one that always has a known predicate. Then see if they
649 have any codes in common. */
651 if (d1->pred >= 0 || d2->pred >= 0)
656 p1 = d1, d1 = d2, d2 = p1;
658 /* If D2 tests an explicit code, see if it is in the list of valid codes
659 for D1's predicate. */
660 if (d2->code != UNKNOWN)
662 for (i = 0; i < NUM_RTX_CODE && preds[d1->pred].codes[i] != 0; i++)
663 if (preds[d1->pred].codes[i] == d2->code)
666 if (preds[d1->pred].codes[i] == 0)
670 /* Otherwise see if the predicates have any codes in common. */
672 else if (d2->pred >= 0)
674 for (i = 0; i < NUM_RTX_CODE && preds[d1->pred].codes[i] != 0; i++)
676 for (j = 0; j < NUM_RTX_CODE; j++)
677 if (preds[d2->pred].codes[j] == 0
678 || preds[d2->pred].codes[j] == preds[d1->pred].codes[i])
681 if (preds[d2->pred].codes[j] != 0)
685 if (preds[d1->pred].codes[i] == 0)
690 /* If we got here, we can't prove that D1 and D2 cannot both be true.
691 If we are only to check the top level, return 0. Otherwise, see if
692 we can prove that all choices in both successors are mutually
693 exclusive. If either does not have any successors, we can't prove
694 they can't both be true. */
696 if (toplevel || d1->success.first == 0 || d2->success.first == 0)
699 for (p1 = d1->success.first; p1; p1 = p1->next)
700 for (p2 = d2->success.first; p2; p2 = p2->next)
701 if (! not_both_true (p1, p2, 0))
707 /* Assuming that we can reorder all the alternatives at a specific point in
708 the tree (see discussion in merge_trees), we would prefer an ordering of
709 nodes where groups of consecutive nodes test the same mode and, within each
710 mode, groups of nodes test the same code. With this order, we can
711 construct nested switch statements, the inner one to test the code and
712 the outer one to test the mode.
714 We would like to list nodes testing for specific codes before those
715 that test predicates to avoid unnecessary function calls. Similarly,
716 tests for specific modes should precede nodes that allow any mode.
718 This function returns the merit (with 0 being the best) of inserting
719 a test involving the specified MODE and CODE after node P. If P is
720 zero, we are to determine the merit of inserting the test at the front
724 position_merit (p, mode, code)
726 enum machine_mode mode;
729 enum machine_mode p_mode;
731 /* The only time the front of the list is anything other than the worst
732 position is if we are testing a mode that isn't VOIDmode. */
734 return mode == VOIDmode ? 3 : 2;
736 p_mode = p->enforce_mode ? p->mode : VOIDmode;
738 /* The best case is if the codes and modes both match. */
739 if (p_mode == mode && p->code== code)
742 /* If the codes don't match, the next best case is if the modes match.
743 In that case, the best position for this node depends on whether
744 we are testing for a specific code or not. If we are, the best place
745 is after some other test for an explicit code and our mode or after
746 the last test in the previous mode if every test in our mode is for
749 If we are testing for UNKNOWN, then the next best case is at the end of
753 && ((p_mode == mode && p->code != UNKNOWN)
754 || (p_mode != mode && p->next
755 && (p->next->enforce_mode ? p->next->mode : VOIDmode) == mode
756 && (p->next->code == UNKNOWN))))
757 || (code == UNKNOWN && p_mode == mode
759 || (p->next->enforce_mode ? p->next->mode : VOIDmode) != mode)))
762 /* The third best case occurs when nothing is testing MODE. If MODE
763 is not VOIDmode, then the third best case is after something of any
764 mode that is not VOIDmode. If we are testing VOIDmode, the third best
765 place is the end of the list. */
768 && ((mode != VOIDmode && p_mode != VOIDmode)
769 || (mode == VOIDmode && p->next == 0)))
772 /* Otherwise, we have the worst case. */
776 /* Merge two decision tree listheads OLDH and ADDH,
777 modifying OLDH destructively, and return the merged tree. */
779 static struct decision_head
780 merge_trees (oldh, addh)
781 register struct decision_head oldh, addh;
783 struct decision *add, *next;
791 /* If we are adding things at different positions, something is wrong. */
792 if (strcmp (oldh.first->position, addh.first->position))
795 for (add = addh.first; add; add = next)
797 enum machine_mode add_mode = add->enforce_mode ? add->mode : VOIDmode;
798 struct decision *best_position = 0;
800 struct decision *old;
804 /* The semantics of pattern matching state that the tests are done in
805 the order given in the MD file so that if an insn matches two
806 patterns, the first one will be used. However, in practice, most,
807 if not all, patterns are unambiguous so that their order is
808 independent. In that case, we can merge identical tests and
809 group all similar modes and codes together.
811 Scan starting from the end of OLDH until we reach a point
812 where we reach the head of the list or where we pass a pattern
813 that could also be true if NEW is true. If we find an identical
814 pattern, we can merge them. Also, record the last node that tests
815 the same code and mode and the last one that tests just the same mode.
817 If we have no match, place NEW after the closest match we found. */
819 for (old = oldh.last; old; old = old->prev)
823 /* If we don't have anything to test except an additional test,
824 do not consider the two nodes equal. If we did, the test below
825 would cause an infinite recursion. */
826 if (old->tests == 0 && old->test_elt_zero_int == 0
827 && old->test_elt_one_int == 0 && old->veclen == 0
828 && old->test_elt_zero_wide == 0
829 && old->dupno == -1 && old->mode == VOIDmode
830 && old->code == UNKNOWN
831 && (old->c_test != 0 || add->c_test != 0))
834 else if ((old->tests == add->tests
835 || (old->pred >= 0 && old->pred == add->pred)
836 || (old->tests && add->tests
837 && !strcmp (old->tests, add->tests)))
838 && old->test_elt_zero_int == add->test_elt_zero_int
839 && old->elt_zero_int == add->elt_zero_int
840 && old->test_elt_one_int == add->test_elt_one_int
841 && old->elt_one_int == add->elt_one_int
842 && old->test_elt_zero_wide == add->test_elt_zero_wide
843 && old->elt_zero_wide == add->elt_zero_wide
844 && old->veclen == add->veclen
845 && old->dupno == add->dupno
846 && old->opno == add->opno
847 && old->code == add->code
848 && old->enforce_mode == add->enforce_mode
849 && old->mode == add->mode)
851 /* If the additional test is not the same, split both nodes
852 into nodes that just contain all things tested before the
853 additional test and nodes that contain the additional test
854 and actions when it is true. This optimization is important
855 because of the case where we have almost identical patterns
856 with different tests on target flags. */
858 if (old->c_test != add->c_test
859 && ! (old->c_test && add->c_test
860 && !strcmp (old->c_test, add->c_test)))
862 if (old->insn_code_number >= 0 || old->opno >= 0)
864 struct decision *split
865 = (struct decision *) xmalloc (sizeof (struct decision));
867 memcpy (split, old, sizeof (struct decision));
869 old->success.first = old->success.last = split;
872 old->insn_code_number = -1;
873 old->num_clobbers_to_add = 0;
875 split->number = next_number++;
876 split->next = split->prev = 0;
877 split->mode = VOIDmode;
878 split->code = UNKNOWN;
880 split->test_elt_zero_int = 0;
881 split->test_elt_one_int = 0;
882 split->test_elt_zero_wide = 0;
888 if (add->insn_code_number >= 0 || add->opno >= 0)
890 struct decision *split
891 = (struct decision *) xmalloc (sizeof (struct decision));
893 memcpy (split, add, sizeof (struct decision));
895 add->success.first = add->success.last = split;
898 add->insn_code_number = -1;
899 add->num_clobbers_to_add = 0;
901 split->number = next_number++;
902 split->next = split->prev = 0;
903 split->mode = VOIDmode;
904 split->code = UNKNOWN;
906 split->test_elt_zero_int = 0;
907 split->test_elt_one_int = 0;
908 split->test_elt_zero_wide = 0;
915 if (old->insn_code_number >= 0 && add->insn_code_number >= 0)
917 /* If one node is for a normal insn and the second is
918 for the base insn with clobbers stripped off, the
919 second node should be ignored. */
921 if (old->num_clobbers_to_add == 0
922 && add->num_clobbers_to_add > 0)
923 /* Nothing to do here. */
925 else if (old->num_clobbers_to_add > 0
926 && add->num_clobbers_to_add == 0)
928 /* In this case, replace OLD with ADD. */
929 old->insn_code_number = add->insn_code_number;
930 old->num_clobbers_to_add = 0;
933 fatal ("Two actions at one point in tree for insns \"%s\" (%d) and \"%s\" (%d)",
934 insn_name_ptr[old->insn_code_number],
935 old->insn_code_number,
936 insn_name_ptr[add->insn_code_number],
937 add->insn_code_number);
940 if (old->insn_code_number == -1)
941 old->insn_code_number = add->insn_code_number;
942 old->success = merge_trees (old->success, add->success);
947 /* Unless we have already found the best possible insert point,
948 see if this position is better. If so, record it. */
951 && ((our_merit = position_merit (old, add_mode, add->code))
953 best_merit = our_merit, best_position = old;
955 if (! not_both_true (old, add, 0))
959 /* If ADD was duplicate, we are done. */
963 /* Otherwise, find the best place to insert ADD. Normally this is
964 BEST_POSITION. However, if we went all the way to the top of
965 the list, it might be better to insert at the top. */
967 if (best_position == 0)
971 && position_merit (NULL_PTR, add_mode, add->code) < best_merit)
974 add->next = oldh.first;
975 oldh.first->prev = add;
981 add->prev = best_position;
982 add->next = best_position->next;
983 best_position->next = add;
984 if (best_position == oldh.last)
987 add->next->prev = add;
994 /* Count the number of subnodes of HEAD. If the number is high enough,
995 make the first node in HEAD start a separate subroutine in the C code
998 TYPE gives the type of routine we are writing.
1000 INITIAL is non-zero if this is the highest-level node. We never write
1004 break_out_subroutines (head, type, initial)
1005 struct decision_head head;
1006 enum routine_type type;
1010 struct decision *sub;
1012 for (sub = head.first; sub; sub = sub->next)
1013 size += 1 + break_out_subroutines (sub->success, type, 0);
1015 if (size > SUBROUTINE_THRESHOLD && ! initial)
1017 head.first->subroutine_number = ++next_subroutine_number;
1018 write_subroutine (head.first, type);
1024 /* Write out a subroutine of type TYPE to do comparisons starting at node
1028 write_subroutine (tree, type)
1029 struct decision *tree;
1030 enum routine_type type;
1035 printf ("extern rtx split");
1037 printf ("extern int recog");
1038 if (tree != 0 && tree->subroutine_number > 0)
1039 printf ("_%d", tree->subroutine_number);
1040 else if (type == SPLIT)
1042 printf (" PROTO ((rtx, rtx");
1048 printf ("rtx\nsplit");
1050 printf ("int\nrecog");
1052 if (tree != 0 && tree->subroutine_number > 0)
1053 printf ("_%d", tree->subroutine_number);
1054 else if (type == SPLIT)
1057 printf (" (x0, insn");
1059 printf (", pnum_clobbers");
1062 printf (" register rtx x0;\n rtx insn ATTRIBUTE_UNUSED;\n");
1064 printf (" int *pnum_clobbers ATTRIBUTE_UNUSED;\n");
1067 printf (" register rtx *ro = &recog_operand[0];\n");
1069 printf (" register rtx ");
1070 for (i = 1; i < max_depth; i++)
1071 printf ("x%d ATTRIBUTE_UNUSED, ", i);
1073 printf ("x%d ATTRIBUTE_UNUSED;\n", max_depth);
1074 printf (" %s tem ATTRIBUTE_UNUSED;\n", type == SPLIT ? "rtx" : "int");
1075 write_tree (tree, "", NULL_PTR, 1, type);
1076 printf (" ret0: return %d;\n}\n\n", type == SPLIT ? 0 : -1);
1079 /* This table is used to indent the recog_* functions when we are inside
1080 conditions or switch statements. We only support small indentations
1081 and always indent at least two spaces. */
1083 static const char *indents[]
1084 = {" ", " ", " ", " ", " ", " ", " ", " ",
1085 "\t", "\t ", "\t ", "\t ", "\t ", "\t ", "\t ",
1086 "\t\t", "\t\t ", "\t\t ", "\t\t ", "\t\t ", "\t\t "};
1088 /* Write out C code to perform the decisions in TREE for a subroutine of
1089 type TYPE. If all of the choices fail, branch to node AFTERWARD, if
1090 non-zero, otherwise return. PREVPOS is the position of the node that
1091 branched to this test.
1093 When we merged all alternatives, we tried to set up a convenient order.
1094 Specifically, tests involving the same mode are all grouped together,
1095 followed by a group that does not contain a mode test. Within each group
1096 of the same mode, we also group tests with the same code, followed by a
1097 group that does not test a code.
1099 Occasionally, we cannot arbitrarily reorder the tests so that multiple
1100 sequence of groups as described above are present.
1102 We generate two nested switch statements, the outer statement for
1103 testing modes, and the inner switch for testing RTX codes. It is
1104 not worth optimizing cases when only a small number of modes or
1105 codes is tested, since the compiler can do that when compiling the
1106 resulting function. We do check for when every test is the same mode
1110 write_tree_1 (tree, prevpos, afterward, type)
1111 struct decision *tree;
1112 const char *prevpos;
1113 struct decision *afterward;
1114 enum routine_type type;
1116 register struct decision *p, *p1;
1117 register int depth = tree ? strlen (tree->position) : 0;
1118 enum machine_mode switch_mode = VOIDmode;
1119 RTX_CODE switch_code = UNKNOWN;
1121 char modemap[NUM_MACHINE_MODES];
1122 char codemap[NUM_RTX_CODE];
1126 /* One tricky area is what is the exact state when we branch to a
1127 node's label. There are two cases where we branch: when looking at
1128 successors to a node, or when a set of tests fails.
1130 In the former case, we are always branching to the first node in a
1131 decision list and we want all required tests to be performed. We
1132 put the labels for such nodes in front of any switch or test statements.
1133 These branches are done without updating the position to that of the
1136 In the latter case, we are branching to a node that is not the first
1137 node in a decision list. We have already checked that it is possible
1138 for both the node we originally tested at this level and the node we
1139 are branching to to both match some pattern. That means that they
1140 usually will be testing the same mode and code. So it is normally safe
1141 for such labels to be inside switch statements, since the tests done
1142 by virtue of arriving at that label will usually already have been
1143 done. The exception is a branch from a node that does not test a
1144 mode or code to one that does. In such cases, we set the `retest_mode'
1145 or `retest_code' flags. That will ensure that we start a new switch
1146 at that position and put the label before the switch.
1148 The branches in the latter case must set the position to that of the
1153 if (tree && tree->subroutine_number == 0)
1155 OUTPUT_LABEL (" ", tree->number);
1156 tree->label_needed = 0;
1161 change_state (prevpos, tree->position, 2);
1162 prevpos = tree->position;
1165 for (p = tree; p; p = p->next)
1167 enum machine_mode mode = p->enforce_mode ? p->mode : VOIDmode;
1169 int wrote_bracket = 0;
1172 if (p->success.first == 0 && p->insn_code_number < 0)
1175 /* Find the next alternative to p that might be true when p is true.
1176 Test that one next if p's successors fail. */
1178 for (p1 = p->next; p1 && not_both_true (p, p1, 1); p1 = p1->next)
1184 if (mode == VOIDmode && p1->enforce_mode && p1->mode != VOIDmode)
1185 p1->retest_mode = 1;
1186 if (p->code == UNKNOWN && p1->code != UNKNOWN)
1187 p1->retest_code = 1;
1188 p1->label_needed = 1;
1191 /* If we have a different code or mode than the last node and
1192 are in a switch on codes, we must either end the switch or
1193 go to another case. We must also end the switch if this
1194 node needs a label and to retest either the mode or code. */
1196 if (switch_code != UNKNOWN
1197 && (switch_code != p->code || switch_mode != mode
1198 || (p->label_needed && (p->retest_mode || p->retest_code))))
1200 enum rtx_code code = p->code;
1202 /* If P is testing a predicate that we know about and we haven't
1203 seen any of the codes that are valid for the predicate, we
1204 can write a series of "case" statement, one for each possible
1205 code. Since we are already in a switch, these redundant tests
1206 are very cheap and will reduce the number of predicate called. */
1210 for (i = 0; i < NUM_RTX_CODE && preds[p->pred].codes[i] != 0; i++)
1211 if (codemap[(int) preds[p->pred].codes[i]])
1214 if (preds[p->pred].codes[i] == 0)
1215 code = MATCH_OPERAND;
1218 if (code == UNKNOWN || codemap[(int) code]
1219 || switch_mode != mode
1220 || (p->label_needed && (p->retest_mode || p->retest_code)))
1222 printf ("%s}\n", indents[indent - 2]);
1223 switch_code = UNKNOWN;
1229 printf ("%sbreak;\n", indents[indent]);
1231 if (code == MATCH_OPERAND)
1233 for (i = 0; i < NUM_RTX_CODE && preds[p->pred].codes[i] != 0; i++)
1235 printf ("%scase ", indents[indent - 2]);
1236 print_code (preds[p->pred].codes[i]);
1238 codemap[(int) preds[p->pred].codes[i]] = 1;
1243 printf ("%scase ", indents[indent - 2]);
1246 codemap[(int) p->code] = 1;
1255 /* If we were previously in a switch on modes and now have a different
1256 mode, end at least the case, and maybe end the switch if we are
1257 not testing a mode or testing a mode whose case we already saw. */
1259 if (switch_mode != VOIDmode
1260 && (switch_mode != mode || (p->label_needed && p->retest_mode)))
1262 if (mode == VOIDmode || modemap[(int) mode]
1263 || (p->label_needed && p->retest_mode))
1265 printf ("%s}\n", indents[indent - 2]);
1266 switch_mode = VOIDmode;
1272 printf (" break;\n");
1273 printf (" case %smode:\n", GET_MODE_NAME (mode));
1275 modemap[(int) mode] = 1;
1281 /* If we are about to write dead code, something went wrong. */
1282 if (! p->label_needed && uncond)
1285 /* If we need a label and we will want to retest the mode or code at
1286 that label, write the label now. We have already ensured that
1287 things will be valid for the test. */
1289 if (p->label_needed && (p->retest_mode || p->retest_code))
1291 OUTPUT_LABEL (indents[indent - 2], p->number);
1292 p->label_needed = 0;
1297 /* If we are not in any switches, see if we can shortcut things
1298 by checking for identical modes and codes. */
1300 if (switch_mode == VOIDmode && switch_code == UNKNOWN)
1302 /* If p and its alternatives all want the same mode,
1303 reject all others at once, first, then ignore the mode. */
1305 if (mode != VOIDmode && p->next && same_modes (p, mode))
1307 printf (" if (GET_MODE (x%d) != %smode)\n",
1308 depth, GET_MODE_NAME (p->mode));
1312 change_state (p->position, afterward->position, 6);
1313 printf (" goto L%d;\n }\n", afterward->number);
1316 printf (" goto ret0;\n");
1321 /* If p and its alternatives all want the same code,
1322 reject all others at once, first, then ignore the code. */
1324 if (p->code != UNKNOWN && p->next && same_codes (p, p->code))
1326 printf (" if (GET_CODE (x%d) != ", depth);
1327 print_code (p->code);
1332 change_state (p->position, afterward->position, indent + 4);
1333 printf (" goto L%d;\n }\n", afterward->number);
1336 printf (" goto ret0;\n");
1341 /* If we are not in a mode switch and we are testing for a specific
1342 mode, start a mode switch unless we have just one node or the next
1343 node is not testing a mode (we have already tested for the case of
1344 more than one mode, but all of the same mode). */
1346 if (switch_mode == VOIDmode && mode != VOIDmode && p->next != 0
1347 && p->next->enforce_mode && p->next->mode != VOIDmode)
1349 memset (modemap, 0, sizeof modemap);
1350 printf ("%sswitch (GET_MODE (x%d))\n", indents[indent], depth);
1351 printf ("%s{\n", indents[indent + 2]);
1353 printf ("%sdefault:\n%sbreak;\n", indents[indent - 2],
1355 printf ("%scase %smode:\n", indents[indent - 2],
1356 GET_MODE_NAME (mode));
1357 modemap[(int) mode] = 1;
1361 /* Similarly for testing codes. */
1363 if (switch_code == UNKNOWN && p->code != UNKNOWN && ! p->ignore_code
1364 && p->next != 0 && p->next->code != UNKNOWN)
1366 memset (codemap, 0, sizeof codemap);
1367 printf ("%sswitch (GET_CODE (x%d))\n", indents[indent], depth);
1368 printf ("%s{\n", indents[indent + 2]);
1370 printf ("%sdefault:\n%sbreak;\n", indents[indent - 2],
1372 printf ("%scase ", indents[indent - 2]);
1373 print_code (p->code);
1375 codemap[(int) p->code] = 1;
1376 switch_code = p->code;
1379 /* Now that most mode and code tests have been done, we can write out
1380 a label for an inner node, if we haven't already. */
1381 if (p->label_needed)
1382 OUTPUT_LABEL (indents[indent - 2], p->number);
1384 inner_indent = indent;
1386 /* The only way we can have to do a mode or code test here is if
1387 this node needs such a test but is the only node to be tested.
1388 In that case, we won't have started a switch. Note that this is
1389 the only way the switch and test modes can disagree. */
1391 if ((mode != switch_mode && ! p->ignore_mode)
1392 || (p->code != switch_code && p->code != UNKNOWN && ! p->ignore_code)
1393 || p->test_elt_zero_int || p->test_elt_one_int
1394 || p->test_elt_zero_wide || p->veclen
1395 || p->dupno >= 0 || p->tests || p->num_clobbers_to_add)
1397 printf ("%sif (", indents[indent]);
1399 if (mode != switch_mode && ! p->ignore_mode)
1400 printf ("GET_MODE (x%d) == %smode && ",
1401 depth, GET_MODE_NAME (mode));
1402 if (p->code != switch_code && p->code != UNKNOWN && ! p->ignore_code)
1404 printf ("GET_CODE (x%d) == ", depth);
1405 print_code (p->code);
1409 if (p->test_elt_zero_int)
1410 printf ("XINT (x%d, 0) == %d && ", depth, p->elt_zero_int);
1411 if (p->test_elt_one_int)
1412 printf ("XINT (x%d, 1) == %d && ", depth, p->elt_one_int);
1413 if (p->test_elt_zero_wide)
1415 /* Set offset to 1 iff the number might get propagated to
1416 unsigned long by ANSI C rules, else 0.
1417 Prospective hosts are required to have at least 32 bit
1418 ints, and integer constants in machine descriptions
1419 must fit in 32 bit, thus it suffices to check only
1421 HOST_WIDE_INT offset = p->elt_zero_wide == -2147483647 - 1;
1422 printf ("XWINT (x%d, 0) == ", depth);
1423 printf (HOST_WIDE_INT_PRINT_DEC, p->elt_zero_wide + offset);
1424 printf ("%s && ", offset ? "-1" : "");
1427 printf ("XVECLEN (x%d, 0) == %d && ", depth, p->veclen);
1429 printf ("rtx_equal_p (x%d, ro[%d]) && ", depth, p->dupno);
1430 if (p->num_clobbers_to_add)
1431 printf ("pnum_clobbers != 0 && ");
1433 printf ("%s (x%d, %smode)", p->tests, depth,
1434 GET_MODE_NAME (p->mode));
1444 need_bracket = ! uncond;
1450 printf ("%s{\n", indents[inner_indent]);
1456 printf ("%sro[%d] = x%d;\n", indents[inner_indent], p->opno, depth);
1461 printf ("%sif (%s)\n", indents[inner_indent], p->c_test);
1467 if (p->insn_code_number >= 0)
1470 printf ("%sreturn gen_split_%d (operands);\n",
1471 indents[inner_indent], p->insn_code_number);
1474 if (p->num_clobbers_to_add)
1478 printf ("%s{\n", indents[inner_indent]);
1482 printf ("%s*pnum_clobbers = %d;\n",
1483 indents[inner_indent], p->num_clobbers_to_add);
1484 printf ("%sreturn %d;\n",
1485 indents[inner_indent], p->insn_code_number);
1490 printf ("%s}\n", indents[inner_indent]);
1494 printf ("%sreturn %d;\n",
1495 indents[inner_indent], p->insn_code_number);
1499 printf ("%sgoto L%d;\n", indents[inner_indent],
1500 p->success.first->number);
1503 printf ("%s}\n", indents[inner_indent - 2]);
1506 /* We have now tested all alternatives. End any switches we have open
1507 and branch to the alternative node unless we know that we can't fall
1508 through to the branch. */
1510 if (switch_code != UNKNOWN)
1512 printf ("%s}\n", indents[indent - 2]);
1517 if (switch_mode != VOIDmode)
1519 printf ("%s}\n", indents[indent - 2]);
1532 change_state (prevpos, afterward->position, 2);
1533 printf (" goto L%d;\n", afterward->number);
1536 printf (" goto ret0;\n");
1543 register const char *p1;
1544 for (p1 = GET_RTX_NAME (code); *p1; p1++)
1546 if (*p1 >= 'a' && *p1 <= 'z')
1547 putchar (*p1 + 'A' - 'a');
1554 same_codes (p, code)
1555 register struct decision *p;
1556 register enum rtx_code code;
1558 for (; p; p = p->next)
1559 if (p->code != code)
1567 register struct decision *p;
1569 for (; p; p = p->next)
1574 same_modes (p, mode)
1575 register struct decision *p;
1576 register enum machine_mode mode;
1578 for (; p; p = p->next)
1579 if ((p->enforce_mode ? p->mode : VOIDmode) != mode)
1587 register struct decision *p;
1589 for (; p; p = p->next)
1590 p->enforce_mode = 0;
1593 /* Write out the decision tree starting at TREE for a subroutine of type TYPE.
1595 PREVPOS is the position at the node that branched to this node.
1597 INITIAL is nonzero if this is the first node we are writing in a subroutine.
1599 If all nodes are false, branch to the node AFTERWARD. */
1602 write_tree (tree, prevpos, afterward, initial, type)
1603 struct decision *tree;
1604 const char *prevpos;
1605 struct decision *afterward;
1607 enum routine_type type;
1609 register struct decision *p;
1610 const char *name_prefix = (type == SPLIT ? "split" : "recog");
1611 const char *call_suffix = (type == SPLIT ? "" : ", pnum_clobbers");
1613 if (! initial && tree->subroutine_number > 0)
1615 OUTPUT_LABEL (" ", tree->number);
1619 printf (" tem = %s_%d (x0, insn%s);\n",
1620 name_prefix, tree->subroutine_number, call_suffix);
1622 printf (" if (tem != 0) return tem;\n");
1624 printf (" if (tem >= 0) return tem;\n");
1625 change_state (tree->position, afterward->position, 2);
1626 printf (" goto L%d;\n", afterward->number);
1629 printf (" return %s_%d (x0, insn%s);\n",
1630 name_prefix, tree->subroutine_number, call_suffix);
1634 write_tree_1 (tree, prevpos, afterward, type);
1636 for (p = tree; p; p = p->next)
1637 if (p->success.first)
1638 write_tree (p->success.first, p->position,
1639 p->afterward ? p->afterward : afterward, 0, type);
1643 /* Assuming that the state of argument is denoted by OLDPOS, take whatever
1644 actions are necessary to move to NEWPOS.
1646 INDENT says how many blanks to place at the front of lines. */
1649 change_state (oldpos, newpos, indent)
1654 int odepth = strlen (oldpos);
1656 int ndepth = strlen (newpos);
1658 /* Pop up as many levels as necessary. */
1660 while (strncmp (oldpos, newpos, depth))
1663 /* Go down to desired level. */
1665 while (depth < ndepth)
1667 if (newpos[depth] >= 'a' && newpos[depth] <= 'z')
1668 printf ("%sx%d = XVECEXP (x%d, 0, %d);\n",
1669 indents[indent], depth + 1, depth, newpos[depth] - 'a');
1671 printf ("%sx%d = XEXP (x%d, %c);\n",
1672 indents[indent], depth + 1, depth, newpos[depth]);
1681 register size_t len = strlen (input) + 1;
1682 register char *output = xmalloc (len);
1683 memcpy (output, input, len);
1688 xrealloc (old, size)
1694 ptr = (PTR) realloc (old, size);
1696 ptr = (PTR) malloc (size);
1698 fatal ("virtual memory exhausted");
1706 register PTR val = (PTR) malloc (size);
1709 fatal ("virtual memory exhausted");
1714 fatal VPROTO ((const char *format, ...))
1716 #ifndef ANSI_PROTOTYPES
1721 VA_START (ap, format);
1723 #ifndef ANSI_PROTOTYPES
1724 format = va_arg (ap, const char *);
1727 fprintf (stderr, "genrecog: ");
1728 vfprintf (stderr, format, ap);
1730 fprintf (stderr, "\n");
1731 fprintf (stderr, "after %d definitions\n", next_index);
1732 exit (FATAL_EXIT_CODE);
1735 /* More 'friendly' abort that prints the line and file.
1736 config.h can #define abort fancy_abort if you like that sort of thing. */
1741 fatal ("Internal gcc abort.");
1750 struct decision_head recog_tree;
1751 struct decision_head split_tree;
1755 obstack_init (rtl_obstack);
1756 recog_tree.first = recog_tree.last = split_tree.first = split_tree.last = 0;
1759 fatal ("No input file name.");
1761 infile = fopen (argv[1], "r");
1765 exit (FATAL_EXIT_CODE);
1772 printf ("/* Generated automatically by the program `genrecog'\n\
1773 from the machine description file `md'. */\n\n");
1775 printf ("#include \"config.h\"\n");
1776 printf ("#include \"system.h\"\n");
1777 printf ("#include \"rtl.h\"\n");
1778 printf ("#include \"function.h\"\n");
1779 printf ("#include \"insn-config.h\"\n");
1780 printf ("#include \"recog.h\"\n");
1781 printf ("#include \"real.h\"\n");
1782 printf ("#include \"output.h\"\n");
1783 printf ("#include \"flags.h\"\n");
1786 /* Read the machine description. */
1790 c = read_skip_spaces (infile);
1795 desc = read_rtx (infile);
1796 if (GET_CODE (desc) == DEFINE_INSN)
1797 recog_tree = merge_trees (recog_tree,
1798 make_insn_sequence (desc, RECOG));
1799 else if (GET_CODE (desc) == DEFINE_SPLIT)
1800 split_tree = merge_trees (split_tree,
1801 make_insn_sequence (desc, SPLIT));
1802 if (GET_CODE (desc) == DEFINE_PEEPHOLE
1803 || GET_CODE (desc) == DEFINE_EXPAND)
1809 /* `recog' contains a decision tree\n\
1810 that recognizes whether the rtx X0 is a valid instruction.\n\
1812 recog returns -1 if the rtx is not valid.\n\
1813 If the rtx is valid, recog returns a nonnegative number\n\
1814 which is the insn code number for the pattern that matched.\n");
1815 printf (" This is the same as the order in the machine description of\n\
1816 the entry that matched. This number can be used as an index into various\n\
1817 insn_* tables, such as insn_templates, insn_outfun, and insn_n_operands\n\
1818 (found in insn-output.c).\n\n");
1819 printf (" The third argument to recog is an optional pointer to an int.\n\
1820 If present, recog will accept a pattern if it matches except for\n\
1821 missing CLOBBER expressions at the end. In that case, the value\n\
1822 pointed to by the optional pointer will be set to the number of\n\
1823 CLOBBERs that need to be added (it should be initialized to zero by\n\
1824 the caller). If it is set nonzero, the caller should allocate a\n\
1825 PARALLEL of the appropriate size, copy the initial entries, and call\n\
1826 add_clobbers (found in insn-emit.c) to fill in the CLOBBERs.");
1828 if (split_tree.first)
1829 printf ("\n\n The function split_insns returns 0 if the rtl could not\n\
1830 be split or the split rtl in a SEQUENCE if it can be.");
1834 printf ("#define operands recog_operand\n\n");
1836 next_subroutine_number = 0;
1837 break_out_subroutines (recog_tree, RECOG, 1);
1838 write_subroutine (recog_tree.first, RECOG);
1840 next_subroutine_number = 0;
1841 break_out_subroutines (split_tree, SPLIT, 1);
1842 write_subroutine (split_tree.first, SPLIT);
1845 exit (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);