1 /* Generate code from machine description to recognize rtl as insns.
2 Copyright (C) 1987, 1988, 1992, 1993, 1994 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_operator", {EQ
, NE
, LE
, LT
, GE
, GT
, 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. */
382 for (i
= 0; i
< NUM_KNOWN_PREDS
; i
++)
383 if (! strcmp (preds
[i
].name
, new->tests
))
386 int allows_const_int
= 0;
390 if (preds
[i
].codes
[1] == 0 && new->code
== UNKNOWN
)
392 new->code
= preds
[i
].codes
[0];
393 if (! strcmp ("const_int_operand", new->tests
))
394 new->tests
= 0, new->pred
= -1;
397 for (j
= 0; j
< NUM_RTX_CODE
&& preds
[i
].codes
[j
] != 0; j
++)
398 if (preds
[i
].codes
[j
] == CONST_INT
)
399 allows_const_int
= 1;
401 if (! allows_const_int
)
402 new->enforce_mode
= new->ignore_mode
= 1;
407 #ifdef PREDICATE_CODES
408 /* If the port has a list of the predicates it uses but omits
410 if (i
== NUM_KNOWN_PREDS
)
411 fprintf (stderr
, "Warning: `%s' not in PREDICATE_CODES\n",
416 if (code
== MATCH_OPERATOR
|| code
== MATCH_PARALLEL
)
418 for (i
= 0; i
< XVECLEN (pattern
, 2); i
++)
420 newpos
[depth
] = i
+ (code
== MATCH_OPERATOR
? '0': 'a');
421 new = add_to_sequence (XVECEXP (pattern
, 2, i
),
422 &new->success
, newpos
);
429 new->opno
= XINT (pattern
, 0);
430 new->dupno
= XINT (pattern
, 0);
433 for (i
= 0; i
< XVECLEN (pattern
, 1); i
++)
435 newpos
[depth
] = i
+ '0';
436 new = add_to_sequence (XVECEXP (pattern
, 1, i
),
437 &new->success
, newpos
);
443 new->dupno
= XINT (pattern
, 0);
445 new->enforce_mode
= 0;
449 pattern
= XEXP (pattern
, 0);
454 new = add_to_sequence (SET_DEST (pattern
), &new->success
, newpos
);
455 this->success
.first
->enforce_mode
= 1;
457 new = add_to_sequence (SET_SRC (pattern
), &new->success
, newpos
);
459 /* If set are setting CC0 from anything other than a COMPARE, we
460 must enforce the mode so that we do not produce ambiguous insns. */
461 if (GET_CODE (SET_DEST (pattern
)) == CC0
462 && GET_CODE (SET_SRC (pattern
)) != COMPARE
)
463 this->success
.first
->enforce_mode
= 1;
468 case STRICT_LOW_PART
:
470 new = add_to_sequence (XEXP (pattern
, 0), &new->success
, newpos
);
471 this->success
.first
->enforce_mode
= 1;
475 this->test_elt_one_int
= 1;
476 this->elt_one_int
= XINT (pattern
, 1);
478 new = add_to_sequence (XEXP (pattern
, 0), &new->success
, newpos
);
479 this->success
.first
->enforce_mode
= 1;
485 new = add_to_sequence (XEXP (pattern
, 0), &new->success
, newpos
);
486 this->success
.first
->enforce_mode
= 1;
488 new = add_to_sequence (XEXP (pattern
, 1), &new->success
, newpos
);
490 new = add_to_sequence (XEXP (pattern
, 2), &new->success
, newpos
);
493 case EQ
: case NE
: case LE
: case LT
: case GE
: case GT
:
494 case LEU
: case LTU
: case GEU
: case GTU
:
495 /* If the first operand is (cc0), we don't have to do anything
497 if (GET_CODE (XEXP (pattern
, 0)) == CC0
)
500 /* ... fall through ... */
503 /* Enforce the mode on the first operand to avoid ambiguous insns. */
505 new = add_to_sequence (XEXP (pattern
, 0), &new->success
, newpos
);
506 this->success
.first
->enforce_mode
= 1;
508 new = add_to_sequence (XEXP (pattern
, 1), &new->success
, newpos
);
512 fmt
= GET_RTX_FORMAT (code
);
513 len
= GET_RTX_LENGTH (code
);
514 for (i
= 0; i
< len
; i
++)
516 newpos
[depth
] = '0' + i
;
517 if (fmt
[i
] == 'e' || fmt
[i
] == 'u')
518 new = add_to_sequence (XEXP (pattern
, i
), &new->success
, newpos
);
519 else if (fmt
[i
] == 'i' && i
== 0)
521 this->test_elt_zero_int
= 1;
522 this->elt_zero_int
= XINT (pattern
, i
);
524 else if (fmt
[i
] == 'i' && i
== 1)
526 this->test_elt_one_int
= 1;
527 this->elt_one_int
= XINT (pattern
, i
);
529 else if (fmt
[i
] == 'w' && i
== 0)
531 this->test_elt_zero_wide
= 1;
532 this->elt_zero_wide
= XWINT (pattern
, i
);
534 else if (fmt
[i
] == 'E')
537 /* We do not handle a vector appearing as other than
538 the first item, just because nothing uses them
539 and by handling only the special case
540 we can use one element in newpos for either
541 the item number of a subexpression
542 or the element number in a vector. */
545 this->veclen
= XVECLEN (pattern
, i
);
546 for (j
= 0; j
< XVECLEN (pattern
, i
); j
++)
548 newpos
[depth
] = 'a' + j
;
549 new = add_to_sequence (XVECEXP (pattern
, i
, j
),
550 &new->success
, newpos
);
553 else if (fmt
[i
] != '0')
559 /* Return 1 if we can prove that there is no RTL that can match both
560 D1 and D2. Otherwise, return 0 (it may be that there is an RTL that
561 can match both or just that we couldn't prove there wasn't such an RTL).
563 TOPLEVEL is non-zero if we are to only look at the top level and not
564 recursively descend. */
567 not_both_true (d1
, d2
, toplevel
)
568 struct decision
*d1
, *d2
;
571 struct decision
*p1
, *p2
;
573 /* If they are both to test modes and the modes are different, they aren't
574 both true. Similarly for codes, integer elements, and vector lengths. */
576 if ((d1
->enforce_mode
&& d2
->enforce_mode
577 && d1
->mode
!= VOIDmode
&& d2
->mode
!= VOIDmode
&& d1
->mode
!= d2
->mode
)
578 || (d1
->code
!= UNKNOWN
&& d2
->code
!= UNKNOWN
&& d1
->code
!= d2
->code
)
579 || (d1
->test_elt_zero_int
&& d2
->test_elt_zero_int
580 && d1
->elt_zero_int
!= d2
->elt_zero_int
)
581 || (d1
->test_elt_one_int
&& d2
->test_elt_one_int
582 && d1
->elt_one_int
!= d2
->elt_one_int
)
583 || (d1
->test_elt_zero_wide
&& d2
->test_elt_zero_wide
584 && d1
->elt_zero_wide
!= d2
->elt_zero_wide
)
585 || (d1
->veclen
&& d2
->veclen
&& d1
->veclen
!= d2
->veclen
))
588 /* If either is a wild-card MATCH_OPERAND without a predicate, it can match
589 absolutely anything, so we can't say that no intersection is possible.
590 This case is detected by having a zero TESTS field with a code of
593 if ((d1
->tests
== 0 && d1
->code
== UNKNOWN
)
594 || (d2
->tests
== 0 && d2
->code
== UNKNOWN
))
597 /* If either has a predicate that we know something about, set things up so
598 that D1 is the one that always has a known predicate. Then see if they
599 have any codes in common. */
601 if (d1
->pred
>= 0 || d2
->pred
>= 0)
606 p1
= d1
, d1
= d2
, d2
= p1
;
608 /* If D2 tests an explicit code, see if it is in the list of valid codes
609 for D1's predicate. */
610 if (d2
->code
!= UNKNOWN
)
612 for (i
= 0; i
< NUM_RTX_CODE
&& preds
[d1
->pred
].codes
[i
] != 0; i
++)
613 if (preds
[d1
->pred
].codes
[i
] == d2
->code
)
616 if (preds
[d1
->pred
].codes
[i
] == 0)
620 /* Otherwise see if the predicates have any codes in common. */
622 else if (d2
->pred
>= 0)
624 for (i
= 0; i
< NUM_RTX_CODE
&& preds
[d1
->pred
].codes
[i
] != 0; i
++)
626 for (j
= 0; j
< NUM_RTX_CODE
; j
++)
627 if (preds
[d2
->pred
].codes
[j
] == 0
628 || preds
[d2
->pred
].codes
[j
] == preds
[d1
->pred
].codes
[i
])
631 if (preds
[d2
->pred
].codes
[j
] != 0)
635 if (preds
[d1
->pred
].codes
[i
] == 0)
640 /* If we got here, we can't prove that D1 and D2 cannot both be true.
641 If we are only to check the top level, return 0. Otherwise, see if
642 we can prove that all choices in both successors are mutually
643 exclusive. If either does not have any successors, we can't prove
644 they can't both be true. */
646 if (toplevel
|| d1
->success
.first
== 0 || d2
->success
.first
== 0)
649 for (p1
= d1
->success
.first
; p1
; p1
= p1
->next
)
650 for (p2
= d2
->success
.first
; p2
; p2
= p2
->next
)
651 if (! not_both_true (p1
, p2
, 0))
657 /* Assuming that we can reorder all the alternatives at a specific point in
658 the tree (see discussion in merge_trees), we would prefer an ordering of
659 nodes where groups of consecutive nodes test the same mode and, within each
660 mode, groups of nodes test the same code. With this order, we can
661 construct nested switch statements, the inner one to test the code and
662 the outer one to test the mode.
664 We would like to list nodes testing for specific codes before those
665 that test predicates to avoid unnecessary function calls. Similarly,
666 tests for specific modes should precede nodes that allow any mode.
668 This function returns the merit (with 0 being the best) of inserting
669 a test involving the specified MODE and CODE after node P. If P is
670 zero, we are to determine the merit of inserting the test at the front
674 position_merit (p
, mode
, code
)
676 enum machine_mode mode
;
679 enum machine_mode p_mode
;
681 /* The only time the front of the list is anything other than the worst
682 position is if we are testing a mode that isn't VOIDmode. */
684 return mode
== VOIDmode
? 3 : 2;
686 p_mode
= p
->enforce_mode
? p
->mode
: VOIDmode
;
688 /* The best case is if the codes and modes both match. */
689 if (p_mode
== mode
&& p
->code
== code
)
692 /* If the codes don't match, the next best case is if the modes match.
693 In that case, the best position for this node depends on whether
694 we are testing for a specific code or not. If we are, the best place
695 is after some other test for an explicit code and our mode or after
696 the last test in the previous mode if every test in our mode is for
699 If we are testing for UNKNOWN, then the next best case is at the end of
703 && ((p_mode
== mode
&& p
->code
!= UNKNOWN
)
704 || (p_mode
!= mode
&& p
->next
705 && (p
->next
->enforce_mode
? p
->next
->mode
: VOIDmode
) == mode
706 && (p
->next
->code
== UNKNOWN
))))
707 || (code
== UNKNOWN
&& p_mode
== mode
709 || (p
->next
->enforce_mode
? p
->next
->mode
: VOIDmode
) != mode
)))
712 /* The third best case occurs when nothing is testing MODE. If MODE
713 is not VOIDmode, then the third best case is after something of any
714 mode that is not VOIDmode. If we are testing VOIDmode, the third best
715 place is the end of the list. */
718 && ((mode
!= VOIDmode
&& p_mode
!= VOIDmode
)
719 || (mode
== VOIDmode
&& p
->next
== 0)))
722 /* Otherwise, we have the worst case. */
726 /* Merge two decision tree listheads OLDH and ADDH,
727 modifying OLDH destructively, and return the merged tree. */
729 static struct decision_head
730 merge_trees (oldh
, addh
)
731 register struct decision_head oldh
, addh
;
733 struct decision
*add
, *next
;
741 /* If we are adding things at different positions, something is wrong. */
742 if (strcmp (oldh
.first
->position
, addh
.first
->position
))
745 for (add
= addh
.first
; add
; add
= next
)
747 enum machine_mode add_mode
= add
->enforce_mode
? add
->mode
: VOIDmode
;
748 struct decision
*best_position
= 0;
750 struct decision
*old
;
754 /* The semantics of pattern matching state that the tests are done in
755 the order given in the MD file so that if an insn matches two
756 patterns, the first one will be used. However, in practice, most,
757 if not all, patterns are unambiguous so that their order is
758 independent. In that case, we can merge identical tests and
759 group all similar modes and codes together.
761 Scan starting from the end of OLDH until we reach a point
762 where we reach the head of the list or where we pass a pattern
763 that could also be true if NEW is true. If we find an identical
764 pattern, we can merge them. Also, record the last node that tests
765 the same code and mode and the last one that tests just the same mode.
767 If we have no match, place NEW after the closest match we found. */
769 for (old
= oldh
.last
; old
; old
= old
->prev
)
773 /* If we don't have anything to test except an additional test,
774 do not consider the two nodes equal. If we did, the test below
775 would cause an infinite recursion. */
776 if (old
->tests
== 0 && old
->test_elt_zero_int
== 0
777 && old
->test_elt_one_int
== 0 && old
->veclen
== 0
778 && old
->test_elt_zero_wide
== 0
779 && old
->dupno
== -1 && old
->mode
== VOIDmode
780 && old
->code
== UNKNOWN
781 && (old
->c_test
!= 0 || add
->c_test
!= 0))
784 else if ((old
->tests
== add
->tests
785 || (old
->pred
>= 0 && old
->pred
== add
->pred
)
786 || (old
->tests
&& add
->tests
787 && !strcmp (old
->tests
, add
->tests
)))
788 && old
->test_elt_zero_int
== add
->test_elt_zero_int
789 && old
->elt_zero_int
== add
->elt_zero_int
790 && old
->test_elt_one_int
== add
->test_elt_one_int
791 && old
->elt_one_int
== add
->elt_one_int
792 && old
->test_elt_zero_wide
== add
->test_elt_zero_wide
793 && old
->elt_zero_wide
== add
->elt_zero_wide
794 && old
->veclen
== add
->veclen
795 && old
->dupno
== add
->dupno
796 && old
->opno
== add
->opno
797 && old
->code
== add
->code
798 && old
->enforce_mode
== add
->enforce_mode
799 && old
->mode
== add
->mode
)
801 /* If the additional test is not the same, split both nodes
802 into nodes that just contain all things tested before the
803 additional test and nodes that contain the additional test
804 and actions when it is true. This optimization is important
805 because of the case where we have almost identical patterns
806 with different tests on target flags. */
808 if (old
->c_test
!= add
->c_test
809 && ! (old
->c_test
&& add
->c_test
810 && !strcmp (old
->c_test
, add
->c_test
)))
812 if (old
->insn_code_number
>= 0 || old
->opno
>= 0)
814 struct decision
*split
815 = (struct decision
*) xmalloc (sizeof (struct decision
));
817 mybcopy ((char *) old
, (char *) split
,
818 sizeof (struct decision
));
820 old
->success
.first
= old
->success
.last
= split
;
823 old
->insn_code_number
= -1;
824 old
->num_clobbers_to_add
= 0;
826 split
->number
= next_number
++;
827 split
->next
= split
->prev
= 0;
828 split
->mode
= VOIDmode
;
829 split
->code
= UNKNOWN
;
831 split
->test_elt_zero_int
= 0;
832 split
->test_elt_one_int
= 0;
833 split
->test_elt_zero_wide
= 0;
839 if (add
->insn_code_number
>= 0 || add
->opno
>= 0)
841 struct decision
*split
842 = (struct decision
*) xmalloc (sizeof (struct decision
));
844 mybcopy ((char *) add
, (char *) split
,
845 sizeof (struct decision
));
847 add
->success
.first
= add
->success
.last
= split
;
850 add
->insn_code_number
= -1;
851 add
->num_clobbers_to_add
= 0;
853 split
->number
= next_number
++;
854 split
->next
= split
->prev
= 0;
855 split
->mode
= VOIDmode
;
856 split
->code
= UNKNOWN
;
858 split
->test_elt_zero_int
= 0;
859 split
->test_elt_one_int
= 0;
860 split
->test_elt_zero_wide
= 0;
867 if (old
->insn_code_number
>= 0 && add
->insn_code_number
>= 0)
869 /* If one node is for a normal insn and the second is
870 for the base insn with clobbers stripped off, the
871 second node should be ignored. */
873 if (old
->num_clobbers_to_add
== 0
874 && add
->num_clobbers_to_add
> 0)
875 /* Nothing to do here. */
877 else if (old
->num_clobbers_to_add
> 0
878 && add
->num_clobbers_to_add
== 0)
880 /* In this case, replace OLD with ADD. */
881 old
->insn_code_number
= add
->insn_code_number
;
882 old
->num_clobbers_to_add
= 0;
885 fatal ("Two actions at one point in tree");
888 if (old
->insn_code_number
== -1)
889 old
->insn_code_number
= add
->insn_code_number
;
890 old
->success
= merge_trees (old
->success
, add
->success
);
895 /* Unless we have already found the best possible insert point,
896 see if this position is better. If so, record it. */
899 && ((our_merit
= position_merit (old
, add_mode
, add
->code
))
901 best_merit
= our_merit
, best_position
= old
;
903 if (! not_both_true (old
, add
, 0))
907 /* If ADD was duplicate, we are done. */
911 /* Otherwise, find the best place to insert ADD. Normally this is
912 BEST_POSITION. However, if we went all the way to the top of
913 the list, it might be better to insert at the top. */
915 if (best_position
== 0)
919 && position_merit (NULL_PTR
, add_mode
, add
->code
) < best_merit
)
922 add
->next
= oldh
.first
;
923 oldh
.first
->prev
= add
;
929 add
->prev
= best_position
;
930 add
->next
= best_position
->next
;
931 best_position
->next
= add
;
932 if (best_position
== oldh
.last
)
935 add
->next
->prev
= add
;
942 /* Count the number of subnodes of HEAD. If the number is high enough,
943 make the first node in HEAD start a separate subroutine in the C code
946 TYPE gives the type of routine we are writing.
948 INITIAL is non-zero if this is the highest-level node. We never write
952 break_out_subroutines (head
, type
, initial
)
953 struct decision_head head
;
954 enum routine_type type
;
958 struct decision
*sub
;
960 for (sub
= head
.first
; sub
; sub
= sub
->next
)
961 size
+= 1 + break_out_subroutines (sub
->success
, type
, 0);
963 if (size
> SUBROUTINE_THRESHOLD
&& ! initial
)
965 head
.first
->subroutine_number
= ++next_subroutine_number
;
966 write_subroutine (head
.first
, type
);
972 /* Write out a subroutine of type TYPE to do comparisons starting at node
976 write_subroutine (tree
, type
)
977 struct decision
*tree
;
978 enum routine_type type
;
983 printf ("rtx\nsplit");
985 printf ("int\nrecog");
987 if (tree
!= 0 && tree
->subroutine_number
> 0)
988 printf ("_%d", tree
->subroutine_number
);
989 else if (type
== SPLIT
)
992 printf (" (x0, insn");
994 printf (", pnum_clobbers");
997 printf (" register rtx x0;\n rtx insn;\n");
999 printf (" int *pnum_clobbers;\n");
1002 printf (" register rtx *ro = &recog_operand[0];\n");
1004 printf (" register rtx ");
1005 for (i
= 1; i
< max_depth
; i
++)
1006 printf ("x%d, ", i
);
1008 printf ("x%d;\n", max_depth
);
1009 printf (" %s tem;\n", type
== SPLIT
? "rtx" : "int");
1010 write_tree (tree
, "", NULL_PTR
, 1, type
);
1011 printf (" ret0: return %d;\n}\n\n", type
== SPLIT
? 0 : -1);
1014 /* This table is used to indent the recog_* functions when we are inside
1015 conditions or switch statements. We only support small indentations
1016 and always indent at least two spaces. */
1018 static char *indents
[]
1019 = {" ", " ", " ", " ", " ", " ", " ", " ",
1020 "\t", "\t ", "\t ", "\t ", "\t ", "\t ", "\t ",
1021 "\t\t", "\t\t ", "\t\t ", "\t\t ", "\t\t ", "\t\t "};
1023 /* Write out C code to perform the decisions in TREE for a subroutine of
1024 type TYPE. If all of the choices fail, branch to node AFTERWARD, if
1025 non-zero, otherwise return. PREVPOS is the position of the node that
1026 branched to this test.
1028 When we merged all alternatives, we tried to set up a convenient order.
1029 Specifically, tests involving the same mode are all grouped together,
1030 followed by a group that does not contain a mode test. Within each group
1031 of the same mode, we also group tests with the same code, followed by a
1032 group that does not test a code.
1034 Occasionally, we cannot arbitrarily reorder the tests so that multiple
1035 sequence of groups as described above are present.
1037 We generate two nested switch statements, the outer statement for
1038 testing modes, and the inner switch for testing RTX codes. It is
1039 not worth optimizing cases when only a small number of modes or
1040 codes is tested, since the compiler can do that when compiling the
1041 resulting function. We do check for when every test is the same mode
1045 write_tree_1 (tree
, prevpos
, afterward
, type
)
1046 struct decision
*tree
;
1048 struct decision
*afterward
;
1049 enum routine_type type
;
1051 register struct decision
*p
, *p1
;
1052 register int depth
= tree
? strlen (tree
->position
) : 0;
1053 enum machine_mode switch_mode
= VOIDmode
;
1054 RTX_CODE switch_code
= UNKNOWN
;
1056 char modemap
[NUM_MACHINE_MODES
];
1057 char codemap
[NUM_RTX_CODE
];
1061 /* One tricky area is what is the exact state when we branch to a
1062 node's label. There are two cases where we branch: when looking at
1063 successors to a node, or when a set of tests fails.
1065 In the former case, we are always branching to the first node in a
1066 decision list and we want all required tests to be performed. We
1067 put the labels for such nodes in front of any switch or test statements.
1068 These branches are done without updating the position to that of the
1071 In the latter case, we are branching to a node that is not the first
1072 node in a decision list. We have already checked that it is possible
1073 for both the node we originally tested at this level and the node we
1074 are branching to to be both match some pattern. That means that they
1075 usually will be testing the same mode and code. So it is normally safe
1076 for such labels to be inside switch statements, since the tests done
1077 by virtue of arriving at that label will usually already have been
1078 done. The exception is a branch from a node that does not test a
1079 mode or code to one that does. In such cases, we set the `retest_mode'
1080 or `retest_code' flags. That will ensure that we start a new switch
1081 at that position and put the label before the switch.
1083 The branches in the latter case must set the position to that of the
1088 if (tree
&& tree
->subroutine_number
== 0)
1090 printf (" L%d:\n", tree
->number
);
1091 tree
->label_needed
= 0;
1096 change_state (prevpos
, tree
->position
, 2);
1097 prevpos
= tree
->position
;
1100 for (p
= tree
; p
; p
= p
->next
)
1102 enum machine_mode mode
= p
->enforce_mode
? p
->mode
: VOIDmode
;
1104 int wrote_bracket
= 0;
1107 if (p
->success
.first
== 0 && p
->insn_code_number
< 0)
1110 /* Find the next alternative to p that might be true when p is true.
1111 Test that one next if p's successors fail. */
1113 for (p1
= p
->next
; p1
&& not_both_true (p
, p1
, 1); p1
= p1
->next
)
1119 if (mode
== VOIDmode
&& p1
->enforce_mode
&& p1
->mode
!= VOIDmode
)
1120 p1
->retest_mode
= 1;
1121 if (p
->code
== UNKNOWN
&& p1
->code
!= UNKNOWN
)
1122 p1
->retest_code
= 1;
1123 p1
->label_needed
= 1;
1126 /* If we have a different code or mode than the last node and
1127 are in a switch on codes, we must either end the switch or
1128 go to another case. We must also end the switch if this
1129 node needs a label and to retest either the mode or code. */
1131 if (switch_code
!= UNKNOWN
1132 && (switch_code
!= p
->code
|| switch_mode
!= mode
1133 || (p
->label_needed
&& (p
->retest_mode
|| p
->retest_code
))))
1135 enum rtx_code code
= p
->code
;
1137 /* If P is testing a predicate that we know about and we haven't
1138 seen any of the codes that are valid for the predicate, we
1139 can write a series of "case" statement, one for each possible
1140 code. Since we are already in a switch, these redundant tests
1141 are very cheap and will reduce the number of predicate called. */
1145 for (i
= 0; i
< NUM_RTX_CODE
&& preds
[p
->pred
].codes
[i
] != 0; i
++)
1146 if (codemap
[(int) preds
[p
->pred
].codes
[i
]])
1149 if (preds
[p
->pred
].codes
[i
] == 0)
1150 code
= MATCH_OPERAND
;
1153 if (code
== UNKNOWN
|| codemap
[(int) code
]
1154 || switch_mode
!= mode
1155 || (p
->label_needed
&& (p
->retest_mode
|| p
->retest_code
)))
1157 printf ("%s}\n", indents
[indent
- 2]);
1158 switch_code
= UNKNOWN
;
1164 printf ("%sbreak;\n", indents
[indent
]);
1166 if (code
== MATCH_OPERAND
)
1168 for (i
= 0; i
< NUM_RTX_CODE
&& preds
[p
->pred
].codes
[i
] != 0; i
++)
1170 printf ("%scase ", indents
[indent
- 2]);
1171 print_code (preds
[p
->pred
].codes
[i
]);
1173 codemap
[(int) preds
[p
->pred
].codes
[i
]] = 1;
1178 printf ("%scase ", indents
[indent
- 2]);
1181 codemap
[(int) p
->code
] = 1;
1190 /* If we were previously in a switch on modes and now have a different
1191 mode, end at least the case, and maybe end the switch if we are
1192 not testing a mode or testing a mode whose case we already saw. */
1194 if (switch_mode
!= VOIDmode
1195 && (switch_mode
!= mode
|| (p
->label_needed
&& p
->retest_mode
)))
1197 if (mode
== VOIDmode
|| modemap
[(int) mode
]
1198 || (p
->label_needed
&& p
->retest_mode
))
1200 printf ("%s}\n", indents
[indent
- 2]);
1201 switch_mode
= VOIDmode
;
1207 printf (" break;\n");
1208 printf (" case %smode:\n", GET_MODE_NAME (mode
));
1210 modemap
[(int) mode
] = 1;
1216 /* If we are about to write dead code, something went wrong. */
1217 if (! p
->label_needed
&& uncond
)
1220 /* If we need a label and we will want to retest the mode or code at
1221 that label, write the label now. We have already ensured that
1222 things will be valid for the test. */
1224 if (p
->label_needed
&& (p
->retest_mode
|| p
->retest_code
))
1226 printf ("%sL%d:\n", indents
[indent
- 2], p
->number
);
1227 p
->label_needed
= 0;
1232 /* If we are not in any switches, see if we can shortcut things
1233 by checking for identical modes and codes. */
1235 if (switch_mode
== VOIDmode
&& switch_code
== UNKNOWN
)
1237 /* If p and its alternatives all want the same mode,
1238 reject all others at once, first, then ignore the mode. */
1240 if (mode
!= VOIDmode
&& p
->next
&& same_modes (p
, mode
))
1242 printf (" if (GET_MODE (x%d) != %smode)\n",
1243 depth
, GET_MODE_NAME (p
->mode
));
1247 change_state (p
->position
, afterward
->position
, 6);
1248 printf (" goto L%d;\n }\n", afterward
->number
);
1251 printf (" goto ret0;\n");
1256 /* If p and its alternatives all want the same code,
1257 reject all others at once, first, then ignore the code. */
1259 if (p
->code
!= UNKNOWN
&& p
->next
&& same_codes (p
, p
->code
))
1261 printf (" if (GET_CODE (x%d) != ", depth
);
1262 print_code (p
->code
);
1267 change_state (p
->position
, afterward
->position
, indent
+ 4);
1268 printf (" goto L%d;\n }\n", afterward
->number
);
1271 printf (" goto ret0;\n");
1276 /* If we are not in a mode switch and we are testing for a specific
1277 mode, start a mode switch unless we have just one node or the next
1278 node is not testing a mode (we have already tested for the case of
1279 more than one mode, but all of the same mode). */
1281 if (switch_mode
== VOIDmode
&& mode
!= VOIDmode
&& p
->next
!= 0
1282 && p
->next
->enforce_mode
&& p
->next
->mode
!= VOIDmode
)
1284 mybzero (modemap
, sizeof modemap
);
1285 printf ("%sswitch (GET_MODE (x%d))\n", indents
[indent
], depth
);
1286 printf ("%s{\n", indents
[indent
+ 2]);
1288 printf ("%scase %smode:\n", indents
[indent
- 2],
1289 GET_MODE_NAME (mode
));
1290 modemap
[(int) mode
] = 1;
1294 /* Similarly for testing codes. */
1296 if (switch_code
== UNKNOWN
&& p
->code
!= UNKNOWN
&& ! p
->ignore_code
1297 && p
->next
!= 0 && p
->next
->code
!= UNKNOWN
)
1299 mybzero (codemap
, sizeof codemap
);
1300 printf ("%sswitch (GET_CODE (x%d))\n", indents
[indent
], depth
);
1301 printf ("%s{\n", indents
[indent
+ 2]);
1303 printf ("%scase ", indents
[indent
- 2]);
1304 print_code (p
->code
);
1306 codemap
[(int) p
->code
] = 1;
1307 switch_code
= p
->code
;
1310 /* Now that most mode and code tests have been done, we can write out
1311 a label for an inner node, if we haven't already. */
1312 if (p
->label_needed
)
1313 printf ("%sL%d:\n", indents
[indent
- 2], p
->number
);
1315 inner_indent
= indent
;
1317 /* The only way we can have to do a mode or code test here is if
1318 this node needs such a test but is the only node to be tested.
1319 In that case, we won't have started a switch. Note that this is
1320 the only way the switch and test modes can disagree. */
1322 if ((mode
!= switch_mode
&& ! p
->ignore_mode
)
1323 || (p
->code
!= switch_code
&& p
->code
!= UNKNOWN
&& ! p
->ignore_code
)
1324 || p
->test_elt_zero_int
|| p
->test_elt_one_int
1325 || p
->test_elt_zero_wide
|| p
->veclen
1326 || p
->dupno
>= 0 || p
->tests
|| p
->num_clobbers_to_add
)
1328 printf ("%sif (", indents
[indent
]);
1330 if (mode
!= switch_mode
&& ! p
->ignore_mode
)
1331 printf ("GET_MODE (x%d) == %smode && ",
1332 depth
, GET_MODE_NAME (mode
));
1333 if (p
->code
!= switch_code
&& p
->code
!= UNKNOWN
&& ! p
->ignore_code
)
1335 printf ("GET_CODE (x%d) == ", depth
);
1336 print_code (p
->code
);
1340 if (p
->test_elt_zero_int
)
1341 printf ("XINT (x%d, 0) == %d && ", depth
, p
->elt_zero_int
);
1342 if (p
->test_elt_one_int
)
1343 printf ("XINT (x%d, 1) == %d && ", depth
, p
->elt_one_int
);
1344 if (p
->test_elt_zero_wide
)
1346 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
1347 "XWINT (x%d, 0) == %d && ",
1349 "XWINT (x%d, 0) == %ld && ",
1351 depth
, p
->elt_zero_wide
);
1353 printf ("XVECLEN (x%d, 0) == %d && ", depth
, p
->veclen
);
1355 printf ("rtx_equal_p (x%d, ro[%d]) && ", depth
, p
->dupno
);
1356 if (p
->num_clobbers_to_add
)
1357 printf ("pnum_clobbers != 0 && ");
1359 printf ("%s (x%d, %smode)", p
->tests
, depth
,
1360 GET_MODE_NAME (p
->mode
));
1370 need_bracket
= ! uncond
;
1376 printf ("%s{\n", indents
[inner_indent
]);
1382 printf ("%sro[%d] = x%d;\n", indents
[inner_indent
], p
->opno
, depth
);
1387 printf ("%sif (%s)\n", indents
[inner_indent
], p
->c_test
);
1393 if (p
->insn_code_number
>= 0)
1396 printf ("%sreturn gen_split_%d (operands);\n",
1397 indents
[inner_indent
], p
->insn_code_number
);
1400 if (p
->num_clobbers_to_add
)
1404 printf ("%s{\n", indents
[inner_indent
]);
1408 printf ("%s*pnum_clobbers = %d;\n",
1409 indents
[inner_indent
], p
->num_clobbers_to_add
);
1410 printf ("%sreturn %d;\n",
1411 indents
[inner_indent
], p
->insn_code_number
);
1416 printf ("%s}\n", indents
[inner_indent
]);
1420 printf ("%sreturn %d;\n",
1421 indents
[inner_indent
], p
->insn_code_number
);
1425 printf ("%sgoto L%d;\n", indents
[inner_indent
],
1426 p
->success
.first
->number
);
1429 printf ("%s}\n", indents
[inner_indent
- 2]);
1432 /* We have now tested all alternatives. End any switches we have open
1433 and branch to the alternative node unless we know that we can't fall
1434 through to the branch. */
1436 if (switch_code
!= UNKNOWN
)
1438 printf ("%s}\n", indents
[indent
- 2]);
1443 if (switch_mode
!= VOIDmode
)
1445 printf ("%s}\n", indents
[indent
- 2]);
1458 change_state (prevpos
, afterward
->position
, 2);
1459 printf (" goto L%d;\n", afterward
->number
);
1462 printf (" goto ret0;\n");
1470 for (p1
= GET_RTX_NAME (code
); *p1
; p1
++)
1472 if (*p1
>= 'a' && *p1
<= 'z')
1473 putchar (*p1
+ 'A' - 'a');
1480 same_codes (p
, code
)
1481 register struct decision
*p
;
1482 register enum rtx_code code
;
1484 for (; p
; p
= p
->next
)
1485 if (p
->code
!= code
)
1493 register struct decision
*p
;
1495 for (; p
; p
= p
->next
)
1500 same_modes (p
, mode
)
1501 register struct decision
*p
;
1502 register enum machine_mode mode
;
1504 for (; p
; p
= p
->next
)
1505 if ((p
->enforce_mode
? p
->mode
: VOIDmode
) != mode
)
1513 register struct decision
*p
;
1515 for (; p
; p
= p
->next
)
1516 p
->enforce_mode
= 0;
1519 /* Write out the decision tree starting at TREE for a subroutine of type TYPE.
1521 PREVPOS is the position at the node that branched to this node.
1523 INITIAL is nonzero if this is the first node we are writing in a subroutine.
1525 If all nodes are false, branch to the node AFTERWARD. */
1528 write_tree (tree
, prevpos
, afterward
, initial
, type
)
1529 struct decision
*tree
;
1531 struct decision
*afterward
;
1533 enum routine_type type
;
1535 register struct decision
*p
;
1536 char *name_prefix
= (type
== SPLIT
? "split" : "recog");
1537 char *call_suffix
= (type
== SPLIT
? "" : ", pnum_clobbers");
1539 if (! initial
&& tree
->subroutine_number
> 0)
1541 printf (" L%d:\n", tree
->number
);
1545 printf (" tem = %s_%d (x0, insn%s);\n",
1546 name_prefix
, tree
->subroutine_number
, call_suffix
);
1548 printf (" if (tem != 0) return tem;\n");
1550 printf (" if (tem >= 0) return tem;\n");
1551 change_state (tree
->position
, afterward
->position
, 2);
1552 printf (" goto L%d;\n", afterward
->number
);
1555 printf (" return %s_%d (x0, insn%s);\n",
1556 name_prefix
, tree
->subroutine_number
, call_suffix
);
1560 write_tree_1 (tree
, prevpos
, afterward
, type
);
1562 for (p
= tree
; p
; p
= p
->next
)
1563 if (p
->success
.first
)
1564 write_tree (p
->success
.first
, p
->position
,
1565 p
->afterward
? p
->afterward
: afterward
, 0, type
);
1569 /* Assuming that the state of argument is denoted by OLDPOS, take whatever
1570 actions are necessary to move to NEWPOS.
1572 INDENT says how many blanks to place at the front of lines. */
1575 change_state (oldpos
, newpos
, indent
)
1580 int odepth
= strlen (oldpos
);
1582 int ndepth
= strlen (newpos
);
1584 /* Pop up as many levels as necessary. */
1586 while (strncmp (oldpos
, newpos
, depth
))
1589 /* Go down to desired level. */
1591 while (depth
< ndepth
)
1593 if (newpos
[depth
] >= 'a' && newpos
[depth
] <= 'z')
1594 printf ("%sx%d = XVECEXP (x%d, 0, %d);\n",
1595 indents
[indent
], depth
+ 1, depth
, newpos
[depth
] - 'a');
1597 printf ("%sx%d = XEXP (x%d, %c);\n",
1598 indents
[indent
], depth
+ 1, depth
, newpos
[depth
]);
1612 tem
= (char *) xmalloc (strlen (s1
) + 1);
1621 register unsigned length
;
1623 while (length
-- > 0)
1628 mybcopy (in
, out
, length
)
1629 register char *in
, *out
;
1630 register unsigned length
;
1632 while (length
-- > 0)
1647 tem
= (char *) xmalloc (strlen (s1
) + strlen (s2
) + 2);
1656 xrealloc (ptr
, size
)
1660 char *result
= (char *) realloc (ptr
, size
);
1662 fatal ("virtual memory exhausted");
1670 register char *val
= (char *) malloc (size
);
1673 fatal ("virtual memory exhausted");
1681 fprintf (stderr
, "genrecog: ");
1682 fprintf (stderr
, s
);
1683 fprintf (stderr
, "\n");
1684 fprintf (stderr
, "after %d definitions\n", next_index
);
1685 exit (FATAL_EXIT_CODE
);
1688 /* More 'friendly' abort that prints the line and file.
1689 config.h can #define abort fancy_abort if you like that sort of thing. */
1694 fatal ("Internal gcc abort.");
1703 struct decision_head recog_tree
;
1704 struct decision_head split_tree
;
1708 obstack_init (rtl_obstack
);
1709 recog_tree
.first
= recog_tree
.last
= split_tree
.first
= split_tree
.last
= 0;
1712 fatal ("No input file name.");
1714 infile
= fopen (argv
[1], "r");
1718 exit (FATAL_EXIT_CODE
);
1725 printf ("/* Generated automatically by the program `genrecog'\n\
1726 from the machine description file `md'. */\n\n");
1728 printf ("#include \"config.h\"\n");
1729 printf ("#include \"rtl.h\"\n");
1730 printf ("#include \"insn-config.h\"\n");
1731 printf ("#include \"recog.h\"\n");
1732 printf ("#include \"real.h\"\n");
1733 printf ("#include \"output.h\"\n");
1734 printf ("#include \"flags.h\"\n");
1737 /* Read the machine description. */
1741 c
= read_skip_spaces (infile
);
1746 desc
= read_rtx (infile
);
1747 if (GET_CODE (desc
) == DEFINE_INSN
)
1748 recog_tree
= merge_trees (recog_tree
,
1749 make_insn_sequence (desc
, RECOG
));
1750 else if (GET_CODE (desc
) == DEFINE_SPLIT
)
1751 split_tree
= merge_trees (split_tree
,
1752 make_insn_sequence (desc
, SPLIT
));
1753 if (GET_CODE (desc
) == DEFINE_PEEPHOLE
1754 || GET_CODE (desc
) == DEFINE_EXPAND
)
1760 /* `recog' contains a decision tree\n\
1761 that recognizes whether the rtx X0 is a valid instruction.\n\
1763 recog returns -1 if the rtx is not valid.\n\
1764 If the rtx is valid, recog returns a nonnegative number\n\
1765 which is the insn code number for the pattern that matched.\n");
1766 printf (" This is the same as the order in the machine description of\n\
1767 the entry that matched. This number can be used as an index into\n\
1768 entry that matched. This number can be used as an index into various\n\
1769 insn_* tables, such as insn_templates, insn_outfun, and insn_n_operands\n\
1770 (found in insn-output.c).\n\n");
1771 printf (" The third argument to recog is an optional pointer to an int.\n\
1772 If present, recog will accept a pattern if it matches except for\n\
1773 missing CLOBBER expressions at the end. In that case, the value\n\
1774 pointed to by the optional pointer will be set to the number of\n\
1775 CLOBBERs that need to be added (it should be initialized to zero by\n\
1776 the caller). If it is set nonzero, the caller should allocate a\n\
1777 PARALLEL of the appropriate size, copy the initial entries, and call\n\
1778 add_clobbers (found in insn-emit.c) to fill in the CLOBBERs.");
1780 if (split_tree
.first
)
1781 printf ("\n\n The function split_insns returns 0 if the rtl could not\n\
1782 be split or the split rtl in a SEQUENCE if it can be.");
1786 printf ("rtx recog_operand[MAX_RECOG_OPERANDS];\n\n");
1787 printf ("rtx *recog_operand_loc[MAX_RECOG_OPERANDS];\n\n");
1788 printf ("rtx *recog_dup_loc[MAX_DUP_OPERANDS];\n\n");
1789 printf ("char recog_dup_num[MAX_DUP_OPERANDS];\n\n");
1790 printf ("#define operands recog_operand\n\n");
1792 next_subroutine_number
= 0;
1793 break_out_subroutines (recog_tree
, RECOG
, 1);
1794 write_subroutine (recog_tree
.first
, RECOG
);
1796 next_subroutine_number
= 0;
1797 break_out_subroutines (split_tree
, SPLIT
, 1);
1798 write_subroutine (split_tree
.first
, SPLIT
);
1801 exit (ferror (stdout
) != 0 ? FATAL_EXIT_CODE
: SUCCESS_EXIT_CODE
);