1 /* Generate code from machine description to recognize rtl as insns.
2 Copyright (C) 1987, 88, 92, 93, 94, 95, 97, 98 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
22 /* This program is used to produce insn-recog.c, which contains
23 a function called `recog' plus its subroutines.
24 These functions contain a decision tree
25 that recognizes whether an rtx, the argument given to recog,
26 is a valid instruction.
28 recog returns -1 if the rtx is not valid.
29 If the rtx is valid, recog returns a nonnegative number
30 which is the insn code number for the pattern that matched.
31 This is the same as the order in the machine description of the
32 entry that matched. This number can be used as an index into various
33 insn_* tables, such as insn_template, insn_outfun, and insn_n_operands
34 (found in insn-output.c).
36 The third argument to recog is an optional pointer to an int.
37 If present, recog will accept a pattern if it matches except for
38 missing CLOBBER expressions at the end. In that case, the value
39 pointed to by the optional pointer will be set to the number of
40 CLOBBERs that need to be added (it should be initialized to zero by
41 the caller). If it is set nonzero, the caller should allocate a
42 PARALLEL of the appropriate size, copy the initial entries, and call
43 add_clobbers (found in insn-emit.c) to fill in the CLOBBERs.
45 This program also generates the function `split_insns',
46 which returns 0 if the rtl could not be split, or
47 it returns the split rtl in a SEQUENCE. */
54 #define OUTPUT_LABEL(INDENT_STRING, LABEL_NUMBER) \
55 printf("%sL%d: ATTRIBUTE_UNUSED_LABEL\n", (INDENT_STRING), (LABEL_NUMBER))
57 static struct obstack obstack
;
58 struct obstack
*rtl_obstack
= &obstack
;
60 #define obstack_chunk_alloc xmalloc
61 #define obstack_chunk_free free
63 /* Define this so we can link with print-rtl.o to get debug_rtx function. */
64 char **insn_name_ptr
= 0;
66 /* Data structure for a listhead of decision trees. The alternatives
67 to a node are kept in a doublely-linked list so we can easily add nodes
68 to the proper place when merging. */
70 struct decision_head
{ struct decision
*first
, *last
; };
72 /* Data structure for decision tree for recognizing
73 legitimate instructions. */
77 int number
; /* Node number, used for labels */
78 char *position
; /* String denoting position in pattern */
79 RTX_CODE code
; /* Code to test for or UNKNOWN to suppress */
80 char ignore_code
; /* If non-zero, need not test code */
81 char ignore_mode
; /* If non-zero, need not test mode */
82 int veclen
; /* Length of vector, if nonzero */
83 enum machine_mode mode
; /* Machine mode of node */
84 char enforce_mode
; /* If non-zero, test `mode' */
85 char retest_code
, retest_mode
; /* See write_tree_1 */
86 int test_elt_zero_int
; /* Nonzero if should test XINT (rtl, 0) */
87 int elt_zero_int
; /* Required value for XINT (rtl, 0) */
88 int test_elt_one_int
; /* Nonzero if should test XINT (rtl, 1) */
89 int elt_one_int
; /* Required value for XINT (rtl, 1) */
90 int test_elt_zero_wide
; /* Nonzero if should test XWINT (rtl, 0) */
91 HOST_WIDE_INT elt_zero_wide
; /* Required value for XWINT (rtl, 0) */
92 const char *tests
; /* If nonzero predicate to call */
93 int pred
; /* `preds' index of predicate or -1 */
94 char *c_test
; /* Additional test to perform */
95 struct decision_head success
; /* Nodes to test on success */
96 int insn_code_number
; /* Insn number matched, if success */
97 int num_clobbers_to_add
; /* Number of CLOBBERs to be added to pattern */
98 struct decision
*next
; /* Node to test on failure */
99 struct decision
*prev
; /* Node whose failure tests us */
100 struct decision
*afterward
; /* Node to test on success, but failure of
102 int opno
; /* Operand number, if >= 0 */
103 int dupno
; /* Number of operand to compare against */
104 int label_needed
; /* Nonzero if label needed when writing tree */
105 int subroutine_number
; /* Number of subroutine this node starts */
108 #define SUBROUTINE_THRESHOLD 50
110 static int next_subroutine_number
;
112 /* We can write two types of subroutines: One for insn recognition and
113 one to split insns. This defines which type is being written. */
115 enum routine_type
{RECOG
, SPLIT
};
117 /* Next available node number for tree nodes. */
119 static int next_number
;
121 /* Next number to use as an insn_code. */
123 static int next_insn_code
;
125 /* Similar, but counts all expressions in the MD file; used for
128 static int next_index
;
130 /* Record the highest depth we ever have so we know how many variables to
131 allocate in each subroutine we make. */
133 static int max_depth
;
135 /* This table contains a list of the rtl codes that can possibly match a
136 predicate defined in recog.c. The function `not_both_true' uses it to
137 deduce that there are no expressions that can be matches by certain pairs
138 of tree nodes. Also, if a predicate can match only one code, we can
139 hardwire that code into the node testing the predicate. */
141 static struct pred_table
144 RTX_CODE codes
[NUM_RTX_CODE
];
146 = {{"general_operand", {CONST_INT
, CONST_DOUBLE
, CONST
, SYMBOL_REF
,
147 LABEL_REF
, SUBREG
, REG
, MEM
}},
148 #ifdef PREDICATE_CODES
151 {"address_operand", {CONST_INT
, CONST_DOUBLE
, CONST
, SYMBOL_REF
,
152 LABEL_REF
, SUBREG
, REG
, MEM
, PLUS
, MINUS
, MULT
}},
153 {"register_operand", {SUBREG
, REG
}},
154 {"scratch_operand", {SCRATCH
, REG
}},
155 {"immediate_operand", {CONST_INT
, CONST_DOUBLE
, CONST
, SYMBOL_REF
,
157 {"const_int_operand", {CONST_INT
}},
158 {"const_double_operand", {CONST_INT
, CONST_DOUBLE
}},
159 {"nonimmediate_operand", {SUBREG
, REG
, MEM
}},
160 {"nonmemory_operand", {CONST_INT
, CONST_DOUBLE
, CONST
, SYMBOL_REF
,
161 LABEL_REF
, SUBREG
, REG
}},
162 {"push_operand", {MEM
}},
163 {"memory_operand", {SUBREG
, MEM
}},
164 {"indirect_operand", {SUBREG
, MEM
}},
165 {"comparison_operator", {EQ
, NE
, LE
, LT
, GE
, GT
, LEU
, LTU
, GEU
, GTU
}},
166 {"mode_independent_operand", {CONST_INT
, CONST_DOUBLE
, CONST
, SYMBOL_REF
,
167 LABEL_REF
, SUBREG
, REG
, MEM
}}};
169 #define NUM_KNOWN_PREDS (sizeof preds / sizeof preds[0])
171 static struct decision_head make_insn_sequence
PROTO((rtx
, enum routine_type
));
172 static struct decision
*add_to_sequence
PROTO((rtx
, struct decision_head
*,
174 static int not_both_true
PROTO((struct decision
*, struct decision
*,
176 static int position_merit
PROTO((struct decision
*, enum machine_mode
,
178 static struct decision_head merge_trees
PROTO((struct decision_head
,
179 struct decision_head
));
180 static int break_out_subroutines
PROTO((struct decision_head
,
181 enum routine_type
, int));
182 static void write_subroutine
PROTO((struct decision
*, enum routine_type
));
183 static void write_tree_1
PROTO((struct decision
*, const char *,
184 struct decision
*, enum routine_type
));
185 static void print_code
PROTO((enum rtx_code
));
186 static int same_codes
PROTO((struct decision
*, enum rtx_code
));
187 static void clear_codes
PROTO((struct decision
*));
188 static int same_modes
PROTO((struct decision
*, enum machine_mode
));
189 static void clear_modes
PROTO((struct decision
*));
190 static void write_tree
PROTO((struct decision
*, const char *,
191 struct decision
*, int,
193 static void change_state
PROTO((const char *, const char *, int));
194 static char *copystr
PROTO((const char *));
195 static void mybzero
PROTO((char *, unsigned));
196 static void mybcopy
PROTO((char *, char *, unsigned));
197 static void fatal
PVPROTO((const char *, ...))
198 ATTRIBUTE_PRINTF_1 ATTRIBUTE_NORETURN
;
199 void fancy_abort
PROTO((void)) ATTRIBUTE_NORETURN
;
201 /* Construct and return a sequence of decisions
202 that will recognize INSN.
204 TYPE says what type of routine we are recognizing (RECOG or SPLIT). */
206 static struct decision_head
207 make_insn_sequence (insn
, type
)
209 enum routine_type type
;
212 char *c_test
= XSTR (insn
, type
== RECOG
? 2 : 1);
213 struct decision
*last
;
214 struct decision_head head
;
216 if (XVECLEN (insn
, type
== RECOG
) == 1)
217 x
= XVECEXP (insn
, type
== RECOG
, 0);
220 x
= rtx_alloc (PARALLEL
);
221 XVEC (x
, 0) = XVEC (insn
, type
== RECOG
);
222 PUT_MODE (x
, VOIDmode
);
225 last
= add_to_sequence (x
, &head
, "");
228 last
->c_test
= c_test
;
229 last
->insn_code_number
= next_insn_code
;
230 last
->num_clobbers_to_add
= 0;
232 /* If this is not a DEFINE_SPLIT and X is a PARALLEL, see if it ends with a
233 group of CLOBBERs of (hard) registers or MATCH_SCRATCHes. If so, set up
234 to recognize the pattern without these CLOBBERs. */
236 if (type
== RECOG
&& GET_CODE (x
) == PARALLEL
)
240 for (i
= XVECLEN (x
, 0); i
> 0; i
--)
241 if (GET_CODE (XVECEXP (x
, 0, i
- 1)) != CLOBBER
242 || (GET_CODE (XEXP (XVECEXP (x
, 0, i
- 1), 0)) != REG
243 && GET_CODE (XEXP (XVECEXP (x
, 0, i
- 1), 0)) != MATCH_SCRATCH
))
246 if (i
!= XVECLEN (x
, 0))
249 struct decision_head clobber_head
;
252 new = XVECEXP (x
, 0, 0);
257 new = rtx_alloc (PARALLEL
);
258 XVEC (new, 0) = rtvec_alloc (i
);
259 for (j
= i
- 1; j
>= 0; j
--)
260 XVECEXP (new, 0, j
) = XVECEXP (x
, 0, j
);
263 last
= add_to_sequence (new, &clobber_head
, "");
266 last
->c_test
= c_test
;
267 last
->insn_code_number
= next_insn_code
;
268 last
->num_clobbers_to_add
= XVECLEN (x
, 0) - i
;
270 head
= merge_trees (head
, clobber_head
);
277 /* Define the subroutine we will call below and emit in genemit. */
278 printf ("extern rtx gen_split_%d ();\n", last
->insn_code_number
);
283 /* Create a chain of nodes to verify that an rtl expression matches
286 LAST is a pointer to the listhead in the previous node in the chain (or
287 in the calling function, for the first node).
289 POSITION is the string representing the current position in the insn.
291 A pointer to the final node in the chain is returned. */
293 static struct decision
*
294 add_to_sequence (pattern
, last
, position
)
296 struct decision_head
*last
;
297 const char *position
;
299 register RTX_CODE code
;
300 register struct decision
*new
301 = (struct decision
*) xmalloc (sizeof (struct decision
));
302 struct decision
*this;
306 int depth
= strlen (position
);
309 if (depth
> max_depth
)
312 new->number
= next_number
++;
313 new->position
= copystr (position
);
314 new->ignore_code
= 0;
315 new->ignore_mode
= 0;
316 new->enforce_mode
= 1;
317 new->retest_code
= new->retest_mode
= 0;
319 new->test_elt_zero_int
= 0;
320 new->test_elt_one_int
= 0;
321 new->test_elt_zero_wide
= 0;
322 new->elt_zero_int
= 0;
323 new->elt_one_int
= 0;
324 new->elt_zero_wide
= 0;
328 new->success
.first
= new->success
.last
= 0;
329 new->insn_code_number
= -1;
330 new->num_clobbers_to_add
= 0;
336 new->label_needed
= 0;
337 new->subroutine_number
= 0;
341 last
->first
= last
->last
= new;
343 newpos
= (char *) alloca (depth
+ 2);
344 strcpy (newpos
, position
);
345 newpos
[depth
+ 1] = 0;
349 new->mode
= GET_MODE (pattern
);
350 new->code
= code
= GET_CODE (pattern
);
359 new->opno
= XINT (pattern
, 0);
360 new->code
= (code
== MATCH_PARALLEL
? PARALLEL
: UNKNOWN
);
361 new->enforce_mode
= 0;
363 if (code
== MATCH_SCRATCH
)
364 new->tests
= "scratch_operand";
366 new->tests
= XSTR (pattern
, 1);
368 if (*new->tests
== 0)
371 /* See if we know about this predicate and save its number. If we do,
372 and it only accepts one code, note that fact. The predicate
373 `const_int_operand' only tests for a CONST_INT, so if we do so we
374 can avoid calling it at all.
376 Finally, if we know that the predicate does not allow CONST_INT, we
377 know that the only way the predicate can match is if the modes match
378 (here we use the kludge of relying on the fact that "address_operand"
379 accepts CONST_INT; otherwise, it would have to be a special case),
380 so we can test the mode (but we need not). This fact should
381 considerably simplify the generated code. */
385 for (i
= 0; i
< NUM_KNOWN_PREDS
; i
++)
386 if (! strcmp (preds
[i
].name
, new->tests
))
389 int allows_const_int
= 0;
393 if (preds
[i
].codes
[1] == 0 && new->code
== UNKNOWN
)
395 new->code
= preds
[i
].codes
[0];
396 if (! strcmp ("const_int_operand", new->tests
))
397 new->tests
= 0, new->pred
= -1;
400 for (j
= 0; j
< NUM_RTX_CODE
&& preds
[i
].codes
[j
] != 0; j
++)
401 if (preds
[i
].codes
[j
] == CONST_INT
)
402 allows_const_int
= 1;
404 if (! allows_const_int
)
405 new->enforce_mode
= new->ignore_mode
= 1;
410 #ifdef PREDICATE_CODES
411 /* If the port has a list of the predicates it uses but omits
413 if (i
== NUM_KNOWN_PREDS
)
414 fprintf (stderr
, "Warning: `%s' not in PREDICATE_CODES\n",
419 if (code
== MATCH_OPERATOR
|| code
== MATCH_PARALLEL
)
421 for (i
= 0; i
< (size_t) XVECLEN (pattern
, 2); i
++)
423 newpos
[depth
] = i
+ (code
== MATCH_OPERATOR
? '0': 'a');
424 new = add_to_sequence (XVECEXP (pattern
, 2, i
),
425 &new->success
, newpos
);
432 new->opno
= XINT (pattern
, 0);
433 new->dupno
= XINT (pattern
, 0);
436 for (i
= 0; i
< (size_t) XVECLEN (pattern
, 1); i
++)
438 newpos
[depth
] = i
+ '0';
439 new = add_to_sequence (XVECEXP (pattern
, 1, i
),
440 &new->success
, newpos
);
446 new->dupno
= XINT (pattern
, 0);
448 new->enforce_mode
= 0;
452 pattern
= XEXP (pattern
, 0);
456 /* The operands of a SET must have the same mode unless one is VOIDmode. */
457 if (GET_MODE (SET_SRC (pattern
)) != VOIDmode
458 && GET_MODE (SET_DEST (pattern
)) != VOIDmode
459 && GET_MODE (SET_SRC (pattern
)) != GET_MODE (SET_DEST (pattern
))
460 /* The mode of an ADDRESS_OPERAND is the mode of the memory reference,
461 not the mode of the address. */
462 && ! (GET_CODE (SET_SRC (pattern
)) == MATCH_OPERAND
463 && ! strcmp (XSTR (SET_SRC (pattern
), 1), "address_operand")))
465 print_rtl (stderr
, pattern
);
466 fputc ('\n', stderr
);
467 fatal ("mode mismatch in SET");
470 new = add_to_sequence (SET_DEST (pattern
), &new->success
, newpos
);
471 this->success
.first
->enforce_mode
= 1;
473 new = add_to_sequence (SET_SRC (pattern
), &new->success
, newpos
);
475 /* If set are setting CC0 from anything other than a COMPARE, we
476 must enforce the mode so that we do not produce ambiguous insns. */
477 if (GET_CODE (SET_DEST (pattern
)) == CC0
478 && GET_CODE (SET_SRC (pattern
)) != COMPARE
)
479 this->success
.first
->enforce_mode
= 1;
484 case STRICT_LOW_PART
:
486 new = add_to_sequence (XEXP (pattern
, 0), &new->success
, newpos
);
487 this->success
.first
->enforce_mode
= 1;
491 this->test_elt_one_int
= 1;
492 this->elt_one_int
= XINT (pattern
, 1);
494 new = add_to_sequence (XEXP (pattern
, 0), &new->success
, newpos
);
495 this->success
.first
->enforce_mode
= 1;
501 new = add_to_sequence (XEXP (pattern
, 0), &new->success
, newpos
);
502 this->success
.first
->enforce_mode
= 1;
504 new = add_to_sequence (XEXP (pattern
, 1), &new->success
, newpos
);
506 new = add_to_sequence (XEXP (pattern
, 2), &new->success
, newpos
);
509 case EQ
: case NE
: case LE
: case LT
: case GE
: case GT
:
510 case LEU
: case LTU
: case GEU
: case GTU
:
511 /* If the first operand is (cc0), we don't have to do anything
513 if (GET_CODE (XEXP (pattern
, 0)) == CC0
)
516 /* ... fall through ... */
519 /* Enforce the mode on the first operand to avoid ambiguous insns. */
521 new = add_to_sequence (XEXP (pattern
, 0), &new->success
, newpos
);
522 this->success
.first
->enforce_mode
= 1;
524 new = add_to_sequence (XEXP (pattern
, 1), &new->success
, newpos
);
531 fmt
= GET_RTX_FORMAT (code
);
532 len
= GET_RTX_LENGTH (code
);
533 for (i
= 0; i
< (size_t) len
; i
++)
535 newpos
[depth
] = '0' + i
;
536 if (fmt
[i
] == 'e' || fmt
[i
] == 'u')
537 new = add_to_sequence (XEXP (pattern
, i
), &new->success
, newpos
);
538 else if (fmt
[i
] == 'i' && i
== 0)
540 this->test_elt_zero_int
= 1;
541 this->elt_zero_int
= XINT (pattern
, i
);
543 else if (fmt
[i
] == 'i' && i
== 1)
545 this->test_elt_one_int
= 1;
546 this->elt_one_int
= XINT (pattern
, i
);
548 else if (fmt
[i
] == 'w' && i
== 0)
550 this->test_elt_zero_wide
= 1;
551 this->elt_zero_wide
= XWINT (pattern
, i
);
553 else if (fmt
[i
] == 'E')
556 /* We do not handle a vector appearing as other than
557 the first item, just because nothing uses them
558 and by handling only the special case
559 we can use one element in newpos for either
560 the item number of a subexpression
561 or the element number in a vector. */
564 this->veclen
= XVECLEN (pattern
, i
);
565 for (j
= 0; j
< XVECLEN (pattern
, i
); j
++)
567 newpos
[depth
] = 'a' + j
;
568 new = add_to_sequence (XVECEXP (pattern
, i
, j
),
569 &new->success
, newpos
);
572 else if (fmt
[i
] != '0')
578 /* Return 1 if we can prove that there is no RTL that can match both
579 D1 and D2. Otherwise, return 0 (it may be that there is an RTL that
580 can match both or just that we couldn't prove there wasn't such an RTL).
582 TOPLEVEL is non-zero if we are to only look at the top level and not
583 recursively descend. */
586 not_both_true (d1
, d2
, toplevel
)
587 struct decision
*d1
, *d2
;
590 struct decision
*p1
, *p2
;
592 /* If they are both to test modes and the modes are different, they aren't
593 both true. Similarly for codes, integer elements, and vector lengths. */
595 if ((d1
->enforce_mode
&& d2
->enforce_mode
596 && d1
->mode
!= VOIDmode
&& d2
->mode
!= VOIDmode
&& d1
->mode
!= d2
->mode
)
597 || (d1
->code
!= UNKNOWN
&& d2
->code
!= UNKNOWN
&& d1
->code
!= d2
->code
)
598 || (d1
->test_elt_zero_int
&& d2
->test_elt_zero_int
599 && d1
->elt_zero_int
!= d2
->elt_zero_int
)
600 || (d1
->test_elt_one_int
&& d2
->test_elt_one_int
601 && d1
->elt_one_int
!= d2
->elt_one_int
)
602 || (d1
->test_elt_zero_wide
&& d2
->test_elt_zero_wide
603 && d1
->elt_zero_wide
!= d2
->elt_zero_wide
)
604 || (d1
->veclen
&& d2
->veclen
&& d1
->veclen
!= d2
->veclen
))
607 /* If either is a wild-card MATCH_OPERAND without a predicate, it can match
608 absolutely anything, so we can't say that no intersection is possible.
609 This case is detected by having a zero TESTS field with a code of
612 if ((d1
->tests
== 0 && d1
->code
== UNKNOWN
)
613 || (d2
->tests
== 0 && d2
->code
== UNKNOWN
))
616 /* If either has a predicate that we know something about, set things up so
617 that D1 is the one that always has a known predicate. Then see if they
618 have any codes in common. */
620 if (d1
->pred
>= 0 || d2
->pred
>= 0)
625 p1
= d1
, d1
= d2
, d2
= p1
;
627 /* If D2 tests an explicit code, see if it is in the list of valid codes
628 for D1's predicate. */
629 if (d2
->code
!= UNKNOWN
)
631 for (i
= 0; i
< NUM_RTX_CODE
&& preds
[d1
->pred
].codes
[i
] != 0; i
++)
632 if (preds
[d1
->pred
].codes
[i
] == d2
->code
)
635 if (preds
[d1
->pred
].codes
[i
] == 0)
639 /* Otherwise see if the predicates have any codes in common. */
641 else if (d2
->pred
>= 0)
643 for (i
= 0; i
< NUM_RTX_CODE
&& preds
[d1
->pred
].codes
[i
] != 0; i
++)
645 for (j
= 0; j
< NUM_RTX_CODE
; j
++)
646 if (preds
[d2
->pred
].codes
[j
] == 0
647 || preds
[d2
->pred
].codes
[j
] == preds
[d1
->pred
].codes
[i
])
650 if (preds
[d2
->pred
].codes
[j
] != 0)
654 if (preds
[d1
->pred
].codes
[i
] == 0)
659 /* If we got here, we can't prove that D1 and D2 cannot both be true.
660 If we are only to check the top level, return 0. Otherwise, see if
661 we can prove that all choices in both successors are mutually
662 exclusive. If either does not have any successors, we can't prove
663 they can't both be true. */
665 if (toplevel
|| d1
->success
.first
== 0 || d2
->success
.first
== 0)
668 for (p1
= d1
->success
.first
; p1
; p1
= p1
->next
)
669 for (p2
= d2
->success
.first
; p2
; p2
= p2
->next
)
670 if (! not_both_true (p1
, p2
, 0))
676 /* Assuming that we can reorder all the alternatives at a specific point in
677 the tree (see discussion in merge_trees), we would prefer an ordering of
678 nodes where groups of consecutive nodes test the same mode and, within each
679 mode, groups of nodes test the same code. With this order, we can
680 construct nested switch statements, the inner one to test the code and
681 the outer one to test the mode.
683 We would like to list nodes testing for specific codes before those
684 that test predicates to avoid unnecessary function calls. Similarly,
685 tests for specific modes should precede nodes that allow any mode.
687 This function returns the merit (with 0 being the best) of inserting
688 a test involving the specified MODE and CODE after node P. If P is
689 zero, we are to determine the merit of inserting the test at the front
693 position_merit (p
, mode
, code
)
695 enum machine_mode mode
;
698 enum machine_mode p_mode
;
700 /* The only time the front of the list is anything other than the worst
701 position is if we are testing a mode that isn't VOIDmode. */
703 return mode
== VOIDmode
? 3 : 2;
705 p_mode
= p
->enforce_mode
? p
->mode
: VOIDmode
;
707 /* The best case is if the codes and modes both match. */
708 if (p_mode
== mode
&& p
->code
== code
)
711 /* If the codes don't match, the next best case is if the modes match.
712 In that case, the best position for this node depends on whether
713 we are testing for a specific code or not. If we are, the best place
714 is after some other test for an explicit code and our mode or after
715 the last test in the previous mode if every test in our mode is for
718 If we are testing for UNKNOWN, then the next best case is at the end of
722 && ((p_mode
== mode
&& p
->code
!= UNKNOWN
)
723 || (p_mode
!= mode
&& p
->next
724 && (p
->next
->enforce_mode
? p
->next
->mode
: VOIDmode
) == mode
725 && (p
->next
->code
== UNKNOWN
))))
726 || (code
== UNKNOWN
&& p_mode
== mode
728 || (p
->next
->enforce_mode
? p
->next
->mode
: VOIDmode
) != mode
)))
731 /* The third best case occurs when nothing is testing MODE. If MODE
732 is not VOIDmode, then the third best case is after something of any
733 mode that is not VOIDmode. If we are testing VOIDmode, the third best
734 place is the end of the list. */
737 && ((mode
!= VOIDmode
&& p_mode
!= VOIDmode
)
738 || (mode
== VOIDmode
&& p
->next
== 0)))
741 /* Otherwise, we have the worst case. */
745 /* Merge two decision tree listheads OLDH and ADDH,
746 modifying OLDH destructively, and return the merged tree. */
748 static struct decision_head
749 merge_trees (oldh
, addh
)
750 register struct decision_head oldh
, addh
;
752 struct decision
*add
, *next
;
760 /* If we are adding things at different positions, something is wrong. */
761 if (strcmp (oldh
.first
->position
, addh
.first
->position
))
764 for (add
= addh
.first
; add
; add
= next
)
766 enum machine_mode add_mode
= add
->enforce_mode
? add
->mode
: VOIDmode
;
767 struct decision
*best_position
= 0;
769 struct decision
*old
;
773 /* The semantics of pattern matching state that the tests are done in
774 the order given in the MD file so that if an insn matches two
775 patterns, the first one will be used. However, in practice, most,
776 if not all, patterns are unambiguous so that their order is
777 independent. In that case, we can merge identical tests and
778 group all similar modes and codes together.
780 Scan starting from the end of OLDH until we reach a point
781 where we reach the head of the list or where we pass a pattern
782 that could also be true if NEW is true. If we find an identical
783 pattern, we can merge them. Also, record the last node that tests
784 the same code and mode and the last one that tests just the same mode.
786 If we have no match, place NEW after the closest match we found. */
788 for (old
= oldh
.last
; old
; old
= old
->prev
)
792 /* If we don't have anything to test except an additional test,
793 do not consider the two nodes equal. If we did, the test below
794 would cause an infinite recursion. */
795 if (old
->tests
== 0 && old
->test_elt_zero_int
== 0
796 && old
->test_elt_one_int
== 0 && old
->veclen
== 0
797 && old
->test_elt_zero_wide
== 0
798 && old
->dupno
== -1 && old
->mode
== VOIDmode
799 && old
->code
== UNKNOWN
800 && (old
->c_test
!= 0 || add
->c_test
!= 0))
803 else if ((old
->tests
== add
->tests
804 || (old
->pred
>= 0 && old
->pred
== add
->pred
)
805 || (old
->tests
&& add
->tests
806 && !strcmp (old
->tests
, add
->tests
)))
807 && old
->test_elt_zero_int
== add
->test_elt_zero_int
808 && old
->elt_zero_int
== add
->elt_zero_int
809 && old
->test_elt_one_int
== add
->test_elt_one_int
810 && old
->elt_one_int
== add
->elt_one_int
811 && old
->test_elt_zero_wide
== add
->test_elt_zero_wide
812 && old
->elt_zero_wide
== add
->elt_zero_wide
813 && old
->veclen
== add
->veclen
814 && old
->dupno
== add
->dupno
815 && old
->opno
== add
->opno
816 && old
->code
== add
->code
817 && old
->enforce_mode
== add
->enforce_mode
818 && old
->mode
== add
->mode
)
820 /* If the additional test is not the same, split both nodes
821 into nodes that just contain all things tested before the
822 additional test and nodes that contain the additional test
823 and actions when it is true. This optimization is important
824 because of the case where we have almost identical patterns
825 with different tests on target flags. */
827 if (old
->c_test
!= add
->c_test
828 && ! (old
->c_test
&& add
->c_test
829 && !strcmp (old
->c_test
, add
->c_test
)))
831 if (old
->insn_code_number
>= 0 || old
->opno
>= 0)
833 struct decision
*split
834 = (struct decision
*) xmalloc (sizeof (struct decision
));
836 mybcopy ((char *) old
, (char *) split
,
837 sizeof (struct decision
));
839 old
->success
.first
= old
->success
.last
= split
;
842 old
->insn_code_number
= -1;
843 old
->num_clobbers_to_add
= 0;
845 split
->number
= next_number
++;
846 split
->next
= split
->prev
= 0;
847 split
->mode
= VOIDmode
;
848 split
->code
= UNKNOWN
;
850 split
->test_elt_zero_int
= 0;
851 split
->test_elt_one_int
= 0;
852 split
->test_elt_zero_wide
= 0;
858 if (add
->insn_code_number
>= 0 || add
->opno
>= 0)
860 struct decision
*split
861 = (struct decision
*) xmalloc (sizeof (struct decision
));
863 mybcopy ((char *) add
, (char *) split
,
864 sizeof (struct decision
));
866 add
->success
.first
= add
->success
.last
= split
;
869 add
->insn_code_number
= -1;
870 add
->num_clobbers_to_add
= 0;
872 split
->number
= next_number
++;
873 split
->next
= split
->prev
= 0;
874 split
->mode
= VOIDmode
;
875 split
->code
= UNKNOWN
;
877 split
->test_elt_zero_int
= 0;
878 split
->test_elt_one_int
= 0;
879 split
->test_elt_zero_wide
= 0;
886 if (old
->insn_code_number
>= 0 && add
->insn_code_number
>= 0)
888 /* If one node is for a normal insn and the second is
889 for the base insn with clobbers stripped off, the
890 second node should be ignored. */
892 if (old
->num_clobbers_to_add
== 0
893 && add
->num_clobbers_to_add
> 0)
894 /* Nothing to do here. */
896 else if (old
->num_clobbers_to_add
> 0
897 && add
->num_clobbers_to_add
== 0)
899 /* In this case, replace OLD with ADD. */
900 old
->insn_code_number
= add
->insn_code_number
;
901 old
->num_clobbers_to_add
= 0;
904 fatal ("Two actions at one point in tree");
907 if (old
->insn_code_number
== -1)
908 old
->insn_code_number
= add
->insn_code_number
;
909 old
->success
= merge_trees (old
->success
, add
->success
);
914 /* Unless we have already found the best possible insert point,
915 see if this position is better. If so, record it. */
918 && ((our_merit
= position_merit (old
, add_mode
, add
->code
))
920 best_merit
= our_merit
, best_position
= old
;
922 if (! not_both_true (old
, add
, 0))
926 /* If ADD was duplicate, we are done. */
930 /* Otherwise, find the best place to insert ADD. Normally this is
931 BEST_POSITION. However, if we went all the way to the top of
932 the list, it might be better to insert at the top. */
934 if (best_position
== 0)
938 && position_merit (NULL_PTR
, add_mode
, add
->code
) < best_merit
)
941 add
->next
= oldh
.first
;
942 oldh
.first
->prev
= add
;
948 add
->prev
= best_position
;
949 add
->next
= best_position
->next
;
950 best_position
->next
= add
;
951 if (best_position
== oldh
.last
)
954 add
->next
->prev
= add
;
961 /* Count the number of subnodes of HEAD. If the number is high enough,
962 make the first node in HEAD start a separate subroutine in the C code
965 TYPE gives the type of routine we are writing.
967 INITIAL is non-zero if this is the highest-level node. We never write
971 break_out_subroutines (head
, type
, initial
)
972 struct decision_head head
;
973 enum routine_type type
;
977 struct decision
*sub
;
979 for (sub
= head
.first
; sub
; sub
= sub
->next
)
980 size
+= 1 + break_out_subroutines (sub
->success
, type
, 0);
982 if (size
> SUBROUTINE_THRESHOLD
&& ! initial
)
984 head
.first
->subroutine_number
= ++next_subroutine_number
;
985 write_subroutine (head
.first
, type
);
991 /* Write out a subroutine of type TYPE to do comparisons starting at node
995 write_subroutine (tree
, type
)
996 struct decision
*tree
;
997 enum routine_type type
;
1002 printf ("rtx\nsplit");
1004 printf ("int\nrecog");
1006 if (tree
!= 0 && tree
->subroutine_number
> 0)
1007 printf ("_%d", tree
->subroutine_number
);
1008 else if (type
== SPLIT
)
1011 printf (" (x0, insn");
1013 printf (", pnum_clobbers");
1016 printf (" register rtx x0;\n rtx insn ATTRIBUTE_UNUSED;\n");
1018 printf (" int *pnum_clobbers ATTRIBUTE_UNUSED;\n");
1021 printf (" register rtx *ro = &recog_operand[0];\n");
1023 printf (" register rtx ");
1024 for (i
= 1; i
< max_depth
; i
++)
1025 printf ("x%d ATTRIBUTE_UNUSED, ", i
);
1027 printf ("x%d ATTRIBUTE_UNUSED;\n", max_depth
);
1028 printf (" %s tem ATTRIBUTE_UNUSED;\n", type
== SPLIT
? "rtx" : "int");
1029 write_tree (tree
, "", NULL_PTR
, 1, type
);
1030 printf (" ret0: return %d;\n}\n\n", type
== SPLIT
? 0 : -1);
1033 /* This table is used to indent the recog_* functions when we are inside
1034 conditions or switch statements. We only support small indentations
1035 and always indent at least two spaces. */
1037 static const char *indents
[]
1038 = {" ", " ", " ", " ", " ", " ", " ", " ",
1039 "\t", "\t ", "\t ", "\t ", "\t ", "\t ", "\t ",
1040 "\t\t", "\t\t ", "\t\t ", "\t\t ", "\t\t ", "\t\t "};
1042 /* Write out C code to perform the decisions in TREE for a subroutine of
1043 type TYPE. If all of the choices fail, branch to node AFTERWARD, if
1044 non-zero, otherwise return. PREVPOS is the position of the node that
1045 branched to this test.
1047 When we merged all alternatives, we tried to set up a convenient order.
1048 Specifically, tests involving the same mode are all grouped together,
1049 followed by a group that does not contain a mode test. Within each group
1050 of the same mode, we also group tests with the same code, followed by a
1051 group that does not test a code.
1053 Occasionally, we cannot arbitrarily reorder the tests so that multiple
1054 sequence of groups as described above are present.
1056 We generate two nested switch statements, the outer statement for
1057 testing modes, and the inner switch for testing RTX codes. It is
1058 not worth optimizing cases when only a small number of modes or
1059 codes is tested, since the compiler can do that when compiling the
1060 resulting function. We do check for when every test is the same mode
1064 write_tree_1 (tree
, prevpos
, afterward
, type
)
1065 struct decision
*tree
;
1066 const char *prevpos
;
1067 struct decision
*afterward
;
1068 enum routine_type type
;
1070 register struct decision
*p
, *p1
;
1071 register int depth
= tree
? strlen (tree
->position
) : 0;
1072 enum machine_mode switch_mode
= VOIDmode
;
1073 RTX_CODE switch_code
= UNKNOWN
;
1075 char modemap
[NUM_MACHINE_MODES
];
1076 char codemap
[NUM_RTX_CODE
];
1080 /* One tricky area is what is the exact state when we branch to a
1081 node's label. There are two cases where we branch: when looking at
1082 successors to a node, or when a set of tests fails.
1084 In the former case, we are always branching to the first node in a
1085 decision list and we want all required tests to be performed. We
1086 put the labels for such nodes in front of any switch or test statements.
1087 These branches are done without updating the position to that of the
1090 In the latter case, we are branching to a node that is not the first
1091 node in a decision list. We have already checked that it is possible
1092 for both the node we originally tested at this level and the node we
1093 are branching to to both match some pattern. That means that they
1094 usually will be testing the same mode and code. So it is normally safe
1095 for such labels to be inside switch statements, since the tests done
1096 by virtue of arriving at that label will usually already have been
1097 done. The exception is a branch from a node that does not test a
1098 mode or code to one that does. In such cases, we set the `retest_mode'
1099 or `retest_code' flags. That will ensure that we start a new switch
1100 at that position and put the label before the switch.
1102 The branches in the latter case must set the position to that of the
1107 if (tree
&& tree
->subroutine_number
== 0)
1109 OUTPUT_LABEL (" ", tree
->number
);
1110 tree
->label_needed
= 0;
1115 change_state (prevpos
, tree
->position
, 2);
1116 prevpos
= tree
->position
;
1119 for (p
= tree
; p
; p
= p
->next
)
1121 enum machine_mode mode
= p
->enforce_mode
? p
->mode
: VOIDmode
;
1123 int wrote_bracket
= 0;
1126 if (p
->success
.first
== 0 && p
->insn_code_number
< 0)
1129 /* Find the next alternative to p that might be true when p is true.
1130 Test that one next if p's successors fail. */
1132 for (p1
= p
->next
; p1
&& not_both_true (p
, p1
, 1); p1
= p1
->next
)
1138 if (mode
== VOIDmode
&& p1
->enforce_mode
&& p1
->mode
!= VOIDmode
)
1139 p1
->retest_mode
= 1;
1140 if (p
->code
== UNKNOWN
&& p1
->code
!= UNKNOWN
)
1141 p1
->retest_code
= 1;
1142 p1
->label_needed
= 1;
1145 /* If we have a different code or mode than the last node and
1146 are in a switch on codes, we must either end the switch or
1147 go to another case. We must also end the switch if this
1148 node needs a label and to retest either the mode or code. */
1150 if (switch_code
!= UNKNOWN
1151 && (switch_code
!= p
->code
|| switch_mode
!= mode
1152 || (p
->label_needed
&& (p
->retest_mode
|| p
->retest_code
))))
1154 enum rtx_code code
= p
->code
;
1156 /* If P is testing a predicate that we know about and we haven't
1157 seen any of the codes that are valid for the predicate, we
1158 can write a series of "case" statement, one for each possible
1159 code. Since we are already in a switch, these redundant tests
1160 are very cheap and will reduce the number of predicate called. */
1164 for (i
= 0; i
< NUM_RTX_CODE
&& preds
[p
->pred
].codes
[i
] != 0; i
++)
1165 if (codemap
[(int) preds
[p
->pred
].codes
[i
]])
1168 if (preds
[p
->pred
].codes
[i
] == 0)
1169 code
= MATCH_OPERAND
;
1172 if (code
== UNKNOWN
|| codemap
[(int) code
]
1173 || switch_mode
!= mode
1174 || (p
->label_needed
&& (p
->retest_mode
|| p
->retest_code
)))
1176 printf ("%s}\n", indents
[indent
- 2]);
1177 switch_code
= UNKNOWN
;
1183 printf ("%sbreak;\n", indents
[indent
]);
1185 if (code
== MATCH_OPERAND
)
1187 for (i
= 0; i
< NUM_RTX_CODE
&& preds
[p
->pred
].codes
[i
] != 0; i
++)
1189 printf ("%scase ", indents
[indent
- 2]);
1190 print_code (preds
[p
->pred
].codes
[i
]);
1192 codemap
[(int) preds
[p
->pred
].codes
[i
]] = 1;
1197 printf ("%scase ", indents
[indent
- 2]);
1200 codemap
[(int) p
->code
] = 1;
1209 /* If we were previously in a switch on modes and now have a different
1210 mode, end at least the case, and maybe end the switch if we are
1211 not testing a mode or testing a mode whose case we already saw. */
1213 if (switch_mode
!= VOIDmode
1214 && (switch_mode
!= mode
|| (p
->label_needed
&& p
->retest_mode
)))
1216 if (mode
== VOIDmode
|| modemap
[(int) mode
]
1217 || (p
->label_needed
&& p
->retest_mode
))
1219 printf ("%s}\n", indents
[indent
- 2]);
1220 switch_mode
= VOIDmode
;
1226 printf (" break;\n");
1227 printf (" case %smode:\n", GET_MODE_NAME (mode
));
1229 modemap
[(int) mode
] = 1;
1235 /* If we are about to write dead code, something went wrong. */
1236 if (! p
->label_needed
&& uncond
)
1239 /* If we need a label and we will want to retest the mode or code at
1240 that label, write the label now. We have already ensured that
1241 things will be valid for the test. */
1243 if (p
->label_needed
&& (p
->retest_mode
|| p
->retest_code
))
1245 OUTPUT_LABEL (indents
[indent
- 2], p
->number
);
1246 p
->label_needed
= 0;
1251 /* If we are not in any switches, see if we can shortcut things
1252 by checking for identical modes and codes. */
1254 if (switch_mode
== VOIDmode
&& switch_code
== UNKNOWN
)
1256 /* If p and its alternatives all want the same mode,
1257 reject all others at once, first, then ignore the mode. */
1259 if (mode
!= VOIDmode
&& p
->next
&& same_modes (p
, mode
))
1261 printf (" if (GET_MODE (x%d) != %smode)\n",
1262 depth
, GET_MODE_NAME (p
->mode
));
1266 change_state (p
->position
, afterward
->position
, 6);
1267 printf (" goto L%d;\n }\n", afterward
->number
);
1270 printf (" goto ret0;\n");
1275 /* If p and its alternatives all want the same code,
1276 reject all others at once, first, then ignore the code. */
1278 if (p
->code
!= UNKNOWN
&& p
->next
&& same_codes (p
, p
->code
))
1280 printf (" if (GET_CODE (x%d) != ", depth
);
1281 print_code (p
->code
);
1286 change_state (p
->position
, afterward
->position
, indent
+ 4);
1287 printf (" goto L%d;\n }\n", afterward
->number
);
1290 printf (" goto ret0;\n");
1295 /* If we are not in a mode switch and we are testing for a specific
1296 mode, start a mode switch unless we have just one node or the next
1297 node is not testing a mode (we have already tested for the case of
1298 more than one mode, but all of the same mode). */
1300 if (switch_mode
== VOIDmode
&& mode
!= VOIDmode
&& p
->next
!= 0
1301 && p
->next
->enforce_mode
&& p
->next
->mode
!= VOIDmode
)
1303 mybzero (modemap
, sizeof modemap
);
1304 printf ("%sswitch (GET_MODE (x%d))\n", indents
[indent
], depth
);
1305 printf ("%s{\n", indents
[indent
+ 2]);
1307 printf ("%sdefault:\n%sbreak;\n", indents
[indent
- 2],
1309 printf ("%scase %smode:\n", indents
[indent
- 2],
1310 GET_MODE_NAME (mode
));
1311 modemap
[(int) mode
] = 1;
1315 /* Similarly for testing codes. */
1317 if (switch_code
== UNKNOWN
&& p
->code
!= UNKNOWN
&& ! p
->ignore_code
1318 && p
->next
!= 0 && p
->next
->code
!= UNKNOWN
)
1320 mybzero (codemap
, sizeof codemap
);
1321 printf ("%sswitch (GET_CODE (x%d))\n", indents
[indent
], depth
);
1322 printf ("%s{\n", indents
[indent
+ 2]);
1324 printf ("%sdefault:\n%sbreak;\n", indents
[indent
- 2],
1326 printf ("%scase ", indents
[indent
- 2]);
1327 print_code (p
->code
);
1329 codemap
[(int) p
->code
] = 1;
1330 switch_code
= p
->code
;
1333 /* Now that most mode and code tests have been done, we can write out
1334 a label for an inner node, if we haven't already. */
1335 if (p
->label_needed
)
1336 OUTPUT_LABEL (indents
[indent
- 2], p
->number
);
1338 inner_indent
= indent
;
1340 /* The only way we can have to do a mode or code test here is if
1341 this node needs such a test but is the only node to be tested.
1342 In that case, we won't have started a switch. Note that this is
1343 the only way the switch and test modes can disagree. */
1345 if ((mode
!= switch_mode
&& ! p
->ignore_mode
)
1346 || (p
->code
!= switch_code
&& p
->code
!= UNKNOWN
&& ! p
->ignore_code
)
1347 || p
->test_elt_zero_int
|| p
->test_elt_one_int
1348 || p
->test_elt_zero_wide
|| p
->veclen
1349 || p
->dupno
>= 0 || p
->tests
|| p
->num_clobbers_to_add
)
1351 printf ("%sif (", indents
[indent
]);
1353 if (mode
!= switch_mode
&& ! p
->ignore_mode
)
1354 printf ("GET_MODE (x%d) == %smode && ",
1355 depth
, GET_MODE_NAME (mode
));
1356 if (p
->code
!= switch_code
&& p
->code
!= UNKNOWN
&& ! p
->ignore_code
)
1358 printf ("GET_CODE (x%d) == ", depth
);
1359 print_code (p
->code
);
1363 if (p
->test_elt_zero_int
)
1364 printf ("XINT (x%d, 0) == %d && ", depth
, p
->elt_zero_int
);
1365 if (p
->test_elt_one_int
)
1366 printf ("XINT (x%d, 1) == %d && ", depth
, p
->elt_one_int
);
1367 if (p
->test_elt_zero_wide
)
1369 /* Set offset to 1 iff the number might get propagated to
1370 unsigned long by ANSI C rules, else 0.
1371 Prospective hosts are required to have at least 32 bit
1372 ints, and integer constants in machine descriptions
1373 must fit in 32 bit, thus it suffices to check only
1375 HOST_WIDE_INT offset
= p
->elt_zero_wide
== -2147483647 - 1;
1376 printf ("XWINT (x%d, 0) == ", depth
);
1377 printf (HOST_WIDE_INT_PRINT_DEC
, p
->elt_zero_wide
+ offset
);
1378 printf ("%s && ", offset
? "-1" : "");
1381 printf ("XVECLEN (x%d, 0) == %d && ", depth
, p
->veclen
);
1383 printf ("rtx_equal_p (x%d, ro[%d]) && ", depth
, p
->dupno
);
1384 if (p
->num_clobbers_to_add
)
1385 printf ("pnum_clobbers != 0 && ");
1387 printf ("%s (x%d, %smode)", p
->tests
, depth
,
1388 GET_MODE_NAME (p
->mode
));
1398 need_bracket
= ! uncond
;
1404 printf ("%s{\n", indents
[inner_indent
]);
1410 printf ("%sro[%d] = x%d;\n", indents
[inner_indent
], p
->opno
, depth
);
1415 printf ("%sif (%s)\n", indents
[inner_indent
], p
->c_test
);
1421 if (p
->insn_code_number
>= 0)
1424 printf ("%sreturn gen_split_%d (operands);\n",
1425 indents
[inner_indent
], p
->insn_code_number
);
1428 if (p
->num_clobbers_to_add
)
1432 printf ("%s{\n", indents
[inner_indent
]);
1436 printf ("%s*pnum_clobbers = %d;\n",
1437 indents
[inner_indent
], p
->num_clobbers_to_add
);
1438 printf ("%sreturn %d;\n",
1439 indents
[inner_indent
], p
->insn_code_number
);
1444 printf ("%s}\n", indents
[inner_indent
]);
1448 printf ("%sreturn %d;\n",
1449 indents
[inner_indent
], p
->insn_code_number
);
1453 printf ("%sgoto L%d;\n", indents
[inner_indent
],
1454 p
->success
.first
->number
);
1457 printf ("%s}\n", indents
[inner_indent
- 2]);
1460 /* We have now tested all alternatives. End any switches we have open
1461 and branch to the alternative node unless we know that we can't fall
1462 through to the branch. */
1464 if (switch_code
!= UNKNOWN
)
1466 printf ("%s}\n", indents
[indent
- 2]);
1471 if (switch_mode
!= VOIDmode
)
1473 printf ("%s}\n", indents
[indent
- 2]);
1486 change_state (prevpos
, afterward
->position
, 2);
1487 printf (" goto L%d;\n", afterward
->number
);
1490 printf (" goto ret0;\n");
1498 for (p1
= GET_RTX_NAME (code
); *p1
; p1
++)
1500 if (*p1
>= 'a' && *p1
<= 'z')
1501 putchar (*p1
+ 'A' - 'a');
1508 same_codes (p
, code
)
1509 register struct decision
*p
;
1510 register enum rtx_code code
;
1512 for (; p
; p
= p
->next
)
1513 if (p
->code
!= code
)
1521 register struct decision
*p
;
1523 for (; p
; p
= p
->next
)
1528 same_modes (p
, mode
)
1529 register struct decision
*p
;
1530 register enum machine_mode mode
;
1532 for (; p
; p
= p
->next
)
1533 if ((p
->enforce_mode
? p
->mode
: VOIDmode
) != mode
)
1541 register struct decision
*p
;
1543 for (; p
; p
= p
->next
)
1544 p
->enforce_mode
= 0;
1547 /* Write out the decision tree starting at TREE for a subroutine of type TYPE.
1549 PREVPOS is the position at the node that branched to this node.
1551 INITIAL is nonzero if this is the first node we are writing in a subroutine.
1553 If all nodes are false, branch to the node AFTERWARD. */
1556 write_tree (tree
, prevpos
, afterward
, initial
, type
)
1557 struct decision
*tree
;
1558 const char *prevpos
;
1559 struct decision
*afterward
;
1561 enum routine_type type
;
1563 register struct decision
*p
;
1564 const char *name_prefix
= (type
== SPLIT
? "split" : "recog");
1565 const char *call_suffix
= (type
== SPLIT
? "" : ", pnum_clobbers");
1567 if (! initial
&& tree
->subroutine_number
> 0)
1569 OUTPUT_LABEL (" ", tree
->number
);
1573 printf (" tem = %s_%d (x0, insn%s);\n",
1574 name_prefix
, tree
->subroutine_number
, call_suffix
);
1576 printf (" if (tem != 0) return tem;\n");
1578 printf (" if (tem >= 0) return tem;\n");
1579 change_state (tree
->position
, afterward
->position
, 2);
1580 printf (" goto L%d;\n", afterward
->number
);
1583 printf (" return %s_%d (x0, insn%s);\n",
1584 name_prefix
, tree
->subroutine_number
, call_suffix
);
1588 write_tree_1 (tree
, prevpos
, afterward
, type
);
1590 for (p
= tree
; p
; p
= p
->next
)
1591 if (p
->success
.first
)
1592 write_tree (p
->success
.first
, p
->position
,
1593 p
->afterward
? p
->afterward
: afterward
, 0, type
);
1597 /* Assuming that the state of argument is denoted by OLDPOS, take whatever
1598 actions are necessary to move to NEWPOS.
1600 INDENT says how many blanks to place at the front of lines. */
1603 change_state (oldpos
, newpos
, indent
)
1608 int odepth
= strlen (oldpos
);
1610 int ndepth
= strlen (newpos
);
1612 /* Pop up as many levels as necessary. */
1614 while (strncmp (oldpos
, newpos
, depth
))
1617 /* Go down to desired level. */
1619 while (depth
< ndepth
)
1621 if (newpos
[depth
] >= 'a' && newpos
[depth
] <= 'z')
1622 printf ("%sx%d = XVECEXP (x%d, 0, %d);\n",
1623 indents
[indent
], depth
+ 1, depth
, newpos
[depth
] - 'a');
1625 printf ("%sx%d = XEXP (x%d, %c);\n",
1626 indents
[indent
], depth
+ 1, depth
, newpos
[depth
]);
1640 tem
= (char *) xmalloc (strlen (s1
) + 1);
1649 register unsigned length
;
1651 while (length
-- > 0)
1656 mybcopy (in
, out
, length
)
1657 register char *in
, *out
;
1658 register unsigned length
;
1660 while (length
-- > 0)
1665 xrealloc (ptr
, size
)
1669 register PTR result
= (PTR
) realloc (ptr
, size
);
1671 fatal ("virtual memory exhausted");
1679 register PTR val
= (PTR
) malloc (size
);
1682 fatal ("virtual memory exhausted");
1687 fatal
VPROTO ((const char *format
, ...))
1689 #ifndef ANSI_PROTOTYPES
1694 VA_START (ap
, format
);
1696 #ifndef ANSI_PROTOTYPES
1697 format
= va_arg (ap
, const char *);
1700 fprintf (stderr
, "genrecog: ");
1701 vfprintf (stderr
, format
, ap
);
1703 fprintf (stderr
, "\n");
1704 fprintf (stderr
, "after %d definitions\n", next_index
);
1705 exit (FATAL_EXIT_CODE
);
1708 /* More 'friendly' abort that prints the line and file.
1709 config.h can #define abort fancy_abort if you like that sort of thing. */
1714 fatal ("Internal gcc abort.");
1723 struct decision_head recog_tree
;
1724 struct decision_head split_tree
;
1728 obstack_init (rtl_obstack
);
1729 recog_tree
.first
= recog_tree
.last
= split_tree
.first
= split_tree
.last
= 0;
1732 fatal ("No input file name.");
1734 infile
= fopen (argv
[1], "r");
1738 exit (FATAL_EXIT_CODE
);
1745 printf ("/* Generated automatically by the program `genrecog'\n\
1746 from the machine description file `md'. */\n\n");
1748 printf ("#include \"config.h\"\n");
1749 printf ("#include \"system.h\"\n");
1750 printf ("#include \"rtl.h\"\n");
1751 printf ("#include \"insn-config.h\"\n");
1752 printf ("#include \"recog.h\"\n");
1753 printf ("#include \"real.h\"\n");
1754 printf ("#include \"output.h\"\n");
1755 printf ("#include \"flags.h\"\n");
1758 /* Read the machine description. */
1762 c
= read_skip_spaces (infile
);
1767 desc
= read_rtx (infile
);
1768 if (GET_CODE (desc
) == DEFINE_INSN
)
1769 recog_tree
= merge_trees (recog_tree
,
1770 make_insn_sequence (desc
, RECOG
));
1771 else if (GET_CODE (desc
) == DEFINE_SPLIT
)
1772 split_tree
= merge_trees (split_tree
,
1773 make_insn_sequence (desc
, SPLIT
));
1774 if (GET_CODE (desc
) == DEFINE_PEEPHOLE
1775 || GET_CODE (desc
) == DEFINE_EXPAND
)
1781 /* `recog' contains a decision tree\n\
1782 that recognizes whether the rtx X0 is a valid instruction.\n\
1784 recog returns -1 if the rtx is not valid.\n\
1785 If the rtx is valid, recog returns a nonnegative number\n\
1786 which is the insn code number for the pattern that matched.\n");
1787 printf (" This is the same as the order in the machine description of\n\
1788 the entry that matched. This number can be used as an index into various\n\
1789 insn_* tables, such as insn_templates, insn_outfun, and insn_n_operands\n\
1790 (found in insn-output.c).\n\n");
1791 printf (" The third argument to recog is an optional pointer to an int.\n\
1792 If present, recog will accept a pattern if it matches except for\n\
1793 missing CLOBBER expressions at the end. In that case, the value\n\
1794 pointed to by the optional pointer will be set to the number of\n\
1795 CLOBBERs that need to be added (it should be initialized to zero by\n\
1796 the caller). If it is set nonzero, the caller should allocate a\n\
1797 PARALLEL of the appropriate size, copy the initial entries, and call\n\
1798 add_clobbers (found in insn-emit.c) to fill in the CLOBBERs.");
1800 if (split_tree
.first
)
1801 printf ("\n\n The function split_insns returns 0 if the rtl could not\n\
1802 be split or the split rtl in a SEQUENCE if it can be.");
1806 printf ("#define operands recog_operand\n\n");
1808 next_subroutine_number
= 0;
1809 break_out_subroutines (recog_tree
, RECOG
, 1);
1810 write_subroutine (recog_tree
.first
, RECOG
);
1812 next_subroutine_number
= 0;
1813 break_out_subroutines (split_tree
, SPLIT
, 1);
1814 write_subroutine (split_tree
.first
, SPLIT
);
1817 exit (ferror (stdout
) != 0 ? FATAL_EXIT_CODE
: SUCCESS_EXIT_CODE
);