1 /* Subroutines used by or related to instruction recognition.
2 Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998
3 1999, 2000 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
27 #include "insn-config.h"
28 #include "insn-attr.h"
29 #include "insn-flags.h"
30 #include "insn-codes.h"
31 #include "hard-reg-set.h"
38 #include "basic-block.h"
41 #ifndef STACK_PUSH_CODE
42 #ifdef STACK_GROWS_DOWNWARD
43 #define STACK_PUSH_CODE PRE_DEC
45 #define STACK_PUSH_CODE PRE_INC
49 #ifndef STACK_POP_CODE
50 #ifdef STACK_GROWS_DOWNWARD
51 #define STACK_POP_CODE POST_INC
53 #define STACK_POP_CODE POST_DEC
57 static void validate_replace_rtx_1
PARAMS ((rtx
*, rtx
, rtx
, rtx
));
58 static rtx
*find_single_use_1
PARAMS ((rtx
, rtx
*));
59 static rtx
*find_constant_term_loc
PARAMS ((rtx
*));
60 static int insn_invalid_p
PARAMS ((rtx
));
62 /* Nonzero means allow operands to be volatile.
63 This should be 0 if you are generating rtl, such as if you are calling
64 the functions in optabs.c and expmed.c (most of the time).
65 This should be 1 if all valid insns need to be recognized,
66 such as in regclass.c and final.c and reload.c.
68 init_recog and init_recog_no_volatile are responsible for setting this. */
72 struct recog_data recog_data
;
74 /* Contains a vector of operand_alternative structures for every operand.
75 Set up by preprocess_constraints. */
76 struct operand_alternative recog_op_alt
[MAX_RECOG_OPERANDS
][MAX_RECOG_ALTERNATIVES
];
78 /* On return from `constrain_operands', indicate which alternative
81 int which_alternative
;
83 /* Nonzero after end of reload pass.
84 Set to 1 or 0 by toplev.c.
85 Controls the significance of (SUBREG (MEM)). */
89 /* Initialize data used by the function `recog'.
90 This must be called once in the compilation of a function
91 before any insn recognition may be done in the function. */
94 init_recog_no_volatile ()
105 /* Try recognizing the instruction INSN,
106 and return the code number that results.
107 Remember the code so that repeated calls do not
108 need to spend the time for actual rerecognition.
110 This function is the normal interface to instruction recognition.
111 The automatically-generated function `recog' is normally called
112 through this one. (The only exception is in combine.c.) */
115 recog_memoized (insn
)
118 if (INSN_CODE (insn
) < 0)
119 INSN_CODE (insn
) = recog (PATTERN (insn
), insn
, NULL_PTR
);
120 return INSN_CODE (insn
);
123 /* Check that X is an insn-body for an `asm' with operands
124 and that the operands mentioned in it are legitimate. */
127 check_asm_operands (x
)
132 const char **constraints
;
135 /* Post-reload, be more strict with things. */
136 if (reload_completed
)
138 /* ??? Doh! We've not got the wrapping insn. Cook one up. */
139 extract_insn (make_insn_raw (x
));
140 constrain_operands (1);
141 return which_alternative
>= 0;
144 noperands
= asm_noperands (x
);
150 operands
= (rtx
*) alloca (noperands
* sizeof (rtx
));
151 constraints
= (const char **) alloca (noperands
* sizeof (char *));
153 decode_asm_operands (x
, operands
, NULL_PTR
, constraints
, NULL_PTR
);
155 for (i
= 0; i
< noperands
; i
++)
157 const char *c
= constraints
[i
];
160 if (ISDIGIT ((unsigned char)c
[0]) && c
[1] == '\0')
161 c
= constraints
[c
[0] - '0'];
163 if (! asm_operand_ok (operands
[i
], c
))
170 /* Static data for the next two routines. */
172 typedef struct change_t
180 static change_t
*changes
;
181 static int changes_allocated
;
183 static int num_changes
= 0;
185 /* Validate a proposed change to OBJECT. LOC is the location in the rtl for
186 at which NEW will be placed. If OBJECT is zero, no validation is done,
187 the change is simply made.
189 Two types of objects are supported: If OBJECT is a MEM, memory_address_p
190 will be called with the address and mode as parameters. If OBJECT is
191 an INSN, CALL_INSN, or JUMP_INSN, the insn will be re-recognized with
194 IN_GROUP is non-zero if this is part of a group of changes that must be
195 performed as a group. In that case, the changes will be stored. The
196 function `apply_change_group' will validate and apply the changes.
198 If IN_GROUP is zero, this is a single change. Try to recognize the insn
199 or validate the memory reference with the change applied. If the result
200 is not valid for the machine, suppress the change and return zero.
201 Otherwise, perform the change and return 1. */
204 validate_change (object
, loc
, new, in_group
)
212 if (old
== new || rtx_equal_p (old
, new))
215 if (in_group
== 0 && num_changes
!= 0)
220 /* Save the information describing this change. */
221 if (num_changes
>= changes_allocated
)
223 if (changes_allocated
== 0)
224 /* This value allows for repeated substitutions inside complex
225 indexed addresses, or changes in up to 5 insns. */
226 changes_allocated
= MAX_RECOG_OPERANDS
* 5;
228 changes_allocated
*= 2;
231 (change_t
*) xrealloc (changes
,
232 sizeof (change_t
) * changes_allocated
);
235 changes
[num_changes
].object
= object
;
236 changes
[num_changes
].loc
= loc
;
237 changes
[num_changes
].old
= old
;
239 if (object
&& GET_CODE (object
) != MEM
)
241 /* Set INSN_CODE to force rerecognition of insn. Save old code in
243 changes
[num_changes
].old_code
= INSN_CODE (object
);
244 INSN_CODE (object
) = -1;
249 /* If we are making a group of changes, return 1. Otherwise, validate the
250 change group we made. */
255 return apply_change_group ();
258 /* This subroutine of apply_change_group verifies whether the changes to INSN
259 were valid; i.e. whether INSN can still be recognized. */
262 insn_invalid_p (insn
)
265 int icode
= recog_memoized (insn
);
266 int is_asm
= icode
< 0 && asm_noperands (PATTERN (insn
)) >= 0;
268 if (is_asm
&& ! check_asm_operands (PATTERN (insn
)))
270 if (! is_asm
&& icode
< 0)
273 /* After reload, verify that all constraints are satisfied. */
274 if (reload_completed
)
278 if (! constrain_operands (1))
285 /* Apply a group of changes previously issued with `validate_change'.
286 Return 1 if all changes are valid, zero otherwise. */
289 apply_change_group ()
293 /* The changes have been applied and all INSN_CODEs have been reset to force
296 The changes are valid if we aren't given an object, or if we are
297 given a MEM and it still is a valid address, or if this is in insn
298 and it is recognized. In the latter case, if reload has completed,
299 we also require that the operands meet the constraints for
302 for (i
= 0; i
< num_changes
; i
++)
304 rtx object
= changes
[i
].object
;
309 if (GET_CODE (object
) == MEM
)
311 if (! memory_address_p (GET_MODE (object
), XEXP (object
, 0)))
314 else if (insn_invalid_p (object
))
316 rtx pat
= PATTERN (object
);
318 /* Perhaps we couldn't recognize the insn because there were
319 extra CLOBBERs at the end. If so, try to re-recognize
320 without the last CLOBBER (later iterations will cause each of
321 them to be eliminated, in turn). But don't do this if we
322 have an ASM_OPERAND. */
323 if (GET_CODE (pat
) == PARALLEL
324 && GET_CODE (XVECEXP (pat
, 0, XVECLEN (pat
, 0) - 1)) == CLOBBER
325 && asm_noperands (PATTERN (object
)) < 0)
329 if (XVECLEN (pat
, 0) == 2)
330 newpat
= XVECEXP (pat
, 0, 0);
336 = gen_rtx_PARALLEL (VOIDmode
,
337 gen_rtvec (XVECLEN (pat
, 0) - 1));
338 for (j
= 0; j
< XVECLEN (newpat
, 0); j
++)
339 XVECEXP (newpat
, 0, j
) = XVECEXP (pat
, 0, j
);
342 /* Add a new change to this group to replace the pattern
343 with this new pattern. Then consider this change
344 as having succeeded. The change we added will
345 cause the entire call to fail if things remain invalid.
347 Note that this can lose if a later change than the one
348 we are processing specified &XVECEXP (PATTERN (object), 0, X)
349 but this shouldn't occur. */
351 validate_change (object
, &PATTERN (object
), newpat
, 1);
353 else if (GET_CODE (pat
) == USE
|| GET_CODE (pat
) == CLOBBER
)
354 /* If this insn is a CLOBBER or USE, it is always valid, but is
362 if (i
== num_changes
)
374 /* Return the number of changes so far in the current group. */
377 num_validated_changes ()
382 /* Retract the changes numbered NUM and up. */
390 /* Back out all the changes. Do this in the opposite order in which
392 for (i
= num_changes
- 1; i
>= num
; i
--)
394 *changes
[i
].loc
= changes
[i
].old
;
395 if (changes
[i
].object
&& GET_CODE (changes
[i
].object
) != MEM
)
396 INSN_CODE (changes
[i
].object
) = changes
[i
].old_code
;
401 /* Replace every occurrence of FROM in X with TO. Mark each change with
402 validate_change passing OBJECT. */
405 validate_replace_rtx_1 (loc
, from
, to
, object
)
407 rtx from
, to
, object
;
410 register const char *fmt
;
411 register rtx x
= *loc
;
417 /* X matches FROM if it is the same rtx or they are both referring to the
418 same register in the same mode. Avoid calling rtx_equal_p unless the
419 operands look similar. */
422 || (GET_CODE (x
) == REG
&& GET_CODE (from
) == REG
423 && GET_MODE (x
) == GET_MODE (from
)
424 && REGNO (x
) == REGNO (from
))
425 || (GET_CODE (x
) == GET_CODE (from
) && GET_MODE (x
) == GET_MODE (from
)
426 && rtx_equal_p (x
, from
)))
428 validate_change (object
, loc
, to
, 1);
432 /* For commutative or comparison operations, try replacing each argument
433 separately and seeing if we made any changes. If so, put a constant
435 if (GET_RTX_CLASS (code
) == '<' || GET_RTX_CLASS (code
) == 'c')
437 int prev_changes
= num_changes
;
439 validate_replace_rtx_1 (&XEXP (x
, 0), from
, to
, object
);
440 validate_replace_rtx_1 (&XEXP (x
, 1), from
, to
, object
);
441 if (prev_changes
!= num_changes
&& CONSTANT_P (XEXP (x
, 0)))
443 validate_change (object
, loc
,
444 gen_rtx_fmt_ee (GET_RTX_CLASS (code
) == 'c' ? code
445 : swap_condition (code
),
446 GET_MODE (x
), XEXP (x
, 1),
454 /* Note that if CODE's RTX_CLASS is "c" or "<" we will have already
455 done the substitution, otherwise we won't. */
460 /* If we have a PLUS whose second operand is now a CONST_INT, use
461 plus_constant to try to simplify it. */
462 if (GET_CODE (XEXP (x
, 1)) == CONST_INT
&& XEXP (x
, 1) == to
)
463 validate_change (object
, loc
, plus_constant (XEXP (x
, 0), INTVAL (to
)),
468 if (GET_CODE (to
) == CONST_INT
&& XEXP (x
, 1) == from
)
470 validate_change (object
, loc
,
471 plus_constant (XEXP (x
, 0), - INTVAL (to
)),
479 /* In these cases, the operation to be performed depends on the mode
480 of the operand. If we are replacing the operand with a VOIDmode
481 constant, we lose the information. So try to simplify the operation
482 in that case. If it fails, substitute in something that we know
483 won't be recognized. */
484 if (GET_MODE (to
) == VOIDmode
485 && (XEXP (x
, 0) == from
486 || (GET_CODE (XEXP (x
, 0)) == REG
&& GET_CODE (from
) == REG
487 && GET_MODE (XEXP (x
, 0)) == GET_MODE (from
)
488 && REGNO (XEXP (x
, 0)) == REGNO (from
))))
490 rtx
new = simplify_unary_operation (code
, GET_MODE (x
), to
,
493 new = gen_rtx_CLOBBER (GET_MODE (x
), const0_rtx
);
495 validate_change (object
, loc
, new, 1);
501 /* If we have a SUBREG of a register that we are replacing and we are
502 replacing it with a MEM, make a new MEM and try replacing the
503 SUBREG with it. Don't do this if the MEM has a mode-dependent address
504 or if we would be widening it. */
506 if (SUBREG_REG (x
) == from
507 && GET_CODE (from
) == REG
508 && GET_CODE (to
) == MEM
509 && ! mode_dependent_address_p (XEXP (to
, 0))
510 && ! MEM_VOLATILE_P (to
)
511 && GET_MODE_SIZE (GET_MODE (x
)) <= GET_MODE_SIZE (GET_MODE (to
)))
513 int offset
= SUBREG_WORD (x
) * UNITS_PER_WORD
;
514 enum machine_mode mode
= GET_MODE (x
);
517 if (BYTES_BIG_ENDIAN
)
518 offset
+= (MIN (UNITS_PER_WORD
,
519 GET_MODE_SIZE (GET_MODE (SUBREG_REG (x
))))
520 - MIN (UNITS_PER_WORD
, GET_MODE_SIZE (mode
)));
522 new = gen_rtx_MEM (mode
, plus_constant (XEXP (to
, 0), offset
));
523 MEM_COPY_ATTRIBUTES (new, to
);
524 validate_change (object
, loc
, new, 1);
531 /* If we are replacing a register with memory, try to change the memory
532 to be the mode required for memory in extract operations (this isn't
533 likely to be an insertion operation; if it was, nothing bad will
534 happen, we might just fail in some cases). */
536 if (XEXP (x
, 0) == from
&& GET_CODE (from
) == REG
&& GET_CODE (to
) == MEM
537 && GET_CODE (XEXP (x
, 1)) == CONST_INT
538 && GET_CODE (XEXP (x
, 2)) == CONST_INT
539 && ! mode_dependent_address_p (XEXP (to
, 0))
540 && ! MEM_VOLATILE_P (to
))
542 enum machine_mode wanted_mode
= VOIDmode
;
543 enum machine_mode is_mode
= GET_MODE (to
);
544 int pos
= INTVAL (XEXP (x
, 2));
547 if (code
== ZERO_EXTRACT
)
549 wanted_mode
= insn_data
[(int) CODE_FOR_extzv
].operand
[1].mode
;
550 if (wanted_mode
== VOIDmode
)
551 wanted_mode
= word_mode
;
555 if (code
== SIGN_EXTRACT
)
557 wanted_mode
= insn_data
[(int) CODE_FOR_extv
].operand
[1].mode
;
558 if (wanted_mode
== VOIDmode
)
559 wanted_mode
= word_mode
;
563 /* If we have a narrower mode, we can do something. */
564 if (wanted_mode
!= VOIDmode
565 && GET_MODE_SIZE (wanted_mode
) < GET_MODE_SIZE (is_mode
))
567 int offset
= pos
/ BITS_PER_UNIT
;
570 /* If the bytes and bits are counted differently, we
571 must adjust the offset. */
572 if (BYTES_BIG_ENDIAN
!= BITS_BIG_ENDIAN
)
573 offset
= (GET_MODE_SIZE (is_mode
) - GET_MODE_SIZE (wanted_mode
)
576 pos
%= GET_MODE_BITSIZE (wanted_mode
);
578 newmem
= gen_rtx_MEM (wanted_mode
,
579 plus_constant (XEXP (to
, 0), offset
));
580 MEM_COPY_ATTRIBUTES (newmem
, to
);
582 validate_change (object
, &XEXP (x
, 2), GEN_INT (pos
), 1);
583 validate_change (object
, &XEXP (x
, 0), newmem
, 1);
593 /* For commutative or comparison operations we've already performed
594 replacements. Don't try to perform them again. */
595 if (GET_RTX_CLASS (code
) != '<' && GET_RTX_CLASS (code
) != 'c')
597 fmt
= GET_RTX_FORMAT (code
);
598 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
601 validate_replace_rtx_1 (&XEXP (x
, i
), from
, to
, object
);
602 else if (fmt
[i
] == 'E')
603 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
604 validate_replace_rtx_1 (&XVECEXP (x
, i
, j
), from
, to
, object
);
609 /* Try replacing every occurrence of FROM in subexpression LOC of INSN
610 with TO. After all changes have been made, validate by seeing
611 if INSN is still valid. */
614 validate_replace_rtx_subexp (from
, to
, insn
, loc
)
615 rtx from
, to
, insn
, *loc
;
617 validate_replace_rtx_1 (loc
, from
, to
, insn
);
618 return apply_change_group ();
621 /* Try replacing every occurrence of FROM in INSN with TO. After all
622 changes have been made, validate by seeing if INSN is still valid. */
625 validate_replace_rtx (from
, to
, insn
)
628 validate_replace_rtx_1 (&PATTERN (insn
), from
, to
, insn
);
629 return apply_change_group ();
632 /* Try replacing every occurrence of FROM in INSN with TO. After all
633 changes have been made, validate by seeing if INSN is still valid. */
636 validate_replace_rtx_group (from
, to
, insn
)
639 validate_replace_rtx_1 (&PATTERN (insn
), from
, to
, insn
);
642 /* Try replacing every occurrence of FROM in INSN with TO, avoiding
643 SET_DESTs. After all changes have been made, validate by seeing if
644 INSN is still valid. */
647 validate_replace_src (from
, to
, insn
)
650 if ((GET_CODE (insn
) != INSN
&& GET_CODE (insn
) != JUMP_INSN
)
651 || GET_CODE (PATTERN (insn
)) != SET
)
654 validate_replace_rtx_1 (&SET_SRC (PATTERN (insn
)), from
, to
, insn
);
655 if (GET_CODE (SET_DEST (PATTERN (insn
))) == MEM
)
656 validate_replace_rtx_1 (&XEXP (SET_DEST (PATTERN (insn
)), 0),
658 return apply_change_group ();
662 /* Return 1 if the insn using CC0 set by INSN does not contain
663 any ordered tests applied to the condition codes.
664 EQ and NE tests do not count. */
667 next_insn_tests_no_inequality (insn
)
670 register rtx next
= next_cc0_user (insn
);
672 /* If there is no next insn, we have to take the conservative choice. */
676 return ((GET_CODE (next
) == JUMP_INSN
677 || GET_CODE (next
) == INSN
678 || GET_CODE (next
) == CALL_INSN
)
679 && ! inequality_comparisons_p (PATTERN (next
)));
682 #if 0 /* This is useless since the insn that sets the cc's
683 must be followed immediately by the use of them. */
684 /* Return 1 if the CC value set up by INSN is not used. */
687 next_insns_test_no_inequality (insn
)
690 register rtx next
= NEXT_INSN (insn
);
692 for (; next
!= 0; next
= NEXT_INSN (next
))
694 if (GET_CODE (next
) == CODE_LABEL
695 || GET_CODE (next
) == BARRIER
)
697 if (GET_CODE (next
) == NOTE
)
699 if (inequality_comparisons_p (PATTERN (next
)))
701 if (sets_cc0_p (PATTERN (next
)) == 1)
703 if (! reg_mentioned_p (cc0_rtx
, PATTERN (next
)))
711 /* This is used by find_single_use to locate an rtx that contains exactly one
712 use of DEST, which is typically either a REG or CC0. It returns a
713 pointer to the innermost rtx expression containing DEST. Appearances of
714 DEST that are being used to totally replace it are not counted. */
717 find_single_use_1 (dest
, loc
)
722 enum rtx_code code
= GET_CODE (x
);
739 /* If the destination is anything other than CC0, PC, a REG or a SUBREG
740 of a REG that occupies all of the REG, the insn uses DEST if
741 it is mentioned in the destination or the source. Otherwise, we
742 need just check the source. */
743 if (GET_CODE (SET_DEST (x
)) != CC0
744 && GET_CODE (SET_DEST (x
)) != PC
745 && GET_CODE (SET_DEST (x
)) != REG
746 && ! (GET_CODE (SET_DEST (x
)) == SUBREG
747 && GET_CODE (SUBREG_REG (SET_DEST (x
))) == REG
748 && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (x
))))
749 + (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
)
750 == ((GET_MODE_SIZE (GET_MODE (SET_DEST (x
)))
751 + (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
))))
754 return find_single_use_1 (dest
, &SET_SRC (x
));
758 return find_single_use_1 (dest
, &XEXP (x
, 0));
764 /* If it wasn't one of the common cases above, check each expression and
765 vector of this code. Look for a unique usage of DEST. */
767 fmt
= GET_RTX_FORMAT (code
);
768 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
772 if (dest
== XEXP (x
, i
)
773 || (GET_CODE (dest
) == REG
&& GET_CODE (XEXP (x
, i
)) == REG
774 && REGNO (dest
) == REGNO (XEXP (x
, i
))))
777 this_result
= find_single_use_1 (dest
, &XEXP (x
, i
));
780 result
= this_result
;
781 else if (this_result
)
782 /* Duplicate usage. */
785 else if (fmt
[i
] == 'E')
789 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
791 if (XVECEXP (x
, i
, j
) == dest
792 || (GET_CODE (dest
) == REG
793 && GET_CODE (XVECEXP (x
, i
, j
)) == REG
794 && REGNO (XVECEXP (x
, i
, j
)) == REGNO (dest
)))
797 this_result
= find_single_use_1 (dest
, &XVECEXP (x
, i
, j
));
800 result
= this_result
;
801 else if (this_result
)
810 /* See if DEST, produced in INSN, is used only a single time in the
811 sequel. If so, return a pointer to the innermost rtx expression in which
814 If PLOC is non-zero, *PLOC is set to the insn containing the single use.
816 This routine will return usually zero either before flow is called (because
817 there will be no LOG_LINKS notes) or after reload (because the REG_DEAD
818 note can't be trusted).
820 If DEST is cc0_rtx, we look only at the next insn. In that case, we don't
821 care about REG_DEAD notes or LOG_LINKS.
823 Otherwise, we find the single use by finding an insn that has a
824 LOG_LINKS pointing at INSN and has a REG_DEAD note for DEST. If DEST is
825 only referenced once in that insn, we know that it must be the first
826 and last insn referencing DEST. */
829 find_single_use (dest
, insn
, ploc
)
841 next
= NEXT_INSN (insn
);
843 || (GET_CODE (next
) != INSN
&& GET_CODE (next
) != JUMP_INSN
))
846 result
= find_single_use_1 (dest
, &PATTERN (next
));
853 if (reload_completed
|| reload_in_progress
|| GET_CODE (dest
) != REG
)
856 for (next
= next_nonnote_insn (insn
);
857 next
!= 0 && GET_CODE (next
) != CODE_LABEL
;
858 next
= next_nonnote_insn (next
))
859 if (INSN_P (next
) && dead_or_set_p (next
, dest
))
861 for (link
= LOG_LINKS (next
); link
; link
= XEXP (link
, 1))
862 if (XEXP (link
, 0) == insn
)
867 result
= find_single_use_1 (dest
, &PATTERN (next
));
877 /* Return 1 if OP is a valid general operand for machine mode MODE.
878 This is either a register reference, a memory reference,
879 or a constant. In the case of a memory reference, the address
880 is checked for general validity for the target machine.
882 Register and memory references must have mode MODE in order to be valid,
883 but some constants have no machine mode and are valid for any mode.
885 If MODE is VOIDmode, OP is checked for validity for whatever mode
888 The main use of this function is as a predicate in match_operand
889 expressions in the machine description.
891 For an explanation of this function's behavior for registers of
892 class NO_REGS, see the comment for `register_operand'. */
895 general_operand (op
, mode
)
897 enum machine_mode mode
;
899 register enum rtx_code code
= GET_CODE (op
);
900 int mode_altering_drug
= 0;
902 if (mode
== VOIDmode
)
903 mode
= GET_MODE (op
);
905 /* Don't accept CONST_INT or anything similar
906 if the caller wants something floating. */
907 if (GET_MODE (op
) == VOIDmode
&& mode
!= VOIDmode
908 && GET_MODE_CLASS (mode
) != MODE_INT
909 && GET_MODE_CLASS (mode
) != MODE_PARTIAL_INT
)
913 return ((GET_MODE (op
) == VOIDmode
|| GET_MODE (op
) == mode
915 #ifdef LEGITIMATE_PIC_OPERAND_P
916 && (! flag_pic
|| LEGITIMATE_PIC_OPERAND_P (op
))
918 && LEGITIMATE_CONSTANT_P (op
));
920 /* Except for certain constants with VOIDmode, already checked for,
921 OP's mode must match MODE if MODE specifies a mode. */
923 if (GET_MODE (op
) != mode
)
928 #ifdef INSN_SCHEDULING
929 /* On machines that have insn scheduling, we want all memory
930 reference to be explicit, so outlaw paradoxical SUBREGs. */
931 if (GET_CODE (SUBREG_REG (op
)) == MEM
932 && GET_MODE_SIZE (mode
) > GET_MODE_SIZE (GET_MODE (SUBREG_REG (op
))))
936 op
= SUBREG_REG (op
);
937 code
= GET_CODE (op
);
939 /* No longer needed, since (SUBREG (MEM...))
940 will load the MEM into a reload reg in the MEM's own mode. */
941 mode_altering_drug
= 1;
946 /* A register whose class is NO_REGS is not a general operand. */
947 return (REGNO (op
) >= FIRST_PSEUDO_REGISTER
948 || REGNO_REG_CLASS (REGNO (op
)) != NO_REGS
);
952 register rtx y
= XEXP (op
, 0);
954 if (! volatile_ok
&& MEM_VOLATILE_P (op
))
957 if (GET_CODE (y
) == ADDRESSOF
)
960 /* Use the mem's mode, since it will be reloaded thus. */
961 mode
= GET_MODE (op
);
962 GO_IF_LEGITIMATE_ADDRESS (mode
, y
, win
);
965 /* Pretend this is an operand for now; we'll run force_operand
966 on its replacement in fixup_var_refs_1. */
967 if (code
== ADDRESSOF
)
973 if (mode_altering_drug
)
974 return ! mode_dependent_address_p (XEXP (op
, 0));
978 /* Return 1 if OP is a valid memory address for a memory reference
981 The main use of this function is as a predicate in match_operand
982 expressions in the machine description. */
985 address_operand (op
, mode
)
987 enum machine_mode mode
;
989 return memory_address_p (mode
, op
);
992 /* Return 1 if OP is a register reference of mode MODE.
993 If MODE is VOIDmode, accept a register in any mode.
995 The main use of this function is as a predicate in match_operand
996 expressions in the machine description.
998 As a special exception, registers whose class is NO_REGS are
999 not accepted by `register_operand'. The reason for this change
1000 is to allow the representation of special architecture artifacts
1001 (such as a condition code register) without extending the rtl
1002 definitions. Since registers of class NO_REGS cannot be used
1003 as registers in any case where register classes are examined,
1004 it is most consistent to keep this function from accepting them. */
1007 register_operand (op
, mode
)
1009 enum machine_mode mode
;
1011 if (GET_MODE (op
) != mode
&& mode
!= VOIDmode
)
1014 if (GET_CODE (op
) == SUBREG
)
1016 /* Before reload, we can allow (SUBREG (MEM...)) as a register operand
1017 because it is guaranteed to be reloaded into one.
1018 Just make sure the MEM is valid in itself.
1019 (Ideally, (SUBREG (MEM)...) should not exist after reload,
1020 but currently it does result from (SUBREG (REG)...) where the
1021 reg went on the stack.) */
1022 if (! reload_completed
&& GET_CODE (SUBREG_REG (op
)) == MEM
)
1023 return general_operand (op
, mode
);
1025 #ifdef CLASS_CANNOT_CHANGE_MODE
1026 if (GET_CODE (SUBREG_REG (op
)) == REG
1027 && REGNO (SUBREG_REG (op
)) < FIRST_PSEUDO_REGISTER
1028 && (TEST_HARD_REG_BIT
1029 (reg_class_contents
[(int) CLASS_CANNOT_CHANGE_MODE
],
1030 REGNO (SUBREG_REG (op
))))
1031 && CLASS_CANNOT_CHANGE_MODE_P (mode
, GET_MODE (SUBREG_REG (op
)))
1032 && GET_MODE_CLASS (GET_MODE (SUBREG_REG (op
))) != MODE_COMPLEX_INT
1033 && GET_MODE_CLASS (GET_MODE (SUBREG_REG (op
))) != MODE_COMPLEX_FLOAT
)
1037 op
= SUBREG_REG (op
);
1040 /* If we have an ADDRESSOF, consider it valid since it will be
1041 converted into something that will not be a MEM. */
1042 if (GET_CODE (op
) == ADDRESSOF
)
1045 /* We don't consider registers whose class is NO_REGS
1046 to be a register operand. */
1047 return (GET_CODE (op
) == REG
1048 && (REGNO (op
) >= FIRST_PSEUDO_REGISTER
1049 || REGNO_REG_CLASS (REGNO (op
)) != NO_REGS
));
1052 /* Return 1 for a register in Pmode; ignore the tested mode. */
1055 pmode_register_operand (op
, mode
)
1057 enum machine_mode mode ATTRIBUTE_UNUSED
;
1059 return register_operand (op
, Pmode
);
1062 /* Return 1 if OP should match a MATCH_SCRATCH, i.e., if it is a SCRATCH
1063 or a hard register. */
1066 scratch_operand (op
, mode
)
1068 enum machine_mode mode
;
1070 if (GET_MODE (op
) != mode
&& mode
!= VOIDmode
)
1073 return (GET_CODE (op
) == SCRATCH
1074 || (GET_CODE (op
) == REG
1075 && REGNO (op
) < FIRST_PSEUDO_REGISTER
));
1078 /* Return 1 if OP is a valid immediate operand for mode MODE.
1080 The main use of this function is as a predicate in match_operand
1081 expressions in the machine description. */
1084 immediate_operand (op
, mode
)
1086 enum machine_mode mode
;
1088 /* Don't accept CONST_INT or anything similar
1089 if the caller wants something floating. */
1090 if (GET_MODE (op
) == VOIDmode
&& mode
!= VOIDmode
1091 && GET_MODE_CLASS (mode
) != MODE_INT
1092 && GET_MODE_CLASS (mode
) != MODE_PARTIAL_INT
)
1095 /* Accept CONSTANT_P_RTX, since it will be gone by CSE1 and
1096 result in 0/1. It seems a safe assumption that this is
1097 in range for everyone. */
1098 if (GET_CODE (op
) == CONSTANT_P_RTX
)
1101 return (CONSTANT_P (op
)
1102 && (GET_MODE (op
) == mode
|| mode
== VOIDmode
1103 || GET_MODE (op
) == VOIDmode
)
1104 #ifdef LEGITIMATE_PIC_OPERAND_P
1105 && (! flag_pic
|| LEGITIMATE_PIC_OPERAND_P (op
))
1107 && LEGITIMATE_CONSTANT_P (op
));
1110 /* Returns 1 if OP is an operand that is a CONST_INT. */
1113 const_int_operand (op
, mode
)
1115 enum machine_mode mode ATTRIBUTE_UNUSED
;
1117 return GET_CODE (op
) == CONST_INT
;
1120 /* Returns 1 if OP is an operand that is a constant integer or constant
1121 floating-point number. */
1124 const_double_operand (op
, mode
)
1126 enum machine_mode mode
;
1128 /* Don't accept CONST_INT or anything similar
1129 if the caller wants something floating. */
1130 if (GET_MODE (op
) == VOIDmode
&& mode
!= VOIDmode
1131 && GET_MODE_CLASS (mode
) != MODE_INT
1132 && GET_MODE_CLASS (mode
) != MODE_PARTIAL_INT
)
1135 return ((GET_CODE (op
) == CONST_DOUBLE
|| GET_CODE (op
) == CONST_INT
)
1136 && (mode
== VOIDmode
|| GET_MODE (op
) == mode
1137 || GET_MODE (op
) == VOIDmode
));
1140 /* Return 1 if OP is a general operand that is not an immediate operand. */
1143 nonimmediate_operand (op
, mode
)
1145 enum machine_mode mode
;
1147 return (general_operand (op
, mode
) && ! CONSTANT_P (op
));
1150 /* Return 1 if OP is a register reference or immediate value of mode MODE. */
1153 nonmemory_operand (op
, mode
)
1155 enum machine_mode mode
;
1157 if (CONSTANT_P (op
))
1159 /* Don't accept CONST_INT or anything similar
1160 if the caller wants something floating. */
1161 if (GET_MODE (op
) == VOIDmode
&& mode
!= VOIDmode
1162 && GET_MODE_CLASS (mode
) != MODE_INT
1163 && GET_MODE_CLASS (mode
) != MODE_PARTIAL_INT
)
1166 return ((GET_MODE (op
) == VOIDmode
|| GET_MODE (op
) == mode
1167 || mode
== VOIDmode
)
1168 #ifdef LEGITIMATE_PIC_OPERAND_P
1169 && (! flag_pic
|| LEGITIMATE_PIC_OPERAND_P (op
))
1171 && LEGITIMATE_CONSTANT_P (op
));
1174 if (GET_MODE (op
) != mode
&& mode
!= VOIDmode
)
1177 if (GET_CODE (op
) == SUBREG
)
1179 /* Before reload, we can allow (SUBREG (MEM...)) as a register operand
1180 because it is guaranteed to be reloaded into one.
1181 Just make sure the MEM is valid in itself.
1182 (Ideally, (SUBREG (MEM)...) should not exist after reload,
1183 but currently it does result from (SUBREG (REG)...) where the
1184 reg went on the stack.) */
1185 if (! reload_completed
&& GET_CODE (SUBREG_REG (op
)) == MEM
)
1186 return general_operand (op
, mode
);
1187 op
= SUBREG_REG (op
);
1190 /* We don't consider registers whose class is NO_REGS
1191 to be a register operand. */
1192 return (GET_CODE (op
) == REG
1193 && (REGNO (op
) >= FIRST_PSEUDO_REGISTER
1194 || REGNO_REG_CLASS (REGNO (op
)) != NO_REGS
));
1197 /* Return 1 if OP is a valid operand that stands for pushing a
1198 value of mode MODE onto the stack.
1200 The main use of this function is as a predicate in match_operand
1201 expressions in the machine description. */
1204 push_operand (op
, mode
)
1206 enum machine_mode mode
;
1208 if (GET_CODE (op
) != MEM
)
1211 if (mode
!= VOIDmode
&& GET_MODE (op
) != mode
)
1216 if (GET_CODE (op
) != STACK_PUSH_CODE
)
1219 return XEXP (op
, 0) == stack_pointer_rtx
;
1222 /* Return 1 if OP is a valid operand that stands for popping a
1223 value of mode MODE off the stack.
1225 The main use of this function is as a predicate in match_operand
1226 expressions in the machine description. */
1229 pop_operand (op
, mode
)
1231 enum machine_mode mode
;
1233 if (GET_CODE (op
) != MEM
)
1236 if (mode
!= VOIDmode
&& GET_MODE (op
) != mode
)
1241 if (GET_CODE (op
) != STACK_POP_CODE
)
1244 return XEXP (op
, 0) == stack_pointer_rtx
;
1247 /* Return 1 if ADDR is a valid memory address for mode MODE. */
1250 memory_address_p (mode
, addr
)
1251 enum machine_mode mode ATTRIBUTE_UNUSED
;
1254 if (GET_CODE (addr
) == ADDRESSOF
)
1257 GO_IF_LEGITIMATE_ADDRESS (mode
, addr
, win
);
1264 /* Return 1 if OP is a valid memory reference with mode MODE,
1265 including a valid address.
1267 The main use of this function is as a predicate in match_operand
1268 expressions in the machine description. */
1271 memory_operand (op
, mode
)
1273 enum machine_mode mode
;
1277 if (! reload_completed
)
1278 /* Note that no SUBREG is a memory operand before end of reload pass,
1279 because (SUBREG (MEM...)) forces reloading into a register. */
1280 return GET_CODE (op
) == MEM
&& general_operand (op
, mode
);
1282 if (mode
!= VOIDmode
&& GET_MODE (op
) != mode
)
1286 if (GET_CODE (inner
) == SUBREG
)
1287 inner
= SUBREG_REG (inner
);
1289 return (GET_CODE (inner
) == MEM
&& general_operand (op
, mode
));
1292 /* Return 1 if OP is a valid indirect memory reference with mode MODE;
1293 that is, a memory reference whose address is a general_operand. */
1296 indirect_operand (op
, mode
)
1298 enum machine_mode mode
;
1300 /* Before reload, a SUBREG isn't in memory (see memory_operand, above). */
1301 if (! reload_completed
1302 && GET_CODE (op
) == SUBREG
&& GET_CODE (SUBREG_REG (op
)) == MEM
)
1304 register int offset
= SUBREG_WORD (op
) * UNITS_PER_WORD
;
1305 rtx inner
= SUBREG_REG (op
);
1307 if (BYTES_BIG_ENDIAN
)
1308 offset
-= (MIN (UNITS_PER_WORD
, GET_MODE_SIZE (GET_MODE (op
)))
1309 - MIN (UNITS_PER_WORD
, GET_MODE_SIZE (GET_MODE (inner
))));
1311 if (mode
!= VOIDmode
&& GET_MODE (op
) != mode
)
1314 /* The only way that we can have a general_operand as the resulting
1315 address is if OFFSET is zero and the address already is an operand
1316 or if the address is (plus Y (const_int -OFFSET)) and Y is an
1319 return ((offset
== 0 && general_operand (XEXP (inner
, 0), Pmode
))
1320 || (GET_CODE (XEXP (inner
, 0)) == PLUS
1321 && GET_CODE (XEXP (XEXP (inner
, 0), 1)) == CONST_INT
1322 && INTVAL (XEXP (XEXP (inner
, 0), 1)) == -offset
1323 && general_operand (XEXP (XEXP (inner
, 0), 0), Pmode
)));
1326 return (GET_CODE (op
) == MEM
1327 && memory_operand (op
, mode
)
1328 && general_operand (XEXP (op
, 0), Pmode
));
1331 /* Return 1 if this is a comparison operator. This allows the use of
1332 MATCH_OPERATOR to recognize all the branch insns. */
1335 comparison_operator (op
, mode
)
1337 enum machine_mode mode
;
1339 return ((mode
== VOIDmode
|| GET_MODE (op
) == mode
)
1340 && GET_RTX_CLASS (GET_CODE (op
)) == '<');
1343 /* If BODY is an insn body that uses ASM_OPERANDS,
1344 return the number of operands (both input and output) in the insn.
1345 Otherwise return -1. */
1348 asm_noperands (body
)
1351 if (GET_CODE (body
) == ASM_OPERANDS
)
1352 /* No output operands: return number of input operands. */
1353 return ASM_OPERANDS_INPUT_LENGTH (body
);
1354 if (GET_CODE (body
) == SET
&& GET_CODE (SET_SRC (body
)) == ASM_OPERANDS
)
1355 /* Single output operand: BODY is (set OUTPUT (asm_operands ...)). */
1356 return ASM_OPERANDS_INPUT_LENGTH (SET_SRC (body
)) + 1;
1357 else if (GET_CODE (body
) == PARALLEL
1358 && GET_CODE (XVECEXP (body
, 0, 0)) == SET
1359 && GET_CODE (SET_SRC (XVECEXP (body
, 0, 0))) == ASM_OPERANDS
)
1361 /* Multiple output operands, or 1 output plus some clobbers:
1362 body is [(set OUTPUT (asm_operands ...))... (clobber (reg ...))...]. */
1366 /* Count backwards through CLOBBERs to determine number of SETs. */
1367 for (i
= XVECLEN (body
, 0); i
> 0; i
--)
1369 if (GET_CODE (XVECEXP (body
, 0, i
- 1)) == SET
)
1371 if (GET_CODE (XVECEXP (body
, 0, i
- 1)) != CLOBBER
)
1375 /* N_SETS is now number of output operands. */
1378 /* Verify that all the SETs we have
1379 came from a single original asm_operands insn
1380 (so that invalid combinations are blocked). */
1381 for (i
= 0; i
< n_sets
; i
++)
1383 rtx elt
= XVECEXP (body
, 0, i
);
1384 if (GET_CODE (elt
) != SET
)
1386 if (GET_CODE (SET_SRC (elt
)) != ASM_OPERANDS
)
1388 /* If these ASM_OPERANDS rtx's came from different original insns
1389 then they aren't allowed together. */
1390 if (ASM_OPERANDS_INPUT_VEC (SET_SRC (elt
))
1391 != ASM_OPERANDS_INPUT_VEC (SET_SRC (XVECEXP (body
, 0, 0))))
1394 return (ASM_OPERANDS_INPUT_LENGTH (SET_SRC (XVECEXP (body
, 0, 0)))
1397 else if (GET_CODE (body
) == PARALLEL
1398 && GET_CODE (XVECEXP (body
, 0, 0)) == ASM_OPERANDS
)
1400 /* 0 outputs, but some clobbers:
1401 body is [(asm_operands ...) (clobber (reg ...))...]. */
1404 /* Make sure all the other parallel things really are clobbers. */
1405 for (i
= XVECLEN (body
, 0) - 1; i
> 0; i
--)
1406 if (GET_CODE (XVECEXP (body
, 0, i
)) != CLOBBER
)
1409 return ASM_OPERANDS_INPUT_LENGTH (XVECEXP (body
, 0, 0));
1415 /* Assuming BODY is an insn body that uses ASM_OPERANDS,
1416 copy its operands (both input and output) into the vector OPERANDS,
1417 the locations of the operands within the insn into the vector OPERAND_LOCS,
1418 and the constraints for the operands into CONSTRAINTS.
1419 Write the modes of the operands into MODES.
1420 Return the assembler-template.
1422 If MODES, OPERAND_LOCS, CONSTRAINTS or OPERANDS is 0,
1423 we don't store that info. */
1426 decode_asm_operands (body
, operands
, operand_locs
, constraints
, modes
)
1430 const char **constraints
;
1431 enum machine_mode
*modes
;
1435 const char *template = 0;
1437 if (GET_CODE (body
) == SET
&& GET_CODE (SET_SRC (body
)) == ASM_OPERANDS
)
1439 rtx asmop
= SET_SRC (body
);
1440 /* Single output operand: BODY is (set OUTPUT (asm_operands ....)). */
1442 noperands
= ASM_OPERANDS_INPUT_LENGTH (asmop
) + 1;
1444 for (i
= 1; i
< noperands
; i
++)
1447 operand_locs
[i
] = &ASM_OPERANDS_INPUT (asmop
, i
- 1);
1449 operands
[i
] = ASM_OPERANDS_INPUT (asmop
, i
- 1);
1451 constraints
[i
] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop
, i
- 1);
1453 modes
[i
] = ASM_OPERANDS_INPUT_MODE (asmop
, i
- 1);
1456 /* The output is in the SET.
1457 Its constraint is in the ASM_OPERANDS itself. */
1459 operands
[0] = SET_DEST (body
);
1461 operand_locs
[0] = &SET_DEST (body
);
1463 constraints
[0] = ASM_OPERANDS_OUTPUT_CONSTRAINT (asmop
);
1465 modes
[0] = GET_MODE (SET_DEST (body
));
1466 template = ASM_OPERANDS_TEMPLATE (asmop
);
1468 else if (GET_CODE (body
) == ASM_OPERANDS
)
1471 /* No output operands: BODY is (asm_operands ....). */
1473 noperands
= ASM_OPERANDS_INPUT_LENGTH (asmop
);
1475 /* The input operands are found in the 1st element vector. */
1476 /* Constraints for inputs are in the 2nd element vector. */
1477 for (i
= 0; i
< noperands
; i
++)
1480 operand_locs
[i
] = &ASM_OPERANDS_INPUT (asmop
, i
);
1482 operands
[i
] = ASM_OPERANDS_INPUT (asmop
, i
);
1484 constraints
[i
] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop
, i
);
1486 modes
[i
] = ASM_OPERANDS_INPUT_MODE (asmop
, i
);
1488 template = ASM_OPERANDS_TEMPLATE (asmop
);
1490 else if (GET_CODE (body
) == PARALLEL
1491 && GET_CODE (XVECEXP (body
, 0, 0)) == SET
)
1493 rtx asmop
= SET_SRC (XVECEXP (body
, 0, 0));
1494 int nparallel
= XVECLEN (body
, 0); /* Includes CLOBBERs. */
1495 int nin
= ASM_OPERANDS_INPUT_LENGTH (asmop
);
1496 int nout
= 0; /* Does not include CLOBBERs. */
1498 /* At least one output, plus some CLOBBERs. */
1500 /* The outputs are in the SETs.
1501 Their constraints are in the ASM_OPERANDS itself. */
1502 for (i
= 0; i
< nparallel
; i
++)
1504 if (GET_CODE (XVECEXP (body
, 0, i
)) == CLOBBER
)
1505 break; /* Past last SET */
1508 operands
[i
] = SET_DEST (XVECEXP (body
, 0, i
));
1510 operand_locs
[i
] = &SET_DEST (XVECEXP (body
, 0, i
));
1512 constraints
[i
] = XSTR (SET_SRC (XVECEXP (body
, 0, i
)), 1);
1514 modes
[i
] = GET_MODE (SET_DEST (XVECEXP (body
, 0, i
)));
1518 for (i
= 0; i
< nin
; i
++)
1521 operand_locs
[i
+ nout
] = &ASM_OPERANDS_INPUT (asmop
, i
);
1523 operands
[i
+ nout
] = ASM_OPERANDS_INPUT (asmop
, i
);
1525 constraints
[i
+ nout
] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop
, i
);
1527 modes
[i
+ nout
] = ASM_OPERANDS_INPUT_MODE (asmop
, i
);
1530 template = ASM_OPERANDS_TEMPLATE (asmop
);
1532 else if (GET_CODE (body
) == PARALLEL
1533 && GET_CODE (XVECEXP (body
, 0, 0)) == ASM_OPERANDS
)
1535 /* No outputs, but some CLOBBERs. */
1537 rtx asmop
= XVECEXP (body
, 0, 0);
1538 int nin
= ASM_OPERANDS_INPUT_LENGTH (asmop
);
1540 for (i
= 0; i
< nin
; i
++)
1543 operand_locs
[i
] = &ASM_OPERANDS_INPUT (asmop
, i
);
1545 operands
[i
] = ASM_OPERANDS_INPUT (asmop
, i
);
1547 constraints
[i
] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop
, i
);
1549 modes
[i
] = ASM_OPERANDS_INPUT_MODE (asmop
, i
);
1552 template = ASM_OPERANDS_TEMPLATE (asmop
);
1558 /* Check if an asm_operand matches it's constraints.
1559 Return > 0 if ok, = 0 if bad, < 0 if inconclusive. */
1562 asm_operand_ok (op
, constraint
)
1564 const char *constraint
;
1568 /* Use constrain_operands after reload. */
1569 if (reload_completed
)
1574 switch (*constraint
++)
1587 case '0': case '1': case '2': case '3': case '4':
1588 case '5': case '6': case '7': case '8': case '9':
1589 /* For best results, our caller should have given us the
1590 proper matching constraint, but we can't actually fail
1591 the check if they didn't. Indicate that results are
1597 if (address_operand (op
, VOIDmode
))
1602 case 'V': /* non-offsettable */
1603 if (memory_operand (op
, VOIDmode
))
1607 case 'o': /* offsettable */
1608 if (offsettable_nonstrict_memref_p (op
))
1613 /* ??? Before flow, auto inc/dec insns are not supposed to exist,
1614 excepting those that expand_call created. Further, on some
1615 machines which do not have generalized auto inc/dec, an inc/dec
1616 is not a memory_operand.
1618 Match any memory and hope things are resolved after reload. */
1620 if (GET_CODE (op
) == MEM
1622 || GET_CODE (XEXP (op
, 0)) == PRE_DEC
1623 || GET_CODE (XEXP (op
, 0)) == POST_DEC
))
1628 if (GET_CODE (op
) == MEM
1630 || GET_CODE (XEXP (op
, 0)) == PRE_INC
1631 || GET_CODE (XEXP (op
, 0)) == POST_INC
))
1636 #ifndef REAL_ARITHMETIC
1637 /* Match any floating double constant, but only if
1638 we can examine the bits of it reliably. */
1639 if ((HOST_FLOAT_FORMAT
!= TARGET_FLOAT_FORMAT
1640 || HOST_BITS_PER_WIDE_INT
!= BITS_PER_WORD
)
1641 && GET_MODE (op
) != VOIDmode
&& ! flag_pretend_float
)
1647 if (GET_CODE (op
) == CONST_DOUBLE
)
1652 if (GET_CODE (op
) == CONST_DOUBLE
1653 && CONST_DOUBLE_OK_FOR_LETTER_P (op
, 'G'))
1657 if (GET_CODE (op
) == CONST_DOUBLE
1658 && CONST_DOUBLE_OK_FOR_LETTER_P (op
, 'H'))
1663 if (GET_CODE (op
) == CONST_INT
1664 || (GET_CODE (op
) == CONST_DOUBLE
1665 && GET_MODE (op
) == VOIDmode
))
1671 #ifdef LEGITIMATE_PIC_OPERAND_P
1672 && (! flag_pic
|| LEGITIMATE_PIC_OPERAND_P (op
))
1679 if (GET_CODE (op
) == CONST_INT
1680 || (GET_CODE (op
) == CONST_DOUBLE
1681 && GET_MODE (op
) == VOIDmode
))
1686 if (GET_CODE (op
) == CONST_INT
1687 && CONST_OK_FOR_LETTER_P (INTVAL (op
), 'I'))
1691 if (GET_CODE (op
) == CONST_INT
1692 && CONST_OK_FOR_LETTER_P (INTVAL (op
), 'J'))
1696 if (GET_CODE (op
) == CONST_INT
1697 && CONST_OK_FOR_LETTER_P (INTVAL (op
), 'K'))
1701 if (GET_CODE (op
) == CONST_INT
1702 && CONST_OK_FOR_LETTER_P (INTVAL (op
), 'L'))
1706 if (GET_CODE (op
) == CONST_INT
1707 && CONST_OK_FOR_LETTER_P (INTVAL (op
), 'M'))
1711 if (GET_CODE (op
) == CONST_INT
1712 && CONST_OK_FOR_LETTER_P (INTVAL (op
), 'N'))
1716 if (GET_CODE (op
) == CONST_INT
1717 && CONST_OK_FOR_LETTER_P (INTVAL (op
), 'O'))
1721 if (GET_CODE (op
) == CONST_INT
1722 && CONST_OK_FOR_LETTER_P (INTVAL (op
), 'P'))
1730 if (general_operand (op
, VOIDmode
))
1734 #ifdef EXTRA_CONSTRAINT
1736 if (EXTRA_CONSTRAINT (op
, 'Q'))
1740 if (EXTRA_CONSTRAINT (op
, 'R'))
1744 if (EXTRA_CONSTRAINT (op
, 'S'))
1748 if (EXTRA_CONSTRAINT (op
, 'T'))
1752 if (EXTRA_CONSTRAINT (op
, 'U'))
1759 if (GET_MODE (op
) == BLKmode
)
1761 if (register_operand (op
, VOIDmode
))
1770 /* Given an rtx *P, if it is a sum containing an integer constant term,
1771 return the location (type rtx *) of the pointer to that constant term.
1772 Otherwise, return a null pointer. */
1775 find_constant_term_loc (p
)
1779 register enum rtx_code code
= GET_CODE (*p
);
1781 /* If *P IS such a constant term, P is its location. */
1783 if (code
== CONST_INT
|| code
== SYMBOL_REF
|| code
== LABEL_REF
1787 /* Otherwise, if not a sum, it has no constant term. */
1789 if (GET_CODE (*p
) != PLUS
)
1792 /* If one of the summands is constant, return its location. */
1794 if (XEXP (*p
, 0) && CONSTANT_P (XEXP (*p
, 0))
1795 && XEXP (*p
, 1) && CONSTANT_P (XEXP (*p
, 1)))
1798 /* Otherwise, check each summand for containing a constant term. */
1800 if (XEXP (*p
, 0) != 0)
1802 tem
= find_constant_term_loc (&XEXP (*p
, 0));
1807 if (XEXP (*p
, 1) != 0)
1809 tem
= find_constant_term_loc (&XEXP (*p
, 1));
1817 /* Return 1 if OP is a memory reference
1818 whose address contains no side effects
1819 and remains valid after the addition
1820 of a positive integer less than the
1821 size of the object being referenced.
1823 We assume that the original address is valid and do not check it.
1825 This uses strict_memory_address_p as a subroutine, so
1826 don't use it before reload. */
1829 offsettable_memref_p (op
)
1832 return ((GET_CODE (op
) == MEM
)
1833 && offsettable_address_p (1, GET_MODE (op
), XEXP (op
, 0)));
1836 /* Similar, but don't require a strictly valid mem ref:
1837 consider pseudo-regs valid as index or base regs. */
1840 offsettable_nonstrict_memref_p (op
)
1843 return ((GET_CODE (op
) == MEM
)
1844 && offsettable_address_p (0, GET_MODE (op
), XEXP (op
, 0)));
1847 /* Return 1 if Y is a memory address which contains no side effects
1848 and would remain valid after the addition of a positive integer
1849 less than the size of that mode.
1851 We assume that the original address is valid and do not check it.
1852 We do check that it is valid for narrower modes.
1854 If STRICTP is nonzero, we require a strictly valid address,
1855 for the sake of use in reload.c. */
1858 offsettable_address_p (strictp
, mode
, y
)
1860 enum machine_mode mode
;
1863 register enum rtx_code ycode
= GET_CODE (y
);
1867 int (*addressp
) PARAMS ((enum machine_mode
, rtx
)) =
1868 (strictp
? strict_memory_address_p
: memory_address_p
);
1869 unsigned int mode_sz
= GET_MODE_SIZE (mode
);
1871 if (CONSTANT_ADDRESS_P (y
))
1874 /* Adjusting an offsettable address involves changing to a narrower mode.
1875 Make sure that's OK. */
1877 if (mode_dependent_address_p (y
))
1880 /* ??? How much offset does an offsettable BLKmode reference need?
1881 Clearly that depends on the situation in which it's being used.
1882 However, the current situation in which we test 0xffffffff is
1883 less than ideal. Caveat user. */
1885 mode_sz
= BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
;
1887 /* If the expression contains a constant term,
1888 see if it remains valid when max possible offset is added. */
1890 if ((ycode
== PLUS
) && (y2
= find_constant_term_loc (&y1
)))
1895 *y2
= plus_constant (*y2
, mode_sz
- 1);
1896 /* Use QImode because an odd displacement may be automatically invalid
1897 for any wider mode. But it should be valid for a single byte. */
1898 good
= (*addressp
) (QImode
, y
);
1900 /* In any case, restore old contents of memory. */
1905 if (GET_RTX_CLASS (ycode
) == 'a')
1908 /* The offset added here is chosen as the maximum offset that
1909 any instruction could need to add when operating on something
1910 of the specified mode. We assume that if Y and Y+c are
1911 valid addresses then so is Y+d for all 0<d<c. */
1913 z
= plus_constant_for_output (y
, mode_sz
- 1);
1915 /* Use QImode because an odd displacement may be automatically invalid
1916 for any wider mode. But it should be valid for a single byte. */
1917 return (*addressp
) (QImode
, z
);
1920 /* Return 1 if ADDR is an address-expression whose effect depends
1921 on the mode of the memory reference it is used in.
1923 Autoincrement addressing is a typical example of mode-dependence
1924 because the amount of the increment depends on the mode. */
1927 mode_dependent_address_p (addr
)
1928 rtx addr ATTRIBUTE_UNUSED
; /* Maybe used in GO_IF_MODE_DEPENDENT_ADDRESS. */
1930 GO_IF_MODE_DEPENDENT_ADDRESS (addr
, win
);
1932 /* Label `win' might (not) be used via GO_IF_MODE_DEPENDENT_ADDRESS. */
1933 win
: ATTRIBUTE_UNUSED_LABEL
1937 /* Return 1 if OP is a general operand
1938 other than a memory ref with a mode dependent address. */
1941 mode_independent_operand (op
, mode
)
1942 enum machine_mode mode
;
1947 if (! general_operand (op
, mode
))
1950 if (GET_CODE (op
) != MEM
)
1953 addr
= XEXP (op
, 0);
1954 GO_IF_MODE_DEPENDENT_ADDRESS (addr
, lose
);
1956 /* Label `lose' might (not) be used via GO_IF_MODE_DEPENDENT_ADDRESS. */
1957 lose
: ATTRIBUTE_UNUSED_LABEL
1961 /* Given an operand OP that is a valid memory reference which
1962 satisfies offsettable_memref_p, return a new memory reference whose
1963 address has been adjusted by OFFSET. OFFSET should be positive and
1964 less than the size of the object referenced. */
1967 adj_offsettable_operand (op
, offset
)
1971 register enum rtx_code code
= GET_CODE (op
);
1975 register rtx y
= XEXP (op
, 0);
1978 if (CONSTANT_ADDRESS_P (y
))
1980 new = gen_rtx_MEM (GET_MODE (op
),
1981 plus_constant_for_output (y
, offset
));
1982 MEM_COPY_ATTRIBUTES (new, op
);
1986 if (GET_CODE (y
) == PLUS
)
1989 register rtx
*const_loc
;
1993 const_loc
= find_constant_term_loc (&z
);
1996 *const_loc
= plus_constant_for_output (*const_loc
, offset
);
2001 new = gen_rtx_MEM (GET_MODE (op
), plus_constant_for_output (y
, offset
));
2002 MEM_COPY_ATTRIBUTES (new, op
);
2008 /* Analyze INSN and fill in recog_data. */
2017 rtx body
= PATTERN (insn
);
2019 recog_data
.n_operands
= 0;
2020 recog_data
.n_alternatives
= 0;
2021 recog_data
.n_dups
= 0;
2023 switch (GET_CODE (body
))
2035 recog_data
.n_operands
= noperands
= asm_noperands (body
);
2038 /* This insn is an `asm' with operands. */
2040 /* expand_asm_operands makes sure there aren't too many operands. */
2041 if (noperands
> MAX_RECOG_OPERANDS
)
2044 /* Now get the operand values and constraints out of the insn. */
2045 decode_asm_operands (body
, recog_data
.operand
,
2046 recog_data
.operand_loc
,
2047 recog_data
.constraints
,
2048 recog_data
.operand_mode
);
2051 const char *p
= recog_data
.constraints
[0];
2052 recog_data
.n_alternatives
= 1;
2054 recog_data
.n_alternatives
+= (*p
++ == ',');
2062 /* Ordinary insn: recognize it, get the operands via insn_extract
2063 and get the constraints. */
2065 icode
= recog_memoized (insn
);
2067 fatal_insn_not_found (insn
);
2069 recog_data
.n_operands
= noperands
= insn_data
[icode
].n_operands
;
2070 recog_data
.n_alternatives
= insn_data
[icode
].n_alternatives
;
2071 recog_data
.n_dups
= insn_data
[icode
].n_dups
;
2073 insn_extract (insn
);
2075 for (i
= 0; i
< noperands
; i
++)
2077 recog_data
.constraints
[i
] = insn_data
[icode
].operand
[i
].constraint
;
2078 recog_data
.operand_mode
[i
] = insn_data
[icode
].operand
[i
].mode
;
2079 /* VOIDmode match_operands gets mode from their real operand. */
2080 if (recog_data
.operand_mode
[i
] == VOIDmode
)
2081 recog_data
.operand_mode
[i
] = GET_MODE (recog_data
.operand
[i
]);
2084 for (i
= 0; i
< noperands
; i
++)
2085 recog_data
.operand_type
[i
]
2086 = (recog_data
.constraints
[i
][0] == '=' ? OP_OUT
2087 : recog_data
.constraints
[i
][0] == '+' ? OP_INOUT
2090 if (recog_data
.n_alternatives
> MAX_RECOG_ALTERNATIVES
)
2094 /* After calling extract_insn, you can use this function to extract some
2095 information from the constraint strings into a more usable form.
2096 The collected data is stored in recog_op_alt. */
2098 preprocess_constraints ()
2102 memset (recog_op_alt
, 0, sizeof recog_op_alt
);
2103 for (i
= 0; i
< recog_data
.n_operands
; i
++)
2106 struct operand_alternative
*op_alt
;
2107 const char *p
= recog_data
.constraints
[i
];
2109 op_alt
= recog_op_alt
[i
];
2111 for (j
= 0; j
< recog_data
.n_alternatives
; j
++)
2113 op_alt
[j
].class = NO_REGS
;
2114 op_alt
[j
].constraint
= p
;
2115 op_alt
[j
].matches
= -1;
2116 op_alt
[j
].matched
= -1;
2118 if (*p
== '\0' || *p
== ',')
2120 op_alt
[j
].anything_ok
= 1;
2130 while (c
!= ',' && c
!= '\0');
2131 if (c
== ',' || c
== '\0')
2136 case '=': case '+': case '*': case '%':
2137 case 'E': case 'F': case 'G': case 'H':
2138 case 's': case 'i': case 'n':
2139 case 'I': case 'J': case 'K': case 'L':
2140 case 'M': case 'N': case 'O': case 'P':
2141 #ifdef EXTRA_CONSTRAINT
2142 case 'Q': case 'R': case 'S': case 'T': case 'U':
2144 /* These don't say anything we care about. */
2148 op_alt
[j
].reject
+= 6;
2151 op_alt
[j
].reject
+= 600;
2154 op_alt
[j
].earlyclobber
= 1;
2157 case '0': case '1': case '2': case '3': case '4':
2158 case '5': case '6': case '7': case '8': case '9':
2159 op_alt
[j
].matches
= c
- '0';
2160 recog_op_alt
[op_alt
[j
].matches
][j
].matched
= i
;
2164 op_alt
[j
].memory_ok
= 1;
2167 op_alt
[j
].decmem_ok
= 1;
2170 op_alt
[j
].incmem_ok
= 1;
2173 op_alt
[j
].nonoffmem_ok
= 1;
2176 op_alt
[j
].offmem_ok
= 1;
2179 op_alt
[j
].anything_ok
= 1;
2183 op_alt
[j
].class = reg_class_subunion
[(int) op_alt
[j
].class][(int) BASE_REG_CLASS
];
2187 op_alt
[j
].class = reg_class_subunion
[(int) op_alt
[j
].class][(int) GENERAL_REGS
];
2191 op_alt
[j
].class = reg_class_subunion
[(int) op_alt
[j
].class][(int) REG_CLASS_FROM_LETTER ((unsigned char)c
)];
2199 /* Check the operands of an insn against the insn's operand constraints
2200 and return 1 if they are valid.
2201 The information about the insn's operands, constraints, operand modes
2202 etc. is obtained from the global variables set up by extract_insn.
2204 WHICH_ALTERNATIVE is set to a number which indicates which
2205 alternative of constraints was matched: 0 for the first alternative,
2206 1 for the next, etc.
2208 In addition, when two operands are match
2209 and it happens that the output operand is (reg) while the
2210 input operand is --(reg) or ++(reg) (a pre-inc or pre-dec),
2211 make the output operand look like the input.
2212 This is because the output operand is the one the template will print.
2214 This is used in final, just before printing the assembler code and by
2215 the routines that determine an insn's attribute.
2217 If STRICT is a positive non-zero value, it means that we have been
2218 called after reload has been completed. In that case, we must
2219 do all checks strictly. If it is zero, it means that we have been called
2220 before reload has completed. In that case, we first try to see if we can
2221 find an alternative that matches strictly. If not, we try again, this
2222 time assuming that reload will fix up the insn. This provides a "best
2223 guess" for the alternative and is used to compute attributes of insns prior
2224 to reload. A negative value of STRICT is used for this internal call. */
2232 constrain_operands (strict
)
2235 const char *constraints
[MAX_RECOG_OPERANDS
];
2236 int matching_operands
[MAX_RECOG_OPERANDS
];
2237 int earlyclobber
[MAX_RECOG_OPERANDS
];
2240 struct funny_match funny_match
[MAX_RECOG_OPERANDS
];
2241 int funny_match_index
;
2243 if (recog_data
.n_operands
== 0 || recog_data
.n_alternatives
== 0)
2246 for (c
= 0; c
< recog_data
.n_operands
; c
++)
2248 constraints
[c
] = recog_data
.constraints
[c
];
2249 matching_operands
[c
] = -1;
2252 which_alternative
= 0;
2254 while (which_alternative
< recog_data
.n_alternatives
)
2258 funny_match_index
= 0;
2260 for (opno
= 0; opno
< recog_data
.n_operands
; opno
++)
2262 register rtx op
= recog_data
.operand
[opno
];
2263 enum machine_mode mode
= GET_MODE (op
);
2264 register const char *p
= constraints
[opno
];
2269 earlyclobber
[opno
] = 0;
2271 /* A unary operator may be accepted by the predicate, but it
2272 is irrelevant for matching constraints. */
2273 if (GET_RTX_CLASS (GET_CODE (op
)) == '1')
2276 if (GET_CODE (op
) == SUBREG
)
2278 if (GET_CODE (SUBREG_REG (op
)) == REG
2279 && REGNO (SUBREG_REG (op
)) < FIRST_PSEUDO_REGISTER
)
2280 offset
= SUBREG_WORD (op
);
2281 op
= SUBREG_REG (op
);
2284 /* An empty constraint or empty alternative
2285 allows anything which matched the pattern. */
2286 if (*p
== 0 || *p
== ',')
2289 while (*p
&& (c
= *p
++) != ',')
2292 case '?': case '!': case '*': case '%':
2297 /* Ignore rest of this alternative as far as
2298 constraint checking is concerned. */
2299 while (*p
&& *p
!= ',')
2304 earlyclobber
[opno
] = 1;
2307 case '0': case '1': case '2': case '3': case '4':
2308 case '5': case '6': case '7': case '8': case '9':
2310 /* This operand must be the same as a previous one.
2311 This kind of constraint is used for instructions such
2312 as add when they take only two operands.
2314 Note that the lower-numbered operand is passed first.
2316 If we are not testing strictly, assume that this constraint
2317 will be satisfied. */
2322 rtx op1
= recog_data
.operand
[c
- '0'];
2323 rtx op2
= recog_data
.operand
[opno
];
2325 /* A unary operator may be accepted by the predicate,
2326 but it is irrelevant for matching constraints. */
2327 if (GET_RTX_CLASS (GET_CODE (op1
)) == '1')
2328 op1
= XEXP (op1
, 0);
2329 if (GET_RTX_CLASS (GET_CODE (op2
)) == '1')
2330 op2
= XEXP (op2
, 0);
2332 val
= operands_match_p (op1
, op2
);
2335 matching_operands
[opno
] = c
- '0';
2336 matching_operands
[c
- '0'] = opno
;
2340 /* If output is *x and input is *--x,
2341 arrange later to change the output to *--x as well,
2342 since the output op is the one that will be printed. */
2343 if (val
== 2 && strict
> 0)
2345 funny_match
[funny_match_index
].this = opno
;
2346 funny_match
[funny_match_index
++].other
= c
- '0';
2351 /* p is used for address_operands. When we are called by
2352 gen_reload, no one will have checked that the address is
2353 strictly valid, i.e., that all pseudos requiring hard regs
2354 have gotten them. */
2356 || (strict_memory_address_p (recog_data
.operand_mode
[opno
],
2361 /* No need to check general_operand again;
2362 it was done in insn-recog.c. */
2364 /* Anything goes unless it is a REG and really has a hard reg
2365 but the hard reg is not in the class GENERAL_REGS. */
2367 || GENERAL_REGS
== ALL_REGS
2368 || GET_CODE (op
) != REG
2369 || (reload_in_progress
2370 && REGNO (op
) >= FIRST_PSEUDO_REGISTER
)
2371 || reg_fits_class_p (op
, GENERAL_REGS
, offset
, mode
))
2378 && GET_CODE (op
) == REG
2379 && REGNO (op
) >= FIRST_PSEUDO_REGISTER
)
2380 || (strict
== 0 && GET_CODE (op
) == SCRATCH
)
2381 || (GET_CODE (op
) == REG
2382 && ((GENERAL_REGS
== ALL_REGS
2383 && REGNO (op
) < FIRST_PSEUDO_REGISTER
)
2384 || reg_fits_class_p (op
, GENERAL_REGS
,
2390 /* This is used for a MATCH_SCRATCH in the cases when
2391 we don't actually need anything. So anything goes
2397 if (GET_CODE (op
) == MEM
2398 /* Before reload, accept what reload can turn into mem. */
2399 || (strict
< 0 && CONSTANT_P (op
))
2400 /* During reload, accept a pseudo */
2401 || (reload_in_progress
&& GET_CODE (op
) == REG
2402 && REGNO (op
) >= FIRST_PSEUDO_REGISTER
))
2407 if (GET_CODE (op
) == MEM
2408 && (GET_CODE (XEXP (op
, 0)) == PRE_DEC
2409 || GET_CODE (XEXP (op
, 0)) == POST_DEC
))
2414 if (GET_CODE (op
) == MEM
2415 && (GET_CODE (XEXP (op
, 0)) == PRE_INC
2416 || GET_CODE (XEXP (op
, 0)) == POST_INC
))
2421 #ifndef REAL_ARITHMETIC
2422 /* Match any CONST_DOUBLE, but only if
2423 we can examine the bits of it reliably. */
2424 if ((HOST_FLOAT_FORMAT
!= TARGET_FLOAT_FORMAT
2425 || HOST_BITS_PER_WIDE_INT
!= BITS_PER_WORD
)
2426 && GET_MODE (op
) != VOIDmode
&& ! flag_pretend_float
)
2429 if (GET_CODE (op
) == CONST_DOUBLE
)
2434 if (GET_CODE (op
) == CONST_DOUBLE
)
2440 if (GET_CODE (op
) == CONST_DOUBLE
2441 && CONST_DOUBLE_OK_FOR_LETTER_P (op
, c
))
2446 if (GET_CODE (op
) == CONST_INT
2447 || (GET_CODE (op
) == CONST_DOUBLE
2448 && GET_MODE (op
) == VOIDmode
))
2451 if (CONSTANT_P (op
))
2456 if (GET_CODE (op
) == CONST_INT
2457 || (GET_CODE (op
) == CONST_DOUBLE
2458 && GET_MODE (op
) == VOIDmode
))
2470 if (GET_CODE (op
) == CONST_INT
2471 && CONST_OK_FOR_LETTER_P (INTVAL (op
), c
))
2475 #ifdef EXTRA_CONSTRAINT
2481 if (EXTRA_CONSTRAINT (op
, c
))
2487 if (GET_CODE (op
) == MEM
2488 && ((strict
> 0 && ! offsettable_memref_p (op
))
2490 && !(CONSTANT_P (op
) || GET_CODE (op
) == MEM
))
2491 || (reload_in_progress
2492 && !(GET_CODE (op
) == REG
2493 && REGNO (op
) >= FIRST_PSEUDO_REGISTER
))))
2498 if ((strict
> 0 && offsettable_memref_p (op
))
2499 || (strict
== 0 && offsettable_nonstrict_memref_p (op
))
2500 /* Before reload, accept what reload can handle. */
2502 && (CONSTANT_P (op
) || GET_CODE (op
) == MEM
))
2503 /* During reload, accept a pseudo */
2504 || (reload_in_progress
&& GET_CODE (op
) == REG
2505 && REGNO (op
) >= FIRST_PSEUDO_REGISTER
))
2512 && GET_CODE (op
) == REG
2513 && REGNO (op
) >= FIRST_PSEUDO_REGISTER
)
2514 || (strict
== 0 && GET_CODE (op
) == SCRATCH
)
2515 || (GET_CODE (op
) == REG
2516 && reg_fits_class_p (op
, REG_CLASS_FROM_LETTER (c
),
2521 constraints
[opno
] = p
;
2522 /* If this operand did not win somehow,
2523 this alternative loses. */
2527 /* This alternative won; the operands are ok.
2528 Change whichever operands this alternative says to change. */
2533 /* See if any earlyclobber operand conflicts with some other
2537 for (eopno
= 0; eopno
< recog_data
.n_operands
; eopno
++)
2538 /* Ignore earlyclobber operands now in memory,
2539 because we would often report failure when we have
2540 two memory operands, one of which was formerly a REG. */
2541 if (earlyclobber
[eopno
]
2542 && GET_CODE (recog_data
.operand
[eopno
]) == REG
)
2543 for (opno
= 0; opno
< recog_data
.n_operands
; opno
++)
2544 if ((GET_CODE (recog_data
.operand
[opno
]) == MEM
2545 || recog_data
.operand_type
[opno
] != OP_OUT
)
2547 /* Ignore things like match_operator operands. */
2548 && *recog_data
.constraints
[opno
] != 0
2549 && ! (matching_operands
[opno
] == eopno
2550 && operands_match_p (recog_data
.operand
[opno
],
2551 recog_data
.operand
[eopno
]))
2552 && ! safe_from_earlyclobber (recog_data
.operand
[opno
],
2553 recog_data
.operand
[eopno
]))
2558 while (--funny_match_index
>= 0)
2560 recog_data
.operand
[funny_match
[funny_match_index
].other
]
2561 = recog_data
.operand
[funny_match
[funny_match_index
].this];
2568 which_alternative
++;
2571 /* If we are about to reject this, but we are not to test strictly,
2572 try a very loose test. Only return failure if it fails also. */
2574 return constrain_operands (-1);
2579 /* Return 1 iff OPERAND (assumed to be a REG rtx)
2580 is a hard reg in class CLASS when its regno is offset by OFFSET
2581 and changed to mode MODE.
2582 If REG occupies multiple hard regs, all of them must be in CLASS. */
2585 reg_fits_class_p (operand
, class, offset
, mode
)
2587 register enum reg_class
class;
2589 enum machine_mode mode
;
2591 register int regno
= REGNO (operand
);
2592 if (regno
< FIRST_PSEUDO_REGISTER
2593 && TEST_HARD_REG_BIT (reg_class_contents
[(int) class],
2598 for (sr
= HARD_REGNO_NREGS (regno
, mode
) - 1;
2600 if (! TEST_HARD_REG_BIT (reg_class_contents
[(int) class],
2609 /* Split all insns in the function. If UPD_LIFE, update life info after. */
2612 split_all_insns (upd_life
)
2619 blocks
= sbitmap_alloc (n_basic_blocks
);
2620 sbitmap_zero (blocks
);
2623 for (i
= n_basic_blocks
- 1; i
>= 0; --i
)
2625 basic_block bb
= BASIC_BLOCK (i
);
2628 for (insn
= bb
->head
; insn
; insn
= next
)
2632 /* Can't use `next_real_insn' because that might go across
2633 CODE_LABELS and short-out basic blocks. */
2634 next
= NEXT_INSN (insn
);
2635 if (! INSN_P (insn
))
2638 /* Don't split no-op move insns. These should silently
2639 disappear later in final. Splitting such insns would
2640 break the code that handles REG_NO_CONFLICT blocks. */
2642 else if ((set
= single_set (insn
)) != NULL
2643 && rtx_equal_p (SET_SRC (set
), SET_DEST (set
)))
2645 /* Nops get in the way while scheduling, so delete them
2646 now if register allocation has already been done. It
2647 is too risky to try to do this before register
2648 allocation, and there are unlikely to be very many
2649 nops then anyways. */
2650 if (reload_completed
)
2652 PUT_CODE (insn
, NOTE
);
2653 NOTE_LINE_NUMBER (insn
) = NOTE_INSN_DELETED
;
2654 NOTE_SOURCE_FILE (insn
) = 0;
2659 /* Split insns here to get max fine-grain parallelism. */
2660 rtx first
= PREV_INSN (insn
);
2661 rtx last
= try_split (PATTERN (insn
), insn
, 1);
2665 SET_BIT (blocks
, i
);
2668 /* try_split returns the NOTE that INSN became. */
2669 first
= NEXT_INSN (first
);
2670 PUT_CODE (insn
, NOTE
);
2671 NOTE_SOURCE_FILE (insn
) = 0;
2672 NOTE_LINE_NUMBER (insn
) = NOTE_INSN_DELETED
;
2674 if (insn
== bb
->end
)
2682 if (insn
== bb
->end
)
2686 /* ??? When we're called from just after reload, the CFG is in bad
2687 shape, and we may have fallen off the end. This could be fixed
2688 by having reload not try to delete unreachable code. Otherwise
2689 assert we found the end insn. */
2690 if (insn
== NULL
&& upd_life
)
2694 if (changed
&& upd_life
)
2696 compute_bb_for_insn (get_max_uid ());
2697 count_or_remove_death_notes (blocks
, 1);
2698 update_life_info (blocks
, UPDATE_LIFE_LOCAL
, PROP_DEATH_NOTES
);
2701 sbitmap_free (blocks
);
2704 #ifdef HAVE_peephole2
2705 struct peep2_insn_data
2711 static struct peep2_insn_data peep2_insn_data
[MAX_INSNS_PER_PEEP2
+ 1];
2712 static int peep2_current
;
2714 /* A non-insn marker indicating the last insn of the block.
2715 The live_before regset for this element is correct, indicating
2716 global_live_at_end for the block. */
2717 #define PEEP2_EOB pc_rtx
2719 /* Return the Nth non-note insn after `current', or return NULL_RTX if it
2720 does not exist. Used by the recognizer to find the next insn to match
2721 in a multi-insn pattern. */
2727 if (n
>= MAX_INSNS_PER_PEEP2
+ 1)
2731 if (n
>= MAX_INSNS_PER_PEEP2
+ 1)
2732 n
-= MAX_INSNS_PER_PEEP2
+ 1;
2734 if (peep2_insn_data
[n
].insn
== PEEP2_EOB
)
2736 return peep2_insn_data
[n
].insn
;
2739 /* Return true if REGNO is dead before the Nth non-note insn
2743 peep2_regno_dead_p (ofs
, regno
)
2747 if (ofs
>= MAX_INSNS_PER_PEEP2
+ 1)
2750 ofs
+= peep2_current
;
2751 if (ofs
>= MAX_INSNS_PER_PEEP2
+ 1)
2752 ofs
-= MAX_INSNS_PER_PEEP2
+ 1;
2754 if (peep2_insn_data
[ofs
].insn
== NULL_RTX
)
2757 return ! REGNO_REG_SET_P (peep2_insn_data
[ofs
].live_before
, regno
);
2760 /* Similarly for a REG. */
2763 peep2_reg_dead_p (ofs
, reg
)
2769 if (ofs
>= MAX_INSNS_PER_PEEP2
+ 1)
2772 ofs
+= peep2_current
;
2773 if (ofs
>= MAX_INSNS_PER_PEEP2
+ 1)
2774 ofs
-= MAX_INSNS_PER_PEEP2
+ 1;
2776 if (peep2_insn_data
[ofs
].insn
== NULL_RTX
)
2779 regno
= REGNO (reg
);
2780 n
= HARD_REGNO_NREGS (regno
, GET_MODE (reg
));
2782 if (REGNO_REG_SET_P (peep2_insn_data
[ofs
].live_before
, regno
+ n
))
2787 /* Try to find a hard register of mode MODE, matching the register class in
2788 CLASS_STR, which is available at the beginning of insn CURRENT_INSN and
2789 remains available until the end of LAST_INSN. LAST_INSN may be NULL_RTX,
2790 in which case the only condition is that the register must be available
2791 before CURRENT_INSN.
2792 Registers that already have bits set in REG_SET will not be considered.
2794 If an appropriate register is available, it will be returned and the
2795 corresponding bit(s) in REG_SET will be set; otherwise, NULL_RTX is
2799 peep2_find_free_register (from
, to
, class_str
, mode
, reg_set
)
2801 const char *class_str
;
2802 enum machine_mode mode
;
2803 HARD_REG_SET
*reg_set
;
2805 static int search_ofs
;
2806 enum reg_class
class;
2810 if (from
>= MAX_INSNS_PER_PEEP2
+ 1 || to
>= MAX_INSNS_PER_PEEP2
+ 1)
2813 from
+= peep2_current
;
2814 if (from
>= MAX_INSNS_PER_PEEP2
+ 1)
2815 from
-= MAX_INSNS_PER_PEEP2
+ 1;
2816 to
+= peep2_current
;
2817 if (to
>= MAX_INSNS_PER_PEEP2
+ 1)
2818 to
-= MAX_INSNS_PER_PEEP2
+ 1;
2820 if (peep2_insn_data
[from
].insn
== NULL_RTX
)
2822 REG_SET_TO_HARD_REG_SET (live
, peep2_insn_data
[from
].live_before
);
2826 HARD_REG_SET this_live
;
2828 if (++from
>= MAX_INSNS_PER_PEEP2
+ 1)
2830 if (peep2_insn_data
[from
].insn
== NULL_RTX
)
2832 REG_SET_TO_HARD_REG_SET (this_live
, peep2_insn_data
[from
].live_before
);
2833 IOR_HARD_REG_SET (live
, this_live
);
2836 class = (class_str
[0] == 'r' ? GENERAL_REGS
2837 : REG_CLASS_FROM_LETTER (class_str
[0]));
2839 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
2841 int raw_regno
, regno
, success
, j
;
2843 /* Distribute the free registers as much as possible. */
2844 raw_regno
= search_ofs
+ i
;
2845 if (raw_regno
>= FIRST_PSEUDO_REGISTER
)
2846 raw_regno
-= FIRST_PSEUDO_REGISTER
;
2847 #ifdef REG_ALLOC_ORDER
2848 regno
= reg_alloc_order
[raw_regno
];
2853 /* Don't allocate fixed registers. */
2854 if (fixed_regs
[regno
])
2856 /* Make sure the register is of the right class. */
2857 if (! TEST_HARD_REG_BIT (reg_class_contents
[class], regno
))
2859 /* And can support the mode we need. */
2860 if (! HARD_REGNO_MODE_OK (regno
, mode
))
2862 /* And that we don't create an extra save/restore. */
2863 if (! call_used_regs
[regno
] && ! regs_ever_live
[regno
])
2865 /* And we don't clobber traceback for noreturn functions. */
2866 if ((regno
== FRAME_POINTER_REGNUM
|| regno
== HARD_FRAME_POINTER_REGNUM
)
2867 && (! reload_completed
|| frame_pointer_needed
))
2871 for (j
= HARD_REGNO_NREGS (regno
, mode
) - 1; j
>= 0; j
--)
2873 if (TEST_HARD_REG_BIT (*reg_set
, regno
+ j
)
2874 || TEST_HARD_REG_BIT (live
, regno
+ j
))
2882 for (j
= HARD_REGNO_NREGS (regno
, mode
) - 1; j
>= 0; j
--)
2883 SET_HARD_REG_BIT (*reg_set
, regno
+ j
);
2885 /* Start the next search with the next register. */
2886 if (++raw_regno
>= FIRST_PSEUDO_REGISTER
)
2888 search_ofs
= raw_regno
;
2890 return gen_rtx_REG (mode
, regno
);
2898 /* Perform the peephole2 optimization pass. */
2901 peephole2_optimize (dump_file
)
2902 FILE *dump_file ATTRIBUTE_UNUSED
;
2904 regset_head rs_heads
[MAX_INSNS_PER_PEEP2
+ 2];
2908 #ifdef HAVE_conditional_execution
2913 /* Initialize the regsets we're going to use. */
2914 for (i
= 0; i
< MAX_INSNS_PER_PEEP2
+ 1; ++i
)
2915 peep2_insn_data
[i
].live_before
= INITIALIZE_REG_SET (rs_heads
[i
]);
2916 live
= INITIALIZE_REG_SET (rs_heads
[i
]);
2918 #ifdef HAVE_conditional_execution
2919 blocks
= sbitmap_alloc (n_basic_blocks
);
2920 sbitmap_zero (blocks
);
2923 count_or_remove_death_notes (NULL
, 1);
2926 for (b
= n_basic_blocks
- 1; b
>= 0; --b
)
2928 basic_block bb
= BASIC_BLOCK (b
);
2929 struct propagate_block_info
*pbi
;
2931 /* Indicate that all slots except the last holds invalid data. */
2932 for (i
= 0; i
< MAX_INSNS_PER_PEEP2
; ++i
)
2933 peep2_insn_data
[i
].insn
= NULL_RTX
;
2935 /* Indicate that the last slot contains live_after data. */
2936 peep2_insn_data
[MAX_INSNS_PER_PEEP2
].insn
= PEEP2_EOB
;
2937 peep2_current
= MAX_INSNS_PER_PEEP2
;
2939 /* Start up propagation. */
2940 COPY_REG_SET (live
, bb
->global_live_at_end
);
2941 COPY_REG_SET (peep2_insn_data
[MAX_INSNS_PER_PEEP2
].live_before
, live
);
2943 #ifdef HAVE_conditional_execution
2944 pbi
= init_propagate_block_info (bb
, live
, NULL
, 0);
2946 pbi
= init_propagate_block_info (bb
, live
, NULL
, PROP_DEATH_NOTES
);
2949 for (insn
= bb
->end
; ; insn
= prev
)
2951 prev
= PREV_INSN (insn
);
2957 /* Record this insn. */
2958 if (--peep2_current
< 0)
2959 peep2_current
= MAX_INSNS_PER_PEEP2
;
2960 peep2_insn_data
[peep2_current
].insn
= insn
;
2961 propagate_one_insn (pbi
, insn
);
2962 COPY_REG_SET (peep2_insn_data
[peep2_current
].live_before
, live
);
2964 /* Match the peephole. */
2965 try = peephole2_insns (PATTERN (insn
), insn
, &match_len
);
2968 i
= match_len
+ peep2_current
;
2969 if (i
>= MAX_INSNS_PER_PEEP2
+ 1)
2970 i
-= MAX_INSNS_PER_PEEP2
+ 1;
2972 /* Replace the old sequence with the new. */
2973 flow_delete_insn_chain (insn
, peep2_insn_data
[i
].insn
);
2974 try = emit_insn_after (try, prev
);
2976 /* Adjust the basic block boundaries. */
2977 if (peep2_insn_data
[i
].insn
== bb
->end
)
2979 if (insn
== bb
->head
)
2980 bb
->head
= NEXT_INSN (prev
);
2982 #ifdef HAVE_conditional_execution
2983 /* With conditional execution, we cannot back up the
2984 live information so easily, since the conditional
2985 death data structures are not so self-contained.
2986 So record that we've made a modification to this
2987 block and update life information at the end. */
2988 SET_BIT (blocks
, b
);
2991 for (i
= 0; i
< MAX_INSNS_PER_PEEP2
+ 1; ++i
)
2992 peep2_insn_data
[i
].insn
= NULL_RTX
;
2993 peep2_insn_data
[peep2_current
].insn
= PEEP2_EOB
;
2995 /* Back up lifetime information past the end of the
2996 newly created sequence. */
2997 if (++i
>= MAX_INSNS_PER_PEEP2
+ 1)
2999 COPY_REG_SET (live
, peep2_insn_data
[i
].live_before
);
3001 /* Update life information for the new sequence. */
3007 i
= MAX_INSNS_PER_PEEP2
;
3008 peep2_insn_data
[i
].insn
= try;
3009 propagate_one_insn (pbi
, try);
3010 COPY_REG_SET (peep2_insn_data
[i
].live_before
, live
);
3012 try = PREV_INSN (try);
3014 while (try != prev
);
3016 /* ??? Should verify that LIVE now matches what we
3017 had before the new sequence. */
3024 if (insn
== bb
->head
)
3028 free_propagate_block_info (pbi
);
3031 for (i
= 0; i
< MAX_INSNS_PER_PEEP2
+ 1; ++i
)
3032 FREE_REG_SET (peep2_insn_data
[i
].live_before
);
3033 FREE_REG_SET (live
);
3035 #ifdef HAVE_conditional_execution
3036 count_or_remove_death_notes (blocks
, 1);
3037 update_life_info (blocks
, UPDATE_LIFE_LOCAL
, PROP_DEATH_NOTES
);
3038 sbitmap_free (blocks
);
3041 #endif /* HAVE_peephole2 */