1 /* Generate code from machine description to recognize rtl as insns.
2 Copyright (C) 1987, 1988, 1992 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
21 /* This program is used to produce insn-recog.c, which contains
22 a function called `recog' plus its subroutines.
23 These functions contain a decision tree
24 that recognizes whether an rtx, the argument given to recog,
25 is a valid instruction.
27 recog returns -1 if the rtx is not valid.
28 If the rtx is valid, recog returns a nonnegative number
29 which is the insn code number for the pattern that matched.
30 This is the same as the order in the machine description of the
31 entry that matched. This number can be used as an index into various
32 insn_* tables, such as insn_template, insn_outfun, and insn_n_operands
33 (found in insn-output.c).
35 The third argument to recog is an optional pointer to an int.
36 If present, recog will accept a pattern if it matches except for
37 missing CLOBBER expressions at the end. In that case, the value
38 pointed to by the optional pointer will be set to the number of
39 CLOBBERs that need to be added (it should be initialized to zero by
40 the caller). If it is set nonzero, the caller should allocate a
41 PARALLEL of the appropriate size, copy the initial entries, and call
42 add_clobbers (found in insn-emit.c) to fill in the CLOBBERs.
44 This program also generates the function `split_insns',
45 which returns 0 if the rtl could not be split, or
46 it returns the split rtl in a SEQUENCE. */
53 static struct obstack obstack
;
54 struct obstack
*rtl_obstack
= &obstack
;
56 #define obstack_chunk_alloc xmalloc
57 #define obstack_chunk_free free
60 extern rtx
read_rtx ();
62 /* Data structure for a listhead of decision trees. The alternatives
63 to a node are kept in a doublely-linked list so we can easily add nodes
64 to the proper place when merging. */
66 struct decision_head
{ struct decision
*first
, *last
; };
68 /* Data structure for decision tree for recognizing
69 legitimate instructions. */
73 int number
; /* Node number, used for labels */
74 char *position
; /* String denoting position in pattern */
75 RTX_CODE code
; /* Code to test for or UNKNOWN to suppress */
76 char ignore_code
; /* If non-zero, need not test code */
77 char ignore_mode
; /* If non-zero, need not test mode */
78 int veclen
; /* Length of vector, if nonzero */
79 enum machine_mode mode
; /* Machine mode of node */
80 char enforce_mode
; /* If non-zero, test `mode' */
81 char retest_code
, retest_mode
; /* See write_tree_1 */
82 int test_elt_zero_int
; /* Nonzero if should test XINT (rtl, 0) */
83 int elt_zero_int
; /* Required value for XINT (rtl, 0) */
84 int test_elt_one_int
; /* Nonzero if should test XINT (rtl, 1) */
85 int elt_one_int
; /* Required value for XINT (rtl, 1) */
86 int test_elt_zero_wide
; /* Nonzero if should test XWINT (rtl, 0) */
87 HOST_WIDE_INT elt_zero_wide
; /* Required value for XWINT (rtl, 0) */
88 char *tests
; /* If nonzero predicate to call */
89 int pred
; /* `preds' index of predicate or -1 */
90 char *c_test
; /* Additional test to perform */
91 struct decision_head success
; /* Nodes to test on success */
92 int insn_code_number
; /* Insn number matched, if success */
93 int num_clobbers_to_add
; /* Number of CLOBBERs to be added to pattern */
94 struct decision
*next
; /* Node to test on failure */
95 struct decision
*prev
; /* Node whose failure tests us */
96 struct decision
*afterward
; /* Node to test on success, but failure of
98 int opno
; /* Operand number, if >= 0 */
99 int dupno
; /* Number of operand to compare against */
100 int label_needed
; /* Nonzero if label needed when writing tree */
101 int subroutine_number
; /* Number of subroutine this node starts */
104 #define SUBROUTINE_THRESHOLD 50
106 static int next_subroutine_number
;
108 /* We can write two types of subroutines: One for insn recognition and
109 one to split insns. This defines which type is being written. */
111 enum routine_type
{RECOG
, SPLIT
};
113 /* Next available node number for tree nodes. */
115 static int next_number
;
117 /* Next number to use as an insn_code. */
119 static int next_insn_code
;
121 /* Similar, but counts all expressions in the MD file; used for
124 static int next_index
;
126 /* Record the highest depth we ever have so we know how many variables to
127 allocate in each subroutine we make. */
129 static int max_depth
;
131 /* This table contains a list of the rtl codes that can possibly match a
132 predicate defined in recog.c. The function `not_both_true' uses it to
133 deduce that there are no expressions that can be matches by certain pairs
134 of tree nodes. Also, if a predicate can match only one code, we can
135 hardwire that code into the node testing the predicate. */
137 static struct pred_table
140 RTX_CODE codes
[NUM_RTX_CODE
];
142 = {{"general_operand", {CONST_INT
, CONST_DOUBLE
, CONST
, SYMBOL_REF
,
143 LABEL_REF
, SUBREG
, REG
, MEM
}},
144 #ifdef PREDICATE_CODES
147 {"address_operand", {CONST_INT
, CONST_DOUBLE
, CONST
, SYMBOL_REF
,
148 LABEL_REF
, SUBREG
, REG
, MEM
, PLUS
, MINUS
, MULT
}},
149 {"register_operand", {SUBREG
, REG
}},
150 {"scratch_operand", {SCRATCH
, REG
}},
151 {"immediate_operand", {CONST_INT
, CONST_DOUBLE
, CONST
, SYMBOL_REF
,
153 {"const_int_operand", {CONST_INT
}},
154 {"const_double_operand", {CONST_INT
, CONST_DOUBLE
}},
155 {"nonimmediate_operand", {SUBREG
, REG
, MEM
}},
156 {"nonmemory_operand", {CONST_INT
, CONST_DOUBLE
, CONST
, SYMBOL_REF
,
157 LABEL_REF
, SUBREG
, REG
}},
158 {"push_operand", {MEM
}},
159 {"memory_operand", {SUBREG
, MEM
}},
160 {"indirect_operand", {SUBREG
, MEM
}},
161 {"comparison_operation", {EQ
, NE
, LE
, LT
, GE
, LT
, LEU
, LTU
, GEU
, GTU
}},
162 {"mode_independent_operand", {CONST_INT
, CONST_DOUBLE
, CONST
, SYMBOL_REF
,
163 LABEL_REF
, SUBREG
, REG
, MEM
}}};
165 #define NUM_KNOWN_PREDS (sizeof preds / sizeof preds[0])
167 static struct decision_head make_insn_sequence
PROTO((rtx
, enum routine_type
));
168 static struct decision
*add_to_sequence
PROTO((rtx
, struct decision_head
*,
170 static int not_both_true
PROTO((struct decision
*, struct decision
*,
172 static int position_merit
PROTO((struct decision
*, enum machine_mode
,
174 static struct decision_head merge_trees
PROTO((struct decision_head
,
175 struct decision_head
));
176 static int break_out_subroutines
PROTO((struct decision_head
,
177 enum routine_type
, int));
178 static void write_subroutine
PROTO((struct decision
*, enum routine_type
));
179 static void write_tree_1
PROTO((struct decision
*, char *,
180 struct decision
*, enum routine_type
));
181 static void print_code
PROTO((enum rtx_code
));
182 static int same_codes
PROTO((struct decision
*, enum rtx_code
));
183 static void clear_codes
PROTO((struct decision
*));
184 static int same_modes
PROTO((struct decision
*, enum machine_mode
));
185 static void clear_modes
PROTO((struct decision
*));
186 static void write_tree
PROTO((struct decision
*, char *,
187 struct decision
*, int,
189 static void change_state
PROTO((char *, char *, int));
190 static char *copystr
PROTO((char *));
191 static void mybzero
PROTO((char *, unsigned));
192 static void mybcopy
PROTO((char *, char *, unsigned));
193 static char *concat
PROTO((char *, char *));
194 static void fatal
PROTO((char *));
195 char *xrealloc
PROTO((char *, unsigned));
196 char *xmalloc
PROTO((unsigned));
197 void fancy_abort
PROTO((void));
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
;
214 if (XVECLEN (insn
, type
== RECOG
) == 1)
215 x
= XVECEXP (insn
, type
== RECOG
, 0);
218 x
= rtx_alloc (PARALLEL
);
219 XVEC (x
, 0) = XVEC (insn
, type
== RECOG
);
220 PUT_MODE (x
, VOIDmode
);
223 last
= add_to_sequence (x
, &head
, "");
226 last
->c_test
= c_test
;
227 last
->insn_code_number
= next_insn_code
;
228 last
->num_clobbers_to_add
= 0;
230 /* If this is not a DEFINE_SPLIT and X is a PARALLEL, see if it ends with a
231 group of CLOBBERs of (hard) registers or MATCH_SCRATCHes. If so, set up
232 to recognize the pattern without these CLOBBERs. */
234 if (type
== RECOG
&& GET_CODE (x
) == PARALLEL
)
238 for (i
= XVECLEN (x
, 0); i
> 0; i
--)
239 if (GET_CODE (XVECEXP (x
, 0, i
- 1)) != CLOBBER
240 || (GET_CODE (XEXP (XVECEXP (x
, 0, i
- 1), 0)) != REG
241 && GET_CODE (XEXP (XVECEXP (x
, 0, i
- 1), 0)) != MATCH_SCRATCH
))
244 if (i
!= XVECLEN (x
, 0))
247 struct decision_head clobber_head
;
250 new = XVECEXP (x
, 0, 0);
255 new = rtx_alloc (PARALLEL
);
256 XVEC (new, 0) = rtvec_alloc (i
);
257 for (j
= i
- 1; j
>= 0; j
--)
258 XVECEXP (new, 0, j
) = XVECEXP (x
, 0, j
);
261 last
= add_to_sequence (new, &clobber_head
, "");
264 last
->c_test
= c_test
;
265 last
->insn_code_number
= next_insn_code
;
266 last
->num_clobbers_to_add
= XVECLEN (x
, 0) - i
;
268 head
= merge_trees (head
, clobber_head
);
275 /* Define the subroutine we will call below and emit in genemit. */
276 printf ("extern rtx gen_split_%d ();\n", last
->insn_code_number
);
281 /* Create a chain of nodes to verify that an rtl expression matches
284 LAST is a pointer to the listhead in the previous node in the chain (or
285 in the calling function, for the first node).
287 POSITION is the string representing the current position in the insn.
289 A pointer to the final node in the chain is returned. */
291 static struct decision
*
292 add_to_sequence (pattern
, last
, position
)
294 struct decision_head
*last
;
297 register RTX_CODE code
;
298 register struct decision
*new
299 = (struct decision
*) xmalloc (sizeof (struct decision
));
300 struct decision
*this;
304 int depth
= strlen (position
);
307 if (depth
> max_depth
)
310 new->number
= next_number
++;
311 new->position
= copystr (position
);
312 new->ignore_code
= 0;
313 new->ignore_mode
= 0;
314 new->enforce_mode
= 1;
315 new->retest_code
= new->retest_mode
= 0;
317 new->test_elt_zero_int
= 0;
318 new->test_elt_one_int
= 0;
319 new->test_elt_zero_wide
= 0;
320 new->elt_zero_int
= 0;
321 new->elt_one_int
= 0;
322 new->elt_zero_wide
= 0;
326 new->success
.first
= new->success
.last
= 0;
327 new->insn_code_number
= -1;
328 new->num_clobbers_to_add
= 0;
334 new->label_needed
= 0;
335 new->subroutine_number
= 0;
339 last
->first
= last
->last
= new;
341 newpos
= (char *) alloca (depth
+ 2);
342 strcpy (newpos
, position
);
343 newpos
[depth
+ 1] = 0;
347 new->mode
= GET_MODE (pattern
);
348 new->code
= code
= GET_CODE (pattern
);
356 new->opno
= XINT (pattern
, 0);
357 new->code
= (code
== MATCH_PARALLEL
? PARALLEL
: UNKNOWN
);
358 new->enforce_mode
= 0;
360 if (code
== MATCH_SCRATCH
)
361 new->tests
= "scratch_operand";
363 new->tests
= XSTR (pattern
, 1);
365 if (*new->tests
== 0)
368 /* See if we know about this predicate and save its number. If we do,
369 and it only accepts one code, note that fact. The predicate
370 `const_int_operand' only tests for a CONST_INT, so if we do so we
371 can avoid calling it at all.
373 Finally, if we know that the predicate does not allow CONST_INT, we
374 know that the only way the predicate can match is if the modes match
375 (here we use the kluge of relying on the fact that "address_operand"
376 accepts CONST_INT; otherwise, it would have to be a special case),
377 so we can test the mode (but we need not). This fact should
378 considerably simplify the generated code. */
381 for (i
= 0; i
< NUM_KNOWN_PREDS
; i
++)
382 if (! strcmp (preds
[i
].name
, new->tests
))
385 int allows_const_int
= 0;
389 if (preds
[i
].codes
[1] == 0 && new->code
== UNKNOWN
)
391 new->code
= preds
[i
].codes
[0];
392 if (! strcmp ("const_int_operand", new->tests
))
393 new->tests
= 0, new->pred
= -1;
396 for (j
= 0; j
< NUM_RTX_CODE
&& preds
[i
].codes
[j
] != 0; j
++)
397 if (preds
[i
].codes
[j
] == CONST_INT
)
398 allows_const_int
= 1;
400 if (! allows_const_int
)
401 new->enforce_mode
= new->ignore_mode
= 1;
406 if (code
== MATCH_OPERATOR
|| code
== MATCH_PARALLEL
)
408 for (i
= 0; i
< XVECLEN (pattern
, 2); i
++)
410 newpos
[depth
] = i
+ (code
== MATCH_OPERATOR
? '0': 'a');
411 new = add_to_sequence (XVECEXP (pattern
, 2, i
),
412 &new->success
, newpos
);
419 new->opno
= XINT (pattern
, 0);
420 new->dupno
= XINT (pattern
, 0);
423 for (i
= 0; i
< XVECLEN (pattern
, 1); i
++)
425 newpos
[depth
] = i
+ '0';
426 new = add_to_sequence (XVECEXP (pattern
, 1, i
),
427 &new->success
, newpos
);
433 new->dupno
= XINT (pattern
, 0);
435 new->enforce_mode
= 0;
439 pattern
= XEXP (pattern
, 0);
444 new = add_to_sequence (SET_DEST (pattern
), &new->success
, newpos
);
445 this->success
.first
->enforce_mode
= 1;
447 new = add_to_sequence (SET_SRC (pattern
), &new->success
, newpos
);
449 /* If set are setting CC0 from anything other than a COMPARE, we
450 must enforce the mode so that we do not produce ambiguous insns. */
451 if (GET_CODE (SET_DEST (pattern
)) == CC0
452 && GET_CODE (SET_SRC (pattern
)) != COMPARE
)
453 this->success
.first
->enforce_mode
= 1;
458 case STRICT_LOW_PART
:
460 new = add_to_sequence (XEXP (pattern
, 0), &new->success
, newpos
);
461 this->success
.first
->enforce_mode
= 1;
465 this->test_elt_one_int
= 1;
466 this->elt_one_int
= XINT (pattern
, 1);
468 new = add_to_sequence (XEXP (pattern
, 0), &new->success
, newpos
);
469 this->success
.first
->enforce_mode
= 1;
475 new = add_to_sequence (XEXP (pattern
, 0), &new->success
, newpos
);
476 this->success
.first
->enforce_mode
= 1;
478 new = add_to_sequence (XEXP (pattern
, 1), &new->success
, newpos
);
480 new = add_to_sequence (XEXP (pattern
, 2), &new->success
, newpos
);
483 case EQ
: case NE
: case LE
: case LT
: case GE
: case GT
:
484 case LEU
: case LTU
: case GEU
: case GTU
:
485 /* If the first operand is (cc0), we don't have to do anything
487 if (GET_CODE (XEXP (pattern
, 0)) == CC0
)
490 /* ... fall through ... */
493 /* Enforce the mode on the first operand to avoid ambiguous insns. */
495 new = add_to_sequence (XEXP (pattern
, 0), &new->success
, newpos
);
496 this->success
.first
->enforce_mode
= 1;
498 new = add_to_sequence (XEXP (pattern
, 1), &new->success
, newpos
);
502 fmt
= GET_RTX_FORMAT (code
);
503 len
= GET_RTX_LENGTH (code
);
504 for (i
= 0; i
< len
; i
++)
506 newpos
[depth
] = '0' + i
;
507 if (fmt
[i
] == 'e' || fmt
[i
] == 'u')
508 new = add_to_sequence (XEXP (pattern
, i
), &new->success
, newpos
);
509 else if (fmt
[i
] == 'i' && i
== 0)
511 this->test_elt_zero_int
= 1;
512 this->elt_zero_int
= XINT (pattern
, i
);
514 else if (fmt
[i
] == 'i' && i
== 1)
516 this->test_elt_one_int
= 1;
517 this->elt_one_int
= XINT (pattern
, i
);
519 else if (fmt
[i
] == 'w' && i
== 0)
521 this->test_elt_zero_wide
= 1;
522 this->elt_zero_wide
= XWINT (pattern
, i
);
524 else if (fmt
[i
] == 'E')
527 /* We do not handle a vector appearing as other than
528 the first item, just because nothing uses them
529 and by handling only the special case
530 we can use one element in newpos for either
531 the item number of a subexpression
532 or the element number in a vector. */
535 this->veclen
= XVECLEN (pattern
, i
);
536 for (j
= 0; j
< XVECLEN (pattern
, i
); j
++)
538 newpos
[depth
] = 'a' + j
;
539 new = add_to_sequence (XVECEXP (pattern
, i
, j
),
540 &new->success
, newpos
);
543 else if (fmt
[i
] != '0')
549 /* Return 1 if we can prove that there is no RTL that can match both
550 D1 and D2. Otherwise, return 0 (it may be that there is an RTL that
551 can match both or just that we couldn't prove there wasn't such an RTL).
553 TOPLEVEL is non-zero if we are to only look at the top level and not
554 recursively descend. */
557 not_both_true (d1
, d2
, toplevel
)
558 struct decision
*d1
, *d2
;
561 struct decision
*p1
, *p2
;
563 /* If they are both to test modes and the modes are different, they aren't
564 both true. Similarly for codes, integer elements, and vector lengths. */
566 if ((d1
->enforce_mode
&& d2
->enforce_mode
567 && d1
->mode
!= VOIDmode
&& d2
->mode
!= VOIDmode
&& d1
->mode
!= d2
->mode
)
568 || (d1
->code
!= UNKNOWN
&& d2
->code
!= UNKNOWN
&& d1
->code
!= d2
->code
)
569 || (d1
->test_elt_zero_int
&& d2
->test_elt_zero_int
570 && d1
->elt_zero_int
!= d2
->elt_zero_int
)
571 || (d1
->test_elt_one_int
&& d2
->test_elt_one_int
572 && d1
->elt_one_int
!= d2
->elt_one_int
)
573 || (d1
->test_elt_zero_wide
&& d2
->test_elt_zero_wide
574 && d1
->elt_zero_wide
!= d2
->elt_zero_wide
)
575 || (d1
->veclen
&& d2
->veclen
&& d1
->veclen
!= d2
->veclen
))
578 /* If either is a wild-card MATCH_OPERAND without a predicate, it can match
579 absolutely anything, so we can't say that no intersection is possible.
580 This case is detected by having a zero TESTS field with a code of
583 if ((d1
->tests
== 0 && d1
->code
== UNKNOWN
)
584 || (d2
->tests
== 0 && d2
->code
== UNKNOWN
))
587 /* If either has a predicate that we know something about, set things up so
588 that D1 is the one that always has a known predicate. Then see if they
589 have any codes in common. */
591 if (d1
->pred
>= 0 || d2
->pred
>= 0)
596 p1
= d1
, d1
= d2
, d2
= p1
;
598 /* If D2 tests an explicit code, see if it is in the list of valid codes
599 for D1's predicate. */
600 if (d2
->code
!= UNKNOWN
)
602 for (i
= 0; i
< NUM_RTX_CODE
&& preds
[d1
->pred
].codes
[i
] != 0; i
++)
603 if (preds
[d1
->pred
].codes
[i
] == d2
->code
)
606 if (preds
[d1
->pred
].codes
[i
] == 0)
610 /* Otherwise see if the predicates have any codes in common. */
612 else if (d2
->pred
>= 0)
614 for (i
= 0; i
< NUM_RTX_CODE
&& preds
[d1
->pred
].codes
[i
] != 0; i
++)
616 for (j
= 0; j
< NUM_RTX_CODE
; j
++)
617 if (preds
[d2
->pred
].codes
[j
] == 0
618 || preds
[d2
->pred
].codes
[j
] == preds
[d1
->pred
].codes
[i
])
621 if (preds
[d2
->pred
].codes
[j
] != 0)
625 if (preds
[d1
->pred
].codes
[i
] == 0)
630 /* If we got here, we can't prove that D1 and D2 cannot both be true.
631 If we are only to check the top level, return 0. Otherwise, see if
632 we can prove that all choices in both successors are mutually
633 exclusive. If either does not have any successors, we can't prove
634 they can't both be true. */
636 if (toplevel
|| d1
->success
.first
== 0 || d2
->success
.first
== 0)
639 for (p1
= d1
->success
.first
; p1
; p1
= p1
->next
)
640 for (p2
= d2
->success
.first
; p2
; p2
= p2
->next
)
641 if (! not_both_true (p1
, p2
, 0))
647 /* Assuming that we can reorder all the alternatives at a specific point in
648 the tree (see discussion in merge_trees), we would prefer an ordering of
649 nodes where groups of consecutive nodes test the same mode and, within each
650 mode, groups of nodes test the same code. With this order, we can
651 construct nested switch statements, the inner one to test the code and
652 the outer one to test the mode.
654 We would like to list nodes testing for specific codes before those
655 that test predicates to avoid unnecessary function calls. Similarly,
656 tests for specific modes should precede nodes that allow any mode.
658 This function returns the merit (with 0 being the best) of inserting
659 a test involving the specified MODE and CODE after node P. If P is
660 zero, we are to determine the merit of inserting the test at the front
664 position_merit (p
, mode
, code
)
666 enum machine_mode mode
;
669 enum machine_mode p_mode
;
671 /* The only time the front of the list is anything other than the worst
672 position is if we are testing a mode that isn't VOIDmode. */
674 return mode
== VOIDmode
? 3 : 2;
676 p_mode
= p
->enforce_mode
? p
->mode
: VOIDmode
;
678 /* The best case is if the codes and modes both match. */
679 if (p_mode
== mode
&& p
->code
== code
)
682 /* If the codes don't match, the next best case is if the modes match.
683 In that case, the best position for this node depends on whether
684 we are testing for a specific code or not. If we are, the best place
685 is after some other test for an explicit code and our mode or after
686 the last test in the previous mode if every test in our mode is for
689 If we are testing for UNKNOWN, then the next best case is at the end of
693 && ((p_mode
== mode
&& p
->code
!= UNKNOWN
)
694 || (p_mode
!= mode
&& p
->next
695 && (p
->next
->enforce_mode
? p
->next
->mode
: VOIDmode
) == mode
696 && (p
->next
->code
== UNKNOWN
))))
697 || (code
== UNKNOWN
&& p_mode
== mode
699 || (p
->next
->enforce_mode
? p
->next
->mode
: VOIDmode
) != mode
)))
702 /* The third best case occurs when nothing is testing MODE. If MODE
703 is not VOIDmode, then the third best case is after something of any
704 mode that is not VOIDmode. If we are testing VOIDmode, the third best
705 place is the end of the list. */
708 && ((mode
!= VOIDmode
&& p_mode
!= VOIDmode
)
709 || (mode
== VOIDmode
&& p
->next
== 0)))
712 /* Otherwise, we have the worst case. */
716 /* Merge two decision tree listheads OLDH and ADDH,
717 modifying OLDH destructively, and return the merged tree. */
719 static struct decision_head
720 merge_trees (oldh
, addh
)
721 register struct decision_head oldh
, addh
;
723 struct decision
*add
, *next
;
731 /* If we are adding things at different positions, something is wrong. */
732 if (strcmp (oldh
.first
->position
, addh
.first
->position
))
735 for (add
= addh
.first
; add
; add
= next
)
737 enum machine_mode add_mode
= add
->enforce_mode
? add
->mode
: VOIDmode
;
738 struct decision
*best_position
= 0;
740 struct decision
*old
;
744 /* The semantics of pattern matching state that the tests are done in
745 the order given in the MD file so that if an insn matches two
746 patterns, the first one will be used. However, in practice, most,
747 if not all, patterns are unambiguous so that their order is
748 independent. In that case, we can merge identical tests and
749 group all similar modes and codes together.
751 Scan starting from the end of OLDH until we reach a point
752 where we reach the head of the list or where we pass a pattern
753 that could also be true if NEW is true. If we find an identical
754 pattern, we can merge them. Also, record the last node that tests
755 the same code and mode and the last one that tests just the same mode.
757 If we have no match, place NEW after the closest match we found. */
759 for (old
= oldh
.last
; old
; old
= old
->prev
)
763 /* If we don't have anything to test except an additional test,
764 do not consider the two nodes equal. If we did, the test below
765 would cause an infinite recursion. */
766 if (old
->tests
== 0 && old
->test_elt_zero_int
== 0
767 && old
->test_elt_one_int
== 0 && old
->veclen
== 0
768 && old
->test_elt_zero_wide
== 0
769 && old
->dupno
== -1 && old
->mode
== VOIDmode
770 && old
->code
== UNKNOWN
771 && (old
->c_test
!= 0 || add
->c_test
!= 0))
774 else if ((old
->tests
== add
->tests
775 || (old
->pred
>= 0 && old
->pred
== add
->pred
)
776 || (old
->tests
&& add
->tests
777 && !strcmp (old
->tests
, add
->tests
)))
778 && old
->test_elt_zero_int
== add
->test_elt_zero_int
779 && old
->elt_zero_int
== add
->elt_zero_int
780 && old
->test_elt_one_int
== add
->test_elt_one_int
781 && old
->elt_one_int
== add
->elt_one_int
782 && old
->test_elt_zero_wide
== add
->test_elt_zero_wide
783 && old
->elt_zero_wide
== add
->elt_zero_wide
784 && old
->veclen
== add
->veclen
785 && old
->dupno
== add
->dupno
786 && old
->opno
== add
->opno
787 && old
->code
== add
->code
788 && old
->enforce_mode
== add
->enforce_mode
789 && old
->mode
== add
->mode
)
791 /* If the additional test is not the same, split both nodes
792 into nodes that just contain all things tested before the
793 additional test and nodes that contain the additional test
794 and actions when it is true. This optimization is important
795 because of the case where we have almost identical patterns
796 with different tests on target flags. */
798 if (old
->c_test
!= add
->c_test
799 && ! (old
->c_test
&& add
->c_test
800 && !strcmp (old
->c_test
, add
->c_test
)))
802 if (old
->insn_code_number
>= 0 || old
->opno
>= 0)
804 struct decision
*split
805 = (struct decision
*) xmalloc (sizeof (struct decision
));
807 mybcopy ((char *) old
, (char *) split
,
808 sizeof (struct decision
));
810 old
->success
.first
= old
->success
.last
= split
;
813 old
->insn_code_number
= -1;
814 old
->num_clobbers_to_add
= 0;
816 split
->number
= next_number
++;
817 split
->next
= split
->prev
= 0;
818 split
->mode
= VOIDmode
;
819 split
->code
= UNKNOWN
;
821 split
->test_elt_zero_int
= 0;
822 split
->test_elt_one_int
= 0;
823 split
->test_elt_zero_wide
= 0;
829 if (add
->insn_code_number
>= 0 || add
->opno
>= 0)
831 struct decision
*split
832 = (struct decision
*) xmalloc (sizeof (struct decision
));
834 mybcopy ((char *) add
, (char *) split
,
835 sizeof (struct decision
));
837 add
->success
.first
= add
->success
.last
= split
;
840 add
->insn_code_number
= -1;
841 add
->num_clobbers_to_add
= 0;
843 split
->number
= next_number
++;
844 split
->next
= split
->prev
= 0;
845 split
->mode
= VOIDmode
;
846 split
->code
= UNKNOWN
;
848 split
->test_elt_zero_int
= 0;
849 split
->test_elt_one_int
= 0;
850 split
->test_elt_zero_wide
= 0;
857 if (old
->insn_code_number
>= 0 && add
->insn_code_number
>= 0)
859 /* If one node is for a normal insn and the second is
860 for the base insn with clobbers stripped off, the
861 second node should be ignored. */
863 if (old
->num_clobbers_to_add
== 0
864 && add
->num_clobbers_to_add
> 0)
865 /* Nothing to do here. */
867 else if (old
->num_clobbers_to_add
> 0
868 && add
->num_clobbers_to_add
== 0)
870 /* In this case, replace OLD with ADD. */
871 old
->insn_code_number
= add
->insn_code_number
;
872 old
->num_clobbers_to_add
= 0;
875 fatal ("Two actions at one point in tree");
878 if (old
->insn_code_number
== -1)
879 old
->insn_code_number
= add
->insn_code_number
;
880 old
->success
= merge_trees (old
->success
, add
->success
);
885 /* Unless we have already found the best possible insert point,
886 see if this position is better. If so, record it. */
889 && ((our_merit
= position_merit (old
, add_mode
, add
->code
))
891 best_merit
= our_merit
, best_position
= old
;
893 if (! not_both_true (old
, add
, 0))
897 /* If ADD was duplicate, we are done. */
901 /* Otherwise, find the best place to insert ADD. Normally this is
902 BEST_POSITION. However, if we went all the way to the top of
903 the list, it might be better to insert at the top. */
905 if (best_position
== 0)
909 && position_merit (NULL_PTR
, add_mode
, add
->code
) < best_merit
)
912 add
->next
= oldh
.first
;
913 oldh
.first
->prev
= add
;
919 add
->prev
= best_position
;
920 add
->next
= best_position
->next
;
921 best_position
->next
= add
;
922 if (best_position
== oldh
.last
)
925 add
->next
->prev
= add
;
932 /* Count the number of subnodes of HEAD. If the number is high enough,
933 make the first node in HEAD start a separate subroutine in the C code
936 TYPE gives the type of routine we are writing.
938 INITIAL is non-zero if this is the highest-level node. We never write
942 break_out_subroutines (head
, type
, initial
)
943 struct decision_head head
;
944 enum routine_type type
;
948 struct decision
*node
, *sub
;
950 for (sub
= head
.first
; sub
; sub
= sub
->next
)
951 size
+= 1 + break_out_subroutines (sub
->success
, type
, 0);
953 if (size
> SUBROUTINE_THRESHOLD
&& ! initial
)
955 head
.first
->subroutine_number
= ++next_subroutine_number
;
956 write_subroutine (head
.first
, type
);
962 /* Write out a subroutine of type TYPE to do comparisons starting at node
966 write_subroutine (tree
, type
)
967 struct decision
*tree
;
968 enum routine_type type
;
973 printf ("rtx\nsplit");
975 printf ("int\nrecog");
977 if (tree
!= 0 && tree
->subroutine_number
> 0)
978 printf ("_%d", tree
->subroutine_number
);
979 else if (type
== SPLIT
)
982 printf (" (x0, insn");
984 printf (", pnum_clobbers");
987 printf (" register rtx x0;\n rtx insn;\n");
989 printf (" int *pnum_clobbers;\n");
992 printf (" register rtx *ro = &recog_operand[0];\n");
994 printf (" register rtx ");
995 for (i
= 1; i
< max_depth
; i
++)
998 printf ("x%d;\n", max_depth
);
999 printf (" %s tem;\n", type
== SPLIT
? "rtx" : "int");
1000 write_tree (tree
, "", NULL_PTR
, 1, type
);
1001 printf (" ret0: return %d;\n}\n\n", type
== SPLIT
? 0 : -1);
1004 /* This table is used to indent the recog_* functions when we are inside
1005 conditions or switch statements. We only support small indentations
1006 and always indent at least two spaces. */
1008 static char *indents
[]
1009 = {" ", " ", " ", " ", " ", " ", " ", " ",
1010 "\t", "\t ", "\t ", "\t ", "\t ", "\t ", "\t ",
1011 "\t\t", "\t\t ", "\t\t ", "\t\t ", "\t\t ", "\t\t "};
1013 /* Write out C code to perform the decisions in TREE for a subroutine of
1014 type TYPE. If all of the choices fail, branch to node AFTERWARD, if
1015 non-zero, otherwise return. PREVPOS is the position of the node that
1016 branched to this test.
1018 When we merged all alternatives, we tried to set up a convenient order.
1019 Specifically, tests involving the same mode are all grouped together,
1020 followed by a group that does not contain a mode test. Within each group
1021 of the same mode, we also group tests with the same code, followed by a
1022 group that does not test a code.
1024 Occasionally, we cannot arbitrarily reorder the tests so that multiple
1025 sequence of groups as described above are present.
1027 We generate two nested switch statements, the outer statement for
1028 testing modes, and the inner switch for testing RTX codes. It is
1029 not worth optimizing cases when only a small number of modes or
1030 codes is tested, since the compiler can do that when compiling the
1031 resulting function. We do check for when every test is the same mode
1035 write_tree_1 (tree
, prevpos
, afterward
, type
)
1036 struct decision
*tree
;
1038 struct decision
*afterward
;
1039 enum routine_type type
;
1041 register struct decision
*p
, *p1
;
1042 register int depth
= tree
? strlen (tree
->position
) : 0;
1043 enum machine_mode switch_mode
= VOIDmode
;
1044 RTX_CODE switch_code
= UNKNOWN
;
1046 char modemap
[NUM_MACHINE_MODES
];
1047 char codemap
[NUM_RTX_CODE
];
1051 /* One tricky area is what is the exact state when we branch to a
1052 node's label. There are two cases where we branch: when looking at
1053 successors to a node, or when a set of tests fails.
1055 In the former case, we are always branching to the first node in a
1056 decision list and we want all required tests to be performed. We
1057 put the labels for such nodes in front of any switch or test statements.
1058 These branches are done without updating the position to that of the
1061 In the latter case, we are branching to a node that is not the first
1062 node in a decision list. We have already checked that it is possible
1063 for both the node we originally tested at this level and the node we
1064 are branching to to be both match some pattern. That means that they
1065 usually will be testing the same mode and code. So it is normally safe
1066 for such labels to be inside switch statements, since the tests done
1067 by virtue of arriving at that label will usually already have been
1068 done. The exception is a branch from a node that does not test a
1069 mode or code to one that does. In such cases, we set the `retest_mode'
1070 or `retest_code' flags. That will ensure that we start a new switch
1071 at that position and put the label before the switch.
1073 The branches in the latter case must set the position to that of the
1078 if (tree
&& tree
->subroutine_number
== 0)
1080 printf (" L%d:\n", tree
->number
);
1081 tree
->label_needed
= 0;
1086 change_state (prevpos
, tree
->position
, 2);
1087 prevpos
= tree
->position
;
1090 for (p
= tree
; p
; p
= p
->next
)
1092 enum machine_mode mode
= p
->enforce_mode
? p
->mode
: VOIDmode
;
1094 int wrote_bracket
= 0;
1097 if (p
->success
.first
== 0 && p
->insn_code_number
< 0)
1100 /* Find the next alternative to p that might be true when p is true.
1101 Test that one next if p's successors fail. */
1103 for (p1
= p
->next
; p1
&& not_both_true (p
, p1
, 1); p1
= p1
->next
)
1109 if (mode
== VOIDmode
&& p1
->enforce_mode
&& p1
->mode
!= VOIDmode
)
1110 p1
->retest_mode
= 1;
1111 if (p
->code
== UNKNOWN
&& p1
->code
!= UNKNOWN
)
1112 p1
->retest_code
= 1;
1113 p1
->label_needed
= 1;
1116 /* If we have a different code or mode than the last node and
1117 are in a switch on codes, we must either end the switch or
1118 go to another case. We must also end the switch if this
1119 node needs a label and to retest either the mode or code. */
1121 if (switch_code
!= UNKNOWN
1122 && (switch_code
!= p
->code
|| switch_mode
!= mode
1123 || (p
->label_needed
&& (p
->retest_mode
|| p
->retest_code
))))
1125 enum rtx_code code
= p
->code
;
1127 /* If P is testing a predicate that we know about and we haven't
1128 seen any of the codes that are valid for the predicate, we
1129 can write a series of "case" statement, one for each possible
1130 code. Since we are already in a switch, these redundant tests
1131 are very cheap and will reduce the number of predicate called. */
1135 for (i
= 0; i
< NUM_RTX_CODE
&& preds
[p
->pred
].codes
[i
] != 0; i
++)
1136 if (codemap
[(int) preds
[p
->pred
].codes
[i
]])
1139 if (preds
[p
->pred
].codes
[i
] == 0)
1140 code
= MATCH_OPERAND
;
1143 if (code
== UNKNOWN
|| codemap
[(int) code
]
1144 || switch_mode
!= mode
1145 || (p
->label_needed
&& (p
->retest_mode
|| p
->retest_code
)))
1147 printf ("%s}\n", indents
[indent
- 2]);
1148 switch_code
= UNKNOWN
;
1154 printf ("%sbreak;\n", indents
[indent
]);
1156 if (code
== MATCH_OPERAND
)
1158 for (i
= 0; i
< NUM_RTX_CODE
&& preds
[p
->pred
].codes
[i
] != 0; i
++)
1160 printf ("%scase ", indents
[indent
- 2]);
1161 print_code (preds
[p
->pred
].codes
[i
]);
1163 codemap
[(int) preds
[p
->pred
].codes
[i
]] = 1;
1168 printf ("%scase ", indents
[indent
- 2]);
1171 codemap
[(int) p
->code
] = 1;
1180 /* If we were previously in a switch on modes and now have a different
1181 mode, end at least the case, and maybe end the switch if we are
1182 not testing a mode or testing a mode whose case we already saw. */
1184 if (switch_mode
!= VOIDmode
1185 && (switch_mode
!= mode
|| (p
->label_needed
&& p
->retest_mode
)))
1187 if (mode
== VOIDmode
|| modemap
[(int) mode
]
1188 || (p
->label_needed
&& p
->retest_mode
))
1190 printf ("%s}\n", indents
[indent
- 2]);
1191 switch_mode
= VOIDmode
;
1197 printf (" break;\n");
1198 printf (" case %smode:\n", GET_MODE_NAME (mode
));
1200 modemap
[(int) mode
] = 1;
1206 /* If we are about to write dead code, something went wrong. */
1207 if (! p
->label_needed
&& uncond
)
1210 /* If we need a label and we will want to retest the mode or code at
1211 that label, write the label now. We have already ensured that
1212 things will be valid for the test. */
1214 if (p
->label_needed
&& (p
->retest_mode
|| p
->retest_code
))
1216 printf ("%sL%d:\n", indents
[indent
- 2], p
->number
);
1217 p
->label_needed
= 0;
1222 /* If we are not in any switches, see if we can shortcut things
1223 by checking for identical modes and codes. */
1225 if (switch_mode
== VOIDmode
&& switch_code
== UNKNOWN
)
1227 /* If p and its alternatives all want the same mode,
1228 reject all others at once, first, then ignore the mode. */
1230 if (mode
!= VOIDmode
&& p
->next
&& same_modes (p
, mode
))
1232 printf (" if (GET_MODE (x%d) != %smode)\n",
1233 depth
, GET_MODE_NAME (p
->mode
));
1237 change_state (p
->position
, afterward
->position
, 6);
1238 printf (" goto L%d;\n }\n", afterward
->number
);
1241 printf (" goto ret0;\n");
1246 /* If p and its alternatives all want the same code,
1247 reject all others at once, first, then ignore the code. */
1249 if (p
->code
!= UNKNOWN
&& p
->next
&& same_codes (p
, p
->code
))
1251 printf (" if (GET_CODE (x%d) != ", depth
);
1252 print_code (p
->code
);
1257 change_state (p
->position
, afterward
->position
, indent
+ 4);
1258 printf (" goto L%d;\n }\n", afterward
->number
);
1261 printf (" goto ret0;\n");
1266 /* If we are not in a mode switch and we are testing for a specific
1267 mode, start a mode switch unless we have just one node or the next
1268 node is not testing a mode (we have already tested for the case of
1269 more than one mode, but all of the same mode). */
1271 if (switch_mode
== VOIDmode
&& mode
!= VOIDmode
&& p
->next
!= 0
1272 && p
->next
->enforce_mode
&& p
->next
->mode
!= VOIDmode
)
1274 mybzero (modemap
, sizeof modemap
);
1275 printf ("%sswitch (GET_MODE (x%d))\n", indents
[indent
], depth
);
1276 printf ("%s{\n", indents
[indent
+ 2]);
1278 printf ("%scase %smode:\n", indents
[indent
- 2],
1279 GET_MODE_NAME (mode
));
1280 modemap
[(int) mode
] = 1;
1284 /* Similarly for testing codes. */
1286 if (switch_code
== UNKNOWN
&& p
->code
!= UNKNOWN
&& ! p
->ignore_code
1287 && p
->next
!= 0 && p
->next
->code
!= UNKNOWN
)
1289 mybzero (codemap
, sizeof codemap
);
1290 printf ("%sswitch (GET_CODE (x%d))\n", indents
[indent
], depth
);
1291 printf ("%s{\n", indents
[indent
+ 2]);
1293 printf ("%scase ", indents
[indent
- 2]);
1294 print_code (p
->code
);
1296 codemap
[(int) p
->code
] = 1;
1297 switch_code
= p
->code
;
1300 /* Now that most mode and code tests have been done, we can write out
1301 a label for an inner node, if we haven't already. */
1302 if (p
->label_needed
)
1303 printf ("%sL%d:\n", indents
[indent
- 2], p
->number
);
1305 inner_indent
= indent
;
1307 /* The only way we can have to do a mode or code test here is if
1308 this node needs such a test but is the only node to be tested.
1309 In that case, we won't have started a switch. Note that this is
1310 the only way the switch and test modes can disagree. */
1312 if ((mode
!= switch_mode
&& ! p
->ignore_mode
)
1313 || (p
->code
!= switch_code
&& p
->code
!= UNKNOWN
&& ! p
->ignore_code
)
1314 || p
->test_elt_zero_int
|| p
->test_elt_one_int
1315 || p
->test_elt_zero_wide
|| p
->veclen
1316 || p
->dupno
>= 0 || p
->tests
|| p
->num_clobbers_to_add
)
1318 printf ("%sif (", indents
[indent
]);
1320 if (mode
!= switch_mode
&& ! p
->ignore_mode
)
1321 printf ("GET_MODE (x%d) == %smode && ",
1322 depth
, GET_MODE_NAME (mode
));
1323 if (p
->code
!= switch_code
&& p
->code
!= UNKNOWN
&& ! p
->ignore_code
)
1325 printf ("GET_CODE (x%d) == ", depth
);
1326 print_code (p
->code
);
1330 if (p
->test_elt_zero_int
)
1331 printf ("XINT (x%d, 0) == %d && ", depth
, p
->elt_zero_int
);
1332 if (p
->test_elt_one_int
)
1333 printf ("XINT (x%d, 1) == %d && ", depth
, p
->elt_one_int
);
1334 if (p
->test_elt_zero_wide
)
1336 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
1337 "XWINT (x%d, 0) == %d && ",
1339 "XWINT (x%d, 0) == %ld && ",
1341 depth
, p
->elt_zero_wide
);
1343 printf ("XVECLEN (x%d, 0) == %d && ", depth
, p
->veclen
);
1345 printf ("rtx_equal_p (x%d, ro[%d]) && ", depth
, p
->dupno
);
1346 if (p
->num_clobbers_to_add
)
1347 printf ("pnum_clobbers != 0 && ");
1349 printf ("%s (x%d, %smode)", p
->tests
, depth
,
1350 GET_MODE_NAME (p
->mode
));
1360 need_bracket
= ! uncond
;
1366 printf ("%s{\n", indents
[inner_indent
]);
1372 printf ("%sro[%d] = x%d;\n", indents
[inner_indent
], p
->opno
, depth
);
1377 printf ("%sif (%s)\n", indents
[inner_indent
], p
->c_test
);
1383 if (p
->insn_code_number
>= 0)
1386 printf ("%sreturn gen_split_%d (operands);\n",
1387 indents
[inner_indent
], p
->insn_code_number
);
1390 if (p
->num_clobbers_to_add
)
1394 printf ("%s{\n", indents
[inner_indent
]);
1398 printf ("%s*pnum_clobbers = %d;\n",
1399 indents
[inner_indent
], p
->num_clobbers_to_add
);
1400 printf ("%sreturn %d;\n",
1401 indents
[inner_indent
], p
->insn_code_number
);
1406 printf ("%s}\n", indents
[inner_indent
]);
1410 printf ("%sreturn %d;\n",
1411 indents
[inner_indent
], p
->insn_code_number
);
1415 printf ("%sgoto L%d;\n", indents
[inner_indent
],
1416 p
->success
.first
->number
);
1419 printf ("%s}\n", indents
[inner_indent
- 2]);
1422 /* We have now tested all alternatives. End any switches we have open
1423 and branch to the alternative node unless we know that we can't fall
1424 through to the branch. */
1426 if (switch_code
!= UNKNOWN
)
1428 printf ("%s}\n", indents
[indent
- 2]);
1433 if (switch_mode
!= VOIDmode
)
1435 printf ("%s}\n", indents
[indent
- 2]);
1448 change_state (prevpos
, afterward
->position
, 2);
1449 printf (" goto L%d;\n", afterward
->number
);
1452 printf (" goto ret0;\n");
1460 for (p1
= GET_RTX_NAME (code
); *p1
; p1
++)
1462 if (*p1
>= 'a' && *p1
<= 'z')
1463 putchar (*p1
+ 'A' - 'a');
1470 same_codes (p
, code
)
1471 register struct decision
*p
;
1472 register enum rtx_code code
;
1474 for (; p
; p
= p
->next
)
1475 if (p
->code
!= code
)
1483 register struct decision
*p
;
1485 for (; p
; p
= p
->next
)
1490 same_modes (p
, mode
)
1491 register struct decision
*p
;
1492 register enum machine_mode mode
;
1494 for (; p
; p
= p
->next
)
1495 if ((p
->enforce_mode
? p
->mode
: VOIDmode
) != mode
)
1503 register struct decision
*p
;
1505 for (; p
; p
= p
->next
)
1506 p
->enforce_mode
= 0;
1509 /* Write out the decision tree starting at TREE for a subroutine of type TYPE.
1511 PREVPOS is the position at the node that branched to this node.
1513 INITIAL is nonzero if this is the first node we are writing in a subroutine.
1515 If all nodes are false, branch to the node AFTERWARD. */
1518 write_tree (tree
, prevpos
, afterward
, initial
, type
)
1519 struct decision
*tree
;
1521 struct decision
*afterward
;
1523 enum routine_type type
;
1525 register struct decision
*p
;
1526 char *name_prefix
= (type
== SPLIT
? "split" : "recog");
1527 char *call_suffix
= (type
== SPLIT
? "" : ", pnum_clobbers");
1529 if (! initial
&& tree
->subroutine_number
> 0)
1531 printf (" L%d:\n", tree
->number
);
1535 printf (" tem = %s_%d (x0, insn%s);\n",
1536 name_prefix
, tree
->subroutine_number
, call_suffix
);
1538 printf (" if (tem != 0) return tem;\n");
1540 printf (" if (tem >= 0) return tem;\n");
1541 change_state (tree
->position
, afterward
->position
, 2);
1542 printf (" goto L%d;\n", afterward
->number
);
1545 printf (" return %s_%d (x0, insn%s);\n",
1546 name_prefix
, tree
->subroutine_number
, call_suffix
);
1550 write_tree_1 (tree
, prevpos
, afterward
, type
);
1552 for (p
= tree
; p
; p
= p
->next
)
1553 if (p
->success
.first
)
1554 write_tree (p
->success
.first
, p
->position
,
1555 p
->afterward
? p
->afterward
: afterward
, 0, type
);
1559 /* Assuming that the state of argument is denoted by OLDPOS, take whatever
1560 actions are necessary to move to NEWPOS.
1562 INDENT says how many blanks to place at the front of lines. */
1565 change_state (oldpos
, newpos
, indent
)
1570 int odepth
= strlen (oldpos
);
1572 int ndepth
= strlen (newpos
);
1574 /* Pop up as many levels as necessary. */
1576 while (strncmp (oldpos
, newpos
, depth
))
1579 /* Go down to desired level. */
1581 while (depth
< ndepth
)
1583 if (newpos
[depth
] >= 'a' && newpos
[depth
] <= 'z')
1584 printf ("%sx%d = XVECEXP (x%d, 0, %d);\n",
1585 indents
[indent
], depth
+ 1, depth
, newpos
[depth
] - 'a');
1587 printf ("%sx%d = XEXP (x%d, %c);\n",
1588 indents
[indent
], depth
+ 1, depth
, newpos
[depth
]);
1602 tem
= (char *) xmalloc (strlen (s1
) + 1);
1611 register unsigned length
;
1613 while (length
-- > 0)
1618 mybcopy (in
, out
, length
)
1619 register char *in
, *out
;
1620 register unsigned length
;
1622 while (length
-- > 0)
1637 tem
= (char *) xmalloc (strlen (s1
) + strlen (s2
) + 2);
1646 xrealloc (ptr
, size
)
1650 char *result
= (char *) realloc (ptr
, size
);
1652 fatal ("virtual memory exhausted");
1660 register char *val
= (char *) malloc (size
);
1663 fatal ("virtual memory exhausted");
1671 fprintf (stderr
, "genrecog: ");
1672 fprintf (stderr
, s
);
1673 fprintf (stderr
, "\n");
1674 fprintf (stderr
, "after %d definitions\n", next_index
);
1675 exit (FATAL_EXIT_CODE
);
1678 /* More 'friendly' abort that prints the line and file.
1679 config.h can #define abort fancy_abort if you like that sort of thing. */
1684 fatal ("Internal gcc abort.");
1693 struct decision_head recog_tree
;
1694 struct decision_head split_tree
;
1698 obstack_init (rtl_obstack
);
1699 recog_tree
.first
= recog_tree
.last
= split_tree
.first
= split_tree
.last
= 0;
1702 fatal ("No input file name.");
1704 infile
= fopen (argv
[1], "r");
1708 exit (FATAL_EXIT_CODE
);
1715 printf ("/* Generated automatically by the program `genrecog'\n\
1716 from the machine description file `md'. */\n\n");
1718 printf ("#include \"config.h\"\n");
1719 printf ("#include \"rtl.h\"\n");
1720 printf ("#include \"insn-config.h\"\n");
1721 printf ("#include \"recog.h\"\n");
1722 printf ("#include \"real.h\"\n");
1723 printf ("#include \"output.h\"\n");
1724 printf ("#include \"flags.h\"\n");
1727 /* Read the machine description. */
1731 c
= read_skip_spaces (infile
);
1736 desc
= read_rtx (infile
);
1737 if (GET_CODE (desc
) == DEFINE_INSN
)
1738 recog_tree
= merge_trees (recog_tree
,
1739 make_insn_sequence (desc
, RECOG
));
1740 else if (GET_CODE (desc
) == DEFINE_SPLIT
)
1741 split_tree
= merge_trees (split_tree
,
1742 make_insn_sequence (desc
, SPLIT
));
1743 if (GET_CODE (desc
) == DEFINE_PEEPHOLE
1744 || GET_CODE (desc
) == DEFINE_EXPAND
)
1750 /* `recog' contains a decision tree\n\
1751 that recognizes whether the rtx X0 is a valid instruction.\n\
1753 recog returns -1 if the rtx is not valid.\n\
1754 If the rtx is valid, recog returns a nonnegative number\n\
1755 which is the insn code number for the pattern that matched.\n");
1756 printf (" This is the same as the order in the machine description of\n\
1757 the entry that matched. This number can be used as an index into\n\
1758 entry that matched. This number can be used as an index into various\n\
1759 insn_* tables, such as insn_templates, insn_outfun, and insn_n_operands\n\
1760 (found in insn-output.c).\n\n");
1761 printf (" The third argument to recog is an optional pointer to an int.\n\
1762 If present, recog will accept a pattern if it matches except for\n\
1763 missing CLOBBER expressions at the end. In that case, the value\n\
1764 pointed to by the optional pointer will be set to the number of\n\
1765 CLOBBERs that need to be added (it should be initialized to zero by\n\
1766 the caller). If it is set nonzero, the caller should allocate a\n\
1767 PARALLEL of the appropriate size, copy the initial entries, and call\n\
1768 add_clobbers (found in insn-emit.c) to fill in the CLOBBERs.");
1770 if (split_tree
.first
)
1771 printf ("\n\n The function split_insns returns 0 if the rtl could not\n\
1772 be split or the split rtl in a SEQUENCE if it can be.");
1776 printf ("rtx recog_operand[MAX_RECOG_OPERANDS];\n\n");
1777 printf ("rtx *recog_operand_loc[MAX_RECOG_OPERANDS];\n\n");
1778 printf ("rtx *recog_dup_loc[MAX_DUP_OPERANDS];\n\n");
1779 printf ("char recog_dup_num[MAX_DUP_OPERANDS];\n\n");
1780 printf ("#define operands recog_operand\n\n");
1782 next_subroutine_number
= 0;
1783 break_out_subroutines (recog_tree
, RECOG
, 1);
1784 write_subroutine (recog_tree
.first
, RECOG
);
1786 next_subroutine_number
= 0;
1787 break_out_subroutines (split_tree
, SPLIT
, 1);
1788 write_subroutine (split_tree
.first
, SPLIT
);
1791 exit (ferror (stdout
) != 0 ? FATAL_EXIT_CODE
: SUCCESS_EXIT_CODE
);