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, 2001, 2002 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
27 #include "insn-config.h"
28 #include "insn-attr.h"
29 #include "hard-reg-set.h"
37 #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 void validate_replace_src_1
PARAMS ((rtx
*, void *));
60 static rtx split_insn
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_1 (insn
)
118 if (INSN_CODE (insn
) < 0)
119 INSN_CODE (insn
) = recog (PATTERN (insn
), insn
, 0);
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
, constraints
, NULL
);
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
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 rtx pat
= PATTERN (insn
);
266 int num_clobbers
= 0;
267 /* If we are before reload and the pattern is a SET, see if we can add
269 int icode
= recog (pat
, insn
,
270 (GET_CODE (pat
) == SET
271 && ! reload_completed
&& ! reload_in_progress
)
272 ? &num_clobbers
: 0);
273 int is_asm
= icode
< 0 && asm_noperands (PATTERN (insn
)) >= 0;
276 /* If this is an asm and the operand aren't legal, then fail. Likewise if
277 this is not an asm and the insn wasn't recognized. */
278 if ((is_asm
&& ! check_asm_operands (PATTERN (insn
)))
279 || (!is_asm
&& icode
< 0))
282 /* If we have to add CLOBBERs, fail if we have to add ones that reference
283 hard registers since our callers can't know if they are live or not.
284 Otherwise, add them. */
285 if (num_clobbers
> 0)
289 if (added_clobbers_hard_reg_p (icode
))
292 newpat
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (num_clobbers
+ 1));
293 XVECEXP (newpat
, 0, 0) = pat
;
294 add_clobbers (newpat
, icode
);
295 PATTERN (insn
) = pat
= newpat
;
298 /* After reload, verify that all constraints are satisfied. */
299 if (reload_completed
)
303 if (! constrain_operands (1))
307 INSN_CODE (insn
) = icode
;
311 /* Apply a group of changes previously issued with `validate_change'.
312 Return 1 if all changes are valid, zero otherwise. */
315 apply_change_group ()
318 rtx last_validated
= NULL_RTX
;
320 /* The changes have been applied and all INSN_CODEs have been reset to force
323 The changes are valid if we aren't given an object, or if we are
324 given a MEM and it still is a valid address, or if this is in insn
325 and it is recognized. In the latter case, if reload has completed,
326 we also require that the operands meet the constraints for
329 for (i
= 0; i
< num_changes
; i
++)
331 rtx object
= changes
[i
].object
;
333 /* if there is no object to test or if it is the same as the one we
334 already tested, ignore it. */
335 if (object
== 0 || object
== last_validated
)
338 if (GET_CODE (object
) == MEM
)
340 if (! memory_address_p (GET_MODE (object
), XEXP (object
, 0)))
343 else if (insn_invalid_p (object
))
345 rtx pat
= PATTERN (object
);
347 /* Perhaps we couldn't recognize the insn because there were
348 extra CLOBBERs at the end. If so, try to re-recognize
349 without the last CLOBBER (later iterations will cause each of
350 them to be eliminated, in turn). But don't do this if we
351 have an ASM_OPERAND. */
352 if (GET_CODE (pat
) == PARALLEL
353 && GET_CODE (XVECEXP (pat
, 0, XVECLEN (pat
, 0) - 1)) == CLOBBER
354 && asm_noperands (PATTERN (object
)) < 0)
358 if (XVECLEN (pat
, 0) == 2)
359 newpat
= XVECEXP (pat
, 0, 0);
365 = gen_rtx_PARALLEL (VOIDmode
,
366 rtvec_alloc (XVECLEN (pat
, 0) - 1));
367 for (j
= 0; j
< XVECLEN (newpat
, 0); j
++)
368 XVECEXP (newpat
, 0, j
) = XVECEXP (pat
, 0, j
);
371 /* Add a new change to this group to replace the pattern
372 with this new pattern. Then consider this change
373 as having succeeded. The change we added will
374 cause the entire call to fail if things remain invalid.
376 Note that this can lose if a later change than the one
377 we are processing specified &XVECEXP (PATTERN (object), 0, X)
378 but this shouldn't occur. */
380 validate_change (object
, &PATTERN (object
), newpat
, 1);
383 else if (GET_CODE (pat
) == USE
|| GET_CODE (pat
) == CLOBBER
)
384 /* If this insn is a CLOBBER or USE, it is always valid, but is
390 last_validated
= object
;
393 if (i
== num_changes
)
397 for (i
= 0; i
< num_changes
; i
++)
398 if (changes
[i
].object
399 && INSN_P (changes
[i
].object
)
400 && basic_block_for_insn
401 && ((unsigned int)INSN_UID (changes
[i
].object
)
402 < basic_block_for_insn
->num_elements
)
403 && (bb
= BLOCK_FOR_INSN (changes
[i
].object
)))
404 bb
->flags
|= BB_DIRTY
;
416 /* Return the number of changes so far in the current group. */
419 num_validated_changes ()
424 /* Retract the changes numbered NUM and up. */
432 /* Back out all the changes. Do this in the opposite order in which
434 for (i
= num_changes
- 1; i
>= num
; i
--)
436 *changes
[i
].loc
= changes
[i
].old
;
437 if (changes
[i
].object
&& GET_CODE (changes
[i
].object
) != MEM
)
438 INSN_CODE (changes
[i
].object
) = changes
[i
].old_code
;
443 /* Replace every occurrence of FROM in X with TO. Mark each change with
444 validate_change passing OBJECT. */
447 validate_replace_rtx_1 (loc
, from
, to
, object
)
449 rtx from
, to
, object
;
455 enum machine_mode op0_mode
= VOIDmode
;
456 int prev_changes
= num_changes
;
463 fmt
= GET_RTX_FORMAT (code
);
465 op0_mode
= GET_MODE (XEXP (x
, 0));
467 /* X matches FROM if it is the same rtx or they are both referring to the
468 same register in the same mode. Avoid calling rtx_equal_p unless the
469 operands look similar. */
472 || (GET_CODE (x
) == REG
&& GET_CODE (from
) == REG
473 && GET_MODE (x
) == GET_MODE (from
)
474 && REGNO (x
) == REGNO (from
))
475 || (GET_CODE (x
) == GET_CODE (from
) && GET_MODE (x
) == GET_MODE (from
)
476 && rtx_equal_p (x
, from
)))
478 validate_change (object
, loc
, to
, 1);
482 /* Call ourself recursively to perform the replacements. */
484 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
487 validate_replace_rtx_1 (&XEXP (x
, i
), from
, to
, object
);
488 else if (fmt
[i
] == 'E')
489 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
490 validate_replace_rtx_1 (&XVECEXP (x
, i
, j
), from
, to
, object
);
493 /* If we didn't substitute, there is nothing more to do. */
494 if (num_changes
== prev_changes
)
497 /* Allow substituted expression to have different mode. This is used by
498 regmove to change mode of pseudo register. */
499 if (fmt
[0] == 'e' && GET_MODE (XEXP (x
, 0)) != VOIDmode
)
500 op0_mode
= GET_MODE (XEXP (x
, 0));
502 /* Do changes needed to keep rtx consistent. Don't do any other
503 simplifications, as it is not our job. */
505 if ((GET_RTX_CLASS (code
) == '<' || GET_RTX_CLASS (code
) == 'c')
506 && swap_commutative_operands_p (XEXP (x
, 0), XEXP (x
, 1)))
508 validate_change (object
, loc
,
509 gen_rtx_fmt_ee (GET_RTX_CLASS (code
) == 'c' ? code
510 : swap_condition (code
),
511 GET_MODE (x
), XEXP (x
, 1),
520 /* If we have a PLUS whose second operand is now a CONST_INT, use
521 plus_constant to try to simplify it.
522 ??? We may want later to remove this, once simplification is
523 separated from this function. */
524 if (GET_CODE (XEXP (x
, 1)) == CONST_INT
)
525 validate_change (object
, loc
,
527 (PLUS
, GET_MODE (x
), XEXP (x
, 0), XEXP (x
, 1)), 1);
530 if (GET_CODE (XEXP (x
, 1)) == CONST_INT
531 || GET_CODE (XEXP (x
, 1)) == CONST_DOUBLE
)
532 validate_change (object
, loc
,
534 (PLUS
, GET_MODE (x
), XEXP (x
, 0),
535 simplify_gen_unary (NEG
,
536 GET_MODE (x
), XEXP (x
, 1),
541 if (GET_MODE (XEXP (x
, 0)) == VOIDmode
)
543 new = simplify_gen_unary (code
, GET_MODE (x
), XEXP (x
, 0),
545 /* If any of the above failed, substitute in something that
546 we know won't be recognized. */
548 new = gen_rtx_CLOBBER (GET_MODE (x
), const0_rtx
);
549 validate_change (object
, loc
, new, 1);
553 /* All subregs possible to simplify should be simplified. */
554 new = simplify_subreg (GET_MODE (x
), SUBREG_REG (x
), op0_mode
,
557 /* Subregs of VOIDmode operands are incorrect. */
558 if (!new && GET_MODE (SUBREG_REG (x
)) == VOIDmode
)
559 new = gen_rtx_CLOBBER (GET_MODE (x
), const0_rtx
);
561 validate_change (object
, loc
, new, 1);
565 /* If we are replacing a register with memory, try to change the memory
566 to be the mode required for memory in extract operations (this isn't
567 likely to be an insertion operation; if it was, nothing bad will
568 happen, we might just fail in some cases). */
570 if (GET_CODE (XEXP (x
, 0)) == MEM
571 && GET_CODE (XEXP (x
, 1)) == CONST_INT
572 && GET_CODE (XEXP (x
, 2)) == CONST_INT
573 && !mode_dependent_address_p (XEXP (XEXP (x
, 0), 0))
574 && !MEM_VOLATILE_P (XEXP (x
, 0)))
576 enum machine_mode wanted_mode
= VOIDmode
;
577 enum machine_mode is_mode
= GET_MODE (XEXP (x
, 0));
578 int pos
= INTVAL (XEXP (x
, 2));
580 if (GET_CODE (x
) == ZERO_EXTRACT
)
582 enum machine_mode new_mode
583 = mode_for_extraction (EP_extzv
, 1);
584 if (new_mode
!= MAX_MACHINE_MODE
)
585 wanted_mode
= new_mode
;
587 else if (GET_CODE (x
) == SIGN_EXTRACT
)
589 enum machine_mode new_mode
590 = mode_for_extraction (EP_extv
, 1);
591 if (new_mode
!= MAX_MACHINE_MODE
)
592 wanted_mode
= new_mode
;
595 /* If we have a narrower mode, we can do something. */
596 if (wanted_mode
!= VOIDmode
597 && GET_MODE_SIZE (wanted_mode
) < GET_MODE_SIZE (is_mode
))
599 int offset
= pos
/ BITS_PER_UNIT
;
602 /* If the bytes and bits are counted differently, we
603 must adjust the offset. */
604 if (BYTES_BIG_ENDIAN
!= BITS_BIG_ENDIAN
)
606 (GET_MODE_SIZE (is_mode
) - GET_MODE_SIZE (wanted_mode
) -
609 pos
%= GET_MODE_BITSIZE (wanted_mode
);
611 newmem
= adjust_address_nv (XEXP (x
, 0), wanted_mode
, offset
);
613 validate_change (object
, &XEXP (x
, 2), GEN_INT (pos
), 1);
614 validate_change (object
, &XEXP (x
, 0), newmem
, 1);
625 /* Try replacing every occurrence of FROM in subexpression LOC of INSN
626 with TO. After all changes have been made, validate by seeing
627 if INSN is still valid. */
630 validate_replace_rtx_subexp (from
, to
, insn
, loc
)
631 rtx from
, to
, insn
, *loc
;
633 validate_replace_rtx_1 (loc
, from
, to
, insn
);
634 return apply_change_group ();
637 /* Try replacing every occurrence of FROM in INSN with TO. After all
638 changes have been made, validate by seeing if INSN is still valid. */
641 validate_replace_rtx (from
, to
, insn
)
644 validate_replace_rtx_1 (&PATTERN (insn
), from
, to
, insn
);
645 return apply_change_group ();
648 /* Try replacing every occurrence of FROM in INSN with TO. */
651 validate_replace_rtx_group (from
, to
, insn
)
654 validate_replace_rtx_1 (&PATTERN (insn
), from
, to
, insn
);
657 /* Function called by note_uses to replace used subexpressions. */
658 struct validate_replace_src_data
660 rtx from
; /* Old RTX */
661 rtx to
; /* New RTX */
662 rtx insn
; /* Insn in which substitution is occurring. */
666 validate_replace_src_1 (x
, data
)
670 struct validate_replace_src_data
*d
671 = (struct validate_replace_src_data
*) data
;
673 validate_replace_rtx_1 (x
, d
->from
, d
->to
, d
->insn
);
676 /* Try replacing every occurrence of FROM in INSN with TO, avoiding
677 SET_DESTs. After all changes have been made, validate by seeing if
678 INSN is still valid. */
681 validate_replace_src (from
, to
, insn
)
684 struct validate_replace_src_data d
;
689 note_uses (&PATTERN (insn
), validate_replace_src_1
, &d
);
690 return apply_change_group ();
694 /* Return 1 if the insn using CC0 set by INSN does not contain
695 any ordered tests applied to the condition codes.
696 EQ and NE tests do not count. */
699 next_insn_tests_no_inequality (insn
)
702 rtx next
= next_cc0_user (insn
);
704 /* If there is no next insn, we have to take the conservative choice. */
708 return ((GET_CODE (next
) == JUMP_INSN
709 || GET_CODE (next
) == INSN
710 || GET_CODE (next
) == CALL_INSN
)
711 && ! inequality_comparisons_p (PATTERN (next
)));
714 #if 0 /* This is useless since the insn that sets the cc's
715 must be followed immediately by the use of them. */
716 /* Return 1 if the CC value set up by INSN is not used. */
719 next_insns_test_no_inequality (insn
)
722 rtx next
= NEXT_INSN (insn
);
724 for (; next
!= 0; next
= NEXT_INSN (next
))
726 if (GET_CODE (next
) == CODE_LABEL
727 || GET_CODE (next
) == BARRIER
)
729 if (GET_CODE (next
) == NOTE
)
731 if (inequality_comparisons_p (PATTERN (next
)))
733 if (sets_cc0_p (PATTERN (next
)) == 1)
735 if (! reg_mentioned_p (cc0_rtx
, PATTERN (next
)))
743 /* This is used by find_single_use to locate an rtx that contains exactly one
744 use of DEST, which is typically either a REG or CC0. It returns a
745 pointer to the innermost rtx expression containing DEST. Appearances of
746 DEST that are being used to totally replace it are not counted. */
749 find_single_use_1 (dest
, loc
)
754 enum rtx_code code
= GET_CODE (x
);
772 /* If the destination is anything other than CC0, PC, a REG or a SUBREG
773 of a REG that occupies all of the REG, the insn uses DEST if
774 it is mentioned in the destination or the source. Otherwise, we
775 need just check the source. */
776 if (GET_CODE (SET_DEST (x
)) != CC0
777 && GET_CODE (SET_DEST (x
)) != PC
778 && GET_CODE (SET_DEST (x
)) != REG
779 && ! (GET_CODE (SET_DEST (x
)) == SUBREG
780 && GET_CODE (SUBREG_REG (SET_DEST (x
))) == REG
781 && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (x
))))
782 + (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
)
783 == ((GET_MODE_SIZE (GET_MODE (SET_DEST (x
)))
784 + (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
))))
787 return find_single_use_1 (dest
, &SET_SRC (x
));
791 return find_single_use_1 (dest
, &XEXP (x
, 0));
797 /* If it wasn't one of the common cases above, check each expression and
798 vector of this code. Look for a unique usage of DEST. */
800 fmt
= GET_RTX_FORMAT (code
);
801 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
805 if (dest
== XEXP (x
, i
)
806 || (GET_CODE (dest
) == REG
&& GET_CODE (XEXP (x
, i
)) == REG
807 && REGNO (dest
) == REGNO (XEXP (x
, i
))))
810 this_result
= find_single_use_1 (dest
, &XEXP (x
, i
));
813 result
= this_result
;
814 else if (this_result
)
815 /* Duplicate usage. */
818 else if (fmt
[i
] == 'E')
822 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
824 if (XVECEXP (x
, i
, j
) == dest
825 || (GET_CODE (dest
) == REG
826 && GET_CODE (XVECEXP (x
, i
, j
)) == REG
827 && REGNO (XVECEXP (x
, i
, j
)) == REGNO (dest
)))
830 this_result
= find_single_use_1 (dest
, &XVECEXP (x
, i
, j
));
833 result
= this_result
;
834 else if (this_result
)
843 /* See if DEST, produced in INSN, is used only a single time in the
844 sequel. If so, return a pointer to the innermost rtx expression in which
847 If PLOC is non-zero, *PLOC is set to the insn containing the single use.
849 This routine will return usually zero either before flow is called (because
850 there will be no LOG_LINKS notes) or after reload (because the REG_DEAD
851 note can't be trusted).
853 If DEST is cc0_rtx, we look only at the next insn. In that case, we don't
854 care about REG_DEAD notes or LOG_LINKS.
856 Otherwise, we find the single use by finding an insn that has a
857 LOG_LINKS pointing at INSN and has a REG_DEAD note for DEST. If DEST is
858 only referenced once in that insn, we know that it must be the first
859 and last insn referencing DEST. */
862 find_single_use (dest
, insn
, ploc
)
874 next
= NEXT_INSN (insn
);
876 || (GET_CODE (next
) != INSN
&& GET_CODE (next
) != JUMP_INSN
))
879 result
= find_single_use_1 (dest
, &PATTERN (next
));
886 if (reload_completed
|| reload_in_progress
|| GET_CODE (dest
) != REG
)
889 for (next
= next_nonnote_insn (insn
);
890 next
!= 0 && GET_CODE (next
) != CODE_LABEL
;
891 next
= next_nonnote_insn (next
))
892 if (INSN_P (next
) && dead_or_set_p (next
, dest
))
894 for (link
= LOG_LINKS (next
); link
; link
= XEXP (link
, 1))
895 if (XEXP (link
, 0) == insn
)
900 result
= find_single_use_1 (dest
, &PATTERN (next
));
910 /* Return 1 if OP is a valid general operand for machine mode MODE.
911 This is either a register reference, a memory reference,
912 or a constant. In the case of a memory reference, the address
913 is checked for general validity for the target machine.
915 Register and memory references must have mode MODE in order to be valid,
916 but some constants have no machine mode and are valid for any mode.
918 If MODE is VOIDmode, OP is checked for validity for whatever mode
921 The main use of this function is as a predicate in match_operand
922 expressions in the machine description.
924 For an explanation of this function's behavior for registers of
925 class NO_REGS, see the comment for `register_operand'. */
928 general_operand (op
, mode
)
930 enum machine_mode mode
;
932 enum rtx_code code
= GET_CODE (op
);
934 if (mode
== VOIDmode
)
935 mode
= GET_MODE (op
);
937 /* Don't accept CONST_INT or anything similar
938 if the caller wants something floating. */
939 if (GET_MODE (op
) == VOIDmode
&& mode
!= VOIDmode
940 && GET_MODE_CLASS (mode
) != MODE_INT
941 && GET_MODE_CLASS (mode
) != MODE_PARTIAL_INT
)
944 if (GET_CODE (op
) == CONST_INT
945 && trunc_int_for_mode (INTVAL (op
), mode
) != INTVAL (op
))
949 return ((GET_MODE (op
) == VOIDmode
|| GET_MODE (op
) == mode
951 #ifdef LEGITIMATE_PIC_OPERAND_P
952 && (! flag_pic
|| LEGITIMATE_PIC_OPERAND_P (op
))
954 && LEGITIMATE_CONSTANT_P (op
));
956 /* Except for certain constants with VOIDmode, already checked for,
957 OP's mode must match MODE if MODE specifies a mode. */
959 if (GET_MODE (op
) != mode
)
964 #ifdef INSN_SCHEDULING
965 /* On machines that have insn scheduling, we want all memory
966 reference to be explicit, so outlaw paradoxical SUBREGs. */
967 if (GET_CODE (SUBREG_REG (op
)) == MEM
968 && GET_MODE_SIZE (mode
) > GET_MODE_SIZE (GET_MODE (SUBREG_REG (op
))))
971 /* Avoid memories with nonzero SUBREG_BYTE, as offsetting the memory
972 may result in incorrect reference. We should simplify all valid
973 subregs of MEM anyway. But allow this after reload because we
974 might be called from cleanup_subreg_operands.
976 ??? This is a kludge. */
977 if (!reload_completed
&& SUBREG_BYTE (op
) != 0
978 && GET_CODE (SUBREG_REG (op
)) == MEM
)
981 op
= SUBREG_REG (op
);
982 code
= GET_CODE (op
);
986 /* A register whose class is NO_REGS is not a general operand. */
987 return (REGNO (op
) >= FIRST_PSEUDO_REGISTER
988 || REGNO_REG_CLASS (REGNO (op
)) != NO_REGS
);
992 rtx y
= XEXP (op
, 0);
994 if (! volatile_ok
&& MEM_VOLATILE_P (op
))
997 if (GET_CODE (y
) == ADDRESSOF
)
1000 /* Use the mem's mode, since it will be reloaded thus. */
1001 mode
= GET_MODE (op
);
1002 GO_IF_LEGITIMATE_ADDRESS (mode
, y
, win
);
1005 /* Pretend this is an operand for now; we'll run force_operand
1006 on its replacement in fixup_var_refs_1. */
1007 if (code
== ADDRESSOF
)
1016 /* Return 1 if OP is a valid memory address for a memory reference
1019 The main use of this function is as a predicate in match_operand
1020 expressions in the machine description. */
1023 address_operand (op
, mode
)
1025 enum machine_mode mode
;
1027 return memory_address_p (mode
, op
);
1030 /* Return 1 if OP is a register reference of mode MODE.
1031 If MODE is VOIDmode, accept a register in any mode.
1033 The main use of this function is as a predicate in match_operand
1034 expressions in the machine description.
1036 As a special exception, registers whose class is NO_REGS are
1037 not accepted by `register_operand'. The reason for this change
1038 is to allow the representation of special architecture artifacts
1039 (such as a condition code register) without extending the rtl
1040 definitions. Since registers of class NO_REGS cannot be used
1041 as registers in any case where register classes are examined,
1042 it is most consistent to keep this function from accepting them. */
1045 register_operand (op
, mode
)
1047 enum machine_mode mode
;
1049 if (GET_MODE (op
) != mode
&& mode
!= VOIDmode
)
1052 if (GET_CODE (op
) == SUBREG
)
1054 /* Before reload, we can allow (SUBREG (MEM...)) as a register operand
1055 because it is guaranteed to be reloaded into one.
1056 Just make sure the MEM is valid in itself.
1057 (Ideally, (SUBREG (MEM)...) should not exist after reload,
1058 but currently it does result from (SUBREG (REG)...) where the
1059 reg went on the stack.) */
1060 if (! reload_completed
&& GET_CODE (SUBREG_REG (op
)) == MEM
)
1061 return general_operand (op
, mode
);
1063 #ifdef CLASS_CANNOT_CHANGE_MODE
1064 if (GET_CODE (SUBREG_REG (op
)) == REG
1065 && REGNO (SUBREG_REG (op
)) < FIRST_PSEUDO_REGISTER
1066 && (TEST_HARD_REG_BIT
1067 (reg_class_contents
[(int) CLASS_CANNOT_CHANGE_MODE
],
1068 REGNO (SUBREG_REG (op
))))
1069 && CLASS_CANNOT_CHANGE_MODE_P (mode
, GET_MODE (SUBREG_REG (op
)))
1070 && GET_MODE_CLASS (GET_MODE (SUBREG_REG (op
))) != MODE_COMPLEX_INT
1071 && GET_MODE_CLASS (GET_MODE (SUBREG_REG (op
))) != MODE_COMPLEX_FLOAT
)
1075 op
= SUBREG_REG (op
);
1078 /* If we have an ADDRESSOF, consider it valid since it will be
1079 converted into something that will not be a MEM. */
1080 if (GET_CODE (op
) == ADDRESSOF
)
1083 /* We don't consider registers whose class is NO_REGS
1084 to be a register operand. */
1085 return (GET_CODE (op
) == REG
1086 && (REGNO (op
) >= FIRST_PSEUDO_REGISTER
1087 || REGNO_REG_CLASS (REGNO (op
)) != NO_REGS
));
1090 /* Return 1 for a register in Pmode; ignore the tested mode. */
1093 pmode_register_operand (op
, mode
)
1095 enum machine_mode mode ATTRIBUTE_UNUSED
;
1097 return register_operand (op
, Pmode
);
1100 /* Return 1 if OP should match a MATCH_SCRATCH, i.e., if it is a SCRATCH
1101 or a hard register. */
1104 scratch_operand (op
, mode
)
1106 enum machine_mode mode
;
1108 if (GET_MODE (op
) != mode
&& mode
!= VOIDmode
)
1111 return (GET_CODE (op
) == SCRATCH
1112 || (GET_CODE (op
) == REG
1113 && REGNO (op
) < FIRST_PSEUDO_REGISTER
));
1116 /* Return 1 if OP is a valid immediate operand for mode MODE.
1118 The main use of this function is as a predicate in match_operand
1119 expressions in the machine description. */
1122 immediate_operand (op
, mode
)
1124 enum machine_mode mode
;
1126 /* Don't accept CONST_INT or anything similar
1127 if the caller wants something floating. */
1128 if (GET_MODE (op
) == VOIDmode
&& mode
!= VOIDmode
1129 && GET_MODE_CLASS (mode
) != MODE_INT
1130 && GET_MODE_CLASS (mode
) != MODE_PARTIAL_INT
)
1133 if (GET_CODE (op
) == CONST_INT
1134 && trunc_int_for_mode (INTVAL (op
), mode
) != INTVAL (op
))
1137 /* Accept CONSTANT_P_RTX, since it will be gone by CSE1 and
1138 result in 0/1. It seems a safe assumption that this is
1139 in range for everyone. */
1140 if (GET_CODE (op
) == CONSTANT_P_RTX
)
1143 return (CONSTANT_P (op
)
1144 && (GET_MODE (op
) == mode
|| mode
== VOIDmode
1145 || GET_MODE (op
) == VOIDmode
)
1146 #ifdef LEGITIMATE_PIC_OPERAND_P
1147 && (! flag_pic
|| LEGITIMATE_PIC_OPERAND_P (op
))
1149 && LEGITIMATE_CONSTANT_P (op
));
1152 /* Returns 1 if OP is an operand that is a CONST_INT. */
1155 const_int_operand (op
, mode
)
1157 enum machine_mode mode
;
1159 if (GET_CODE (op
) != CONST_INT
)
1162 if (mode
!= VOIDmode
1163 && trunc_int_for_mode (INTVAL (op
), mode
) != INTVAL (op
))
1169 /* Returns 1 if OP is an operand that is a constant integer or constant
1170 floating-point number. */
1173 const_double_operand (op
, mode
)
1175 enum machine_mode mode
;
1177 /* Don't accept CONST_INT or anything similar
1178 if the caller wants something floating. */
1179 if (GET_MODE (op
) == VOIDmode
&& mode
!= VOIDmode
1180 && GET_MODE_CLASS (mode
) != MODE_INT
1181 && GET_MODE_CLASS (mode
) != MODE_PARTIAL_INT
)
1184 return ((GET_CODE (op
) == CONST_DOUBLE
|| GET_CODE (op
) == CONST_INT
)
1185 && (mode
== VOIDmode
|| GET_MODE (op
) == mode
1186 || GET_MODE (op
) == VOIDmode
));
1189 /* Return 1 if OP is a general operand that is not an immediate operand. */
1192 nonimmediate_operand (op
, mode
)
1194 enum machine_mode mode
;
1196 return (general_operand (op
, mode
) && ! CONSTANT_P (op
));
1199 /* Return 1 if OP is a register reference or immediate value of mode MODE. */
1202 nonmemory_operand (op
, mode
)
1204 enum machine_mode mode
;
1206 if (CONSTANT_P (op
))
1208 /* Don't accept CONST_INT or anything similar
1209 if the caller wants something floating. */
1210 if (GET_MODE (op
) == VOIDmode
&& mode
!= VOIDmode
1211 && GET_MODE_CLASS (mode
) != MODE_INT
1212 && GET_MODE_CLASS (mode
) != MODE_PARTIAL_INT
)
1215 if (GET_CODE (op
) == CONST_INT
1216 && trunc_int_for_mode (INTVAL (op
), mode
) != INTVAL (op
))
1219 return ((GET_MODE (op
) == VOIDmode
|| GET_MODE (op
) == mode
1220 || mode
== VOIDmode
)
1221 #ifdef LEGITIMATE_PIC_OPERAND_P
1222 && (! flag_pic
|| LEGITIMATE_PIC_OPERAND_P (op
))
1224 && LEGITIMATE_CONSTANT_P (op
));
1227 if (GET_MODE (op
) != mode
&& mode
!= VOIDmode
)
1230 if (GET_CODE (op
) == SUBREG
)
1232 /* Before reload, we can allow (SUBREG (MEM...)) as a register operand
1233 because it is guaranteed to be reloaded into one.
1234 Just make sure the MEM is valid in itself.
1235 (Ideally, (SUBREG (MEM)...) should not exist after reload,
1236 but currently it does result from (SUBREG (REG)...) where the
1237 reg went on the stack.) */
1238 if (! reload_completed
&& GET_CODE (SUBREG_REG (op
)) == MEM
)
1239 return general_operand (op
, mode
);
1240 op
= SUBREG_REG (op
);
1243 /* We don't consider registers whose class is NO_REGS
1244 to be a register operand. */
1245 return (GET_CODE (op
) == REG
1246 && (REGNO (op
) >= FIRST_PSEUDO_REGISTER
1247 || REGNO_REG_CLASS (REGNO (op
)) != NO_REGS
));
1250 /* Return 1 if OP is a valid operand that stands for pushing a
1251 value of mode MODE onto the stack.
1253 The main use of this function is as a predicate in match_operand
1254 expressions in the machine description. */
1257 push_operand (op
, mode
)
1259 enum machine_mode mode
;
1261 unsigned int rounded_size
= GET_MODE_SIZE (mode
);
1263 #ifdef PUSH_ROUNDING
1264 rounded_size
= PUSH_ROUNDING (rounded_size
);
1267 if (GET_CODE (op
) != MEM
)
1270 if (mode
!= VOIDmode
&& GET_MODE (op
) != mode
)
1275 if (rounded_size
== GET_MODE_SIZE (mode
))
1277 if (GET_CODE (op
) != STACK_PUSH_CODE
)
1282 if (GET_CODE (op
) != PRE_MODIFY
1283 || GET_CODE (XEXP (op
, 1)) != PLUS
1284 || XEXP (XEXP (op
, 1), 0) != XEXP (op
, 0)
1285 || GET_CODE (XEXP (XEXP (op
, 1), 1)) != CONST_INT
1286 #ifdef STACK_GROWS_DOWNWARD
1287 || INTVAL (XEXP (XEXP (op
, 1), 1)) != - (int) rounded_size
1289 || INTVAL (XEXP (XEXP (op
, 1), 1)) != rounded_size
1295 return XEXP (op
, 0) == stack_pointer_rtx
;
1298 /* Return 1 if OP is a valid operand that stands for popping a
1299 value of mode MODE off the stack.
1301 The main use of this function is as a predicate in match_operand
1302 expressions in the machine description. */
1305 pop_operand (op
, mode
)
1307 enum machine_mode mode
;
1309 if (GET_CODE (op
) != MEM
)
1312 if (mode
!= VOIDmode
&& GET_MODE (op
) != mode
)
1317 if (GET_CODE (op
) != STACK_POP_CODE
)
1320 return XEXP (op
, 0) == stack_pointer_rtx
;
1323 /* Return 1 if ADDR is a valid memory address for mode MODE. */
1326 memory_address_p (mode
, addr
)
1327 enum machine_mode mode ATTRIBUTE_UNUSED
;
1330 if (GET_CODE (addr
) == ADDRESSOF
)
1333 GO_IF_LEGITIMATE_ADDRESS (mode
, addr
, win
);
1340 /* Return 1 if OP is a valid memory reference with mode MODE,
1341 including a valid address.
1343 The main use of this function is as a predicate in match_operand
1344 expressions in the machine description. */
1347 memory_operand (op
, mode
)
1349 enum machine_mode mode
;
1353 if (! reload_completed
)
1354 /* Note that no SUBREG is a memory operand before end of reload pass,
1355 because (SUBREG (MEM...)) forces reloading into a register. */
1356 return GET_CODE (op
) == MEM
&& general_operand (op
, mode
);
1358 if (mode
!= VOIDmode
&& GET_MODE (op
) != mode
)
1362 if (GET_CODE (inner
) == SUBREG
)
1363 inner
= SUBREG_REG (inner
);
1365 return (GET_CODE (inner
) == MEM
&& general_operand (op
, mode
));
1368 /* Return 1 if OP is a valid indirect memory reference with mode MODE;
1369 that is, a memory reference whose address is a general_operand. */
1372 indirect_operand (op
, mode
)
1374 enum machine_mode mode
;
1376 /* Before reload, a SUBREG isn't in memory (see memory_operand, above). */
1377 if (! reload_completed
1378 && GET_CODE (op
) == SUBREG
&& GET_CODE (SUBREG_REG (op
)) == MEM
)
1380 int offset
= SUBREG_BYTE (op
);
1381 rtx inner
= SUBREG_REG (op
);
1383 if (mode
!= VOIDmode
&& GET_MODE (op
) != mode
)
1386 /* The only way that we can have a general_operand as the resulting
1387 address is if OFFSET is zero and the address already is an operand
1388 or if the address is (plus Y (const_int -OFFSET)) and Y is an
1391 return ((offset
== 0 && general_operand (XEXP (inner
, 0), Pmode
))
1392 || (GET_CODE (XEXP (inner
, 0)) == PLUS
1393 && GET_CODE (XEXP (XEXP (inner
, 0), 1)) == CONST_INT
1394 && INTVAL (XEXP (XEXP (inner
, 0), 1)) == -offset
1395 && general_operand (XEXP (XEXP (inner
, 0), 0), Pmode
)));
1398 return (GET_CODE (op
) == MEM
1399 && memory_operand (op
, mode
)
1400 && general_operand (XEXP (op
, 0), Pmode
));
1403 /* Return 1 if this is a comparison operator. This allows the use of
1404 MATCH_OPERATOR to recognize all the branch insns. */
1407 comparison_operator (op
, mode
)
1409 enum machine_mode mode
;
1411 return ((mode
== VOIDmode
|| GET_MODE (op
) == mode
)
1412 && GET_RTX_CLASS (GET_CODE (op
)) == '<');
1415 /* If BODY is an insn body that uses ASM_OPERANDS,
1416 return the number of operands (both input and output) in the insn.
1417 Otherwise return -1. */
1420 asm_noperands (body
)
1423 switch (GET_CODE (body
))
1426 /* No output operands: return number of input operands. */
1427 return ASM_OPERANDS_INPUT_LENGTH (body
);
1429 if (GET_CODE (SET_SRC (body
)) == ASM_OPERANDS
)
1430 /* Single output operand: BODY is (set OUTPUT (asm_operands ...)). */
1431 return ASM_OPERANDS_INPUT_LENGTH (SET_SRC (body
)) + 1;
1435 if (GET_CODE (XVECEXP (body
, 0, 0)) == SET
1436 && GET_CODE (SET_SRC (XVECEXP (body
, 0, 0))) == ASM_OPERANDS
)
1438 /* Multiple output operands, or 1 output plus some clobbers:
1439 body is [(set OUTPUT (asm_operands ...))... (clobber (reg ...))...]. */
1443 /* Count backwards through CLOBBERs to determine number of SETs. */
1444 for (i
= XVECLEN (body
, 0); i
> 0; i
--)
1446 if (GET_CODE (XVECEXP (body
, 0, i
- 1)) == SET
)
1448 if (GET_CODE (XVECEXP (body
, 0, i
- 1)) != CLOBBER
)
1452 /* N_SETS is now number of output operands. */
1455 /* Verify that all the SETs we have
1456 came from a single original asm_operands insn
1457 (so that invalid combinations are blocked). */
1458 for (i
= 0; i
< n_sets
; i
++)
1460 rtx elt
= XVECEXP (body
, 0, i
);
1461 if (GET_CODE (elt
) != SET
)
1463 if (GET_CODE (SET_SRC (elt
)) != ASM_OPERANDS
)
1465 /* If these ASM_OPERANDS rtx's came from different original insns
1466 then they aren't allowed together. */
1467 if (ASM_OPERANDS_INPUT_VEC (SET_SRC (elt
))
1468 != ASM_OPERANDS_INPUT_VEC (SET_SRC (XVECEXP (body
, 0, 0))))
1471 return (ASM_OPERANDS_INPUT_LENGTH (SET_SRC (XVECEXP (body
, 0, 0)))
1474 else if (GET_CODE (XVECEXP (body
, 0, 0)) == ASM_OPERANDS
)
1476 /* 0 outputs, but some clobbers:
1477 body is [(asm_operands ...) (clobber (reg ...))...]. */
1480 /* Make sure all the other parallel things really are clobbers. */
1481 for (i
= XVECLEN (body
, 0) - 1; i
> 0; i
--)
1482 if (GET_CODE (XVECEXP (body
, 0, i
)) != CLOBBER
)
1485 return ASM_OPERANDS_INPUT_LENGTH (XVECEXP (body
, 0, 0));
1494 /* Assuming BODY is an insn body that uses ASM_OPERANDS,
1495 copy its operands (both input and output) into the vector OPERANDS,
1496 the locations of the operands within the insn into the vector OPERAND_LOCS,
1497 and the constraints for the operands into CONSTRAINTS.
1498 Write the modes of the operands into MODES.
1499 Return the assembler-template.
1501 If MODES, OPERAND_LOCS, CONSTRAINTS or OPERANDS is 0,
1502 we don't store that info. */
1505 decode_asm_operands (body
, operands
, operand_locs
, constraints
, modes
)
1509 const char **constraints
;
1510 enum machine_mode
*modes
;
1514 const char *template = 0;
1516 if (GET_CODE (body
) == SET
&& GET_CODE (SET_SRC (body
)) == ASM_OPERANDS
)
1518 rtx asmop
= SET_SRC (body
);
1519 /* Single output operand: BODY is (set OUTPUT (asm_operands ....)). */
1521 noperands
= ASM_OPERANDS_INPUT_LENGTH (asmop
) + 1;
1523 for (i
= 1; i
< noperands
; i
++)
1526 operand_locs
[i
] = &ASM_OPERANDS_INPUT (asmop
, i
- 1);
1528 operands
[i
] = ASM_OPERANDS_INPUT (asmop
, i
- 1);
1530 constraints
[i
] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop
, i
- 1);
1532 modes
[i
] = ASM_OPERANDS_INPUT_MODE (asmop
, i
- 1);
1535 /* The output is in the SET.
1536 Its constraint is in the ASM_OPERANDS itself. */
1538 operands
[0] = SET_DEST (body
);
1540 operand_locs
[0] = &SET_DEST (body
);
1542 constraints
[0] = ASM_OPERANDS_OUTPUT_CONSTRAINT (asmop
);
1544 modes
[0] = GET_MODE (SET_DEST (body
));
1545 template = ASM_OPERANDS_TEMPLATE (asmop
);
1547 else if (GET_CODE (body
) == ASM_OPERANDS
)
1550 /* No output operands: BODY is (asm_operands ....). */
1552 noperands
= ASM_OPERANDS_INPUT_LENGTH (asmop
);
1554 /* The input operands are found in the 1st element vector. */
1555 /* Constraints for inputs are in the 2nd element vector. */
1556 for (i
= 0; i
< noperands
; i
++)
1559 operand_locs
[i
] = &ASM_OPERANDS_INPUT (asmop
, i
);
1561 operands
[i
] = ASM_OPERANDS_INPUT (asmop
, i
);
1563 constraints
[i
] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop
, i
);
1565 modes
[i
] = ASM_OPERANDS_INPUT_MODE (asmop
, i
);
1567 template = ASM_OPERANDS_TEMPLATE (asmop
);
1569 else if (GET_CODE (body
) == PARALLEL
1570 && GET_CODE (XVECEXP (body
, 0, 0)) == SET
1571 && GET_CODE (SET_SRC (XVECEXP (body
, 0, 0))) == ASM_OPERANDS
)
1573 rtx asmop
= SET_SRC (XVECEXP (body
, 0, 0));
1574 int nparallel
= XVECLEN (body
, 0); /* Includes CLOBBERs. */
1575 int nin
= ASM_OPERANDS_INPUT_LENGTH (asmop
);
1576 int nout
= 0; /* Does not include CLOBBERs. */
1578 /* At least one output, plus some CLOBBERs. */
1580 /* The outputs are in the SETs.
1581 Their constraints are in the ASM_OPERANDS itself. */
1582 for (i
= 0; i
< nparallel
; i
++)
1584 if (GET_CODE (XVECEXP (body
, 0, i
)) == CLOBBER
)
1585 break; /* Past last SET */
1588 operands
[i
] = SET_DEST (XVECEXP (body
, 0, i
));
1590 operand_locs
[i
] = &SET_DEST (XVECEXP (body
, 0, i
));
1592 constraints
[i
] = XSTR (SET_SRC (XVECEXP (body
, 0, i
)), 1);
1594 modes
[i
] = GET_MODE (SET_DEST (XVECEXP (body
, 0, i
)));
1598 for (i
= 0; i
< nin
; i
++)
1601 operand_locs
[i
+ nout
] = &ASM_OPERANDS_INPUT (asmop
, i
);
1603 operands
[i
+ nout
] = ASM_OPERANDS_INPUT (asmop
, i
);
1605 constraints
[i
+ nout
] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop
, i
);
1607 modes
[i
+ nout
] = ASM_OPERANDS_INPUT_MODE (asmop
, i
);
1610 template = ASM_OPERANDS_TEMPLATE (asmop
);
1612 else if (GET_CODE (body
) == PARALLEL
1613 && GET_CODE (XVECEXP (body
, 0, 0)) == ASM_OPERANDS
)
1615 /* No outputs, but some CLOBBERs. */
1617 rtx asmop
= XVECEXP (body
, 0, 0);
1618 int nin
= ASM_OPERANDS_INPUT_LENGTH (asmop
);
1620 for (i
= 0; i
< nin
; i
++)
1623 operand_locs
[i
] = &ASM_OPERANDS_INPUT (asmop
, i
);
1625 operands
[i
] = ASM_OPERANDS_INPUT (asmop
, i
);
1627 constraints
[i
] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop
, i
);
1629 modes
[i
] = ASM_OPERANDS_INPUT_MODE (asmop
, i
);
1632 template = ASM_OPERANDS_TEMPLATE (asmop
);
1638 /* Check if an asm_operand matches it's constraints.
1639 Return > 0 if ok, = 0 if bad, < 0 if inconclusive. */
1642 asm_operand_ok (op
, constraint
)
1644 const char *constraint
;
1648 /* Use constrain_operands after reload. */
1649 if (reload_completed
)
1654 char c
= *constraint
++;
1668 case '0': case '1': case '2': case '3': case '4':
1669 case '5': case '6': case '7': case '8': case '9':
1670 /* For best results, our caller should have given us the
1671 proper matching constraint, but we can't actually fail
1672 the check if they didn't. Indicate that results are
1674 while (ISDIGIT (*constraint
))
1680 if (address_operand (op
, VOIDmode
))
1685 case 'V': /* non-offsettable */
1686 if (memory_operand (op
, VOIDmode
))
1690 case 'o': /* offsettable */
1691 if (offsettable_nonstrict_memref_p (op
))
1696 /* ??? Before flow, auto inc/dec insns are not supposed to exist,
1697 excepting those that expand_call created. Further, on some
1698 machines which do not have generalized auto inc/dec, an inc/dec
1699 is not a memory_operand.
1701 Match any memory and hope things are resolved after reload. */
1703 if (GET_CODE (op
) == MEM
1705 || GET_CODE (XEXP (op
, 0)) == PRE_DEC
1706 || GET_CODE (XEXP (op
, 0)) == POST_DEC
))
1711 if (GET_CODE (op
) == MEM
1713 || GET_CODE (XEXP (op
, 0)) == PRE_INC
1714 || GET_CODE (XEXP (op
, 0)) == POST_INC
))
1720 if (GET_CODE (op
) == CONST_DOUBLE
)
1725 if (GET_CODE (op
) == CONST_DOUBLE
1726 && CONST_DOUBLE_OK_FOR_LETTER_P (op
, 'G'))
1730 if (GET_CODE (op
) == CONST_DOUBLE
1731 && CONST_DOUBLE_OK_FOR_LETTER_P (op
, 'H'))
1736 if (GET_CODE (op
) == CONST_INT
1737 || (GET_CODE (op
) == CONST_DOUBLE
1738 && GET_MODE (op
) == VOIDmode
))
1744 #ifdef LEGITIMATE_PIC_OPERAND_P
1745 && (! flag_pic
|| LEGITIMATE_PIC_OPERAND_P (op
))
1752 if (GET_CODE (op
) == CONST_INT
1753 || (GET_CODE (op
) == CONST_DOUBLE
1754 && GET_MODE (op
) == VOIDmode
))
1759 if (GET_CODE (op
) == CONST_INT
1760 && CONST_OK_FOR_LETTER_P (INTVAL (op
), 'I'))
1764 if (GET_CODE (op
) == CONST_INT
1765 && CONST_OK_FOR_LETTER_P (INTVAL (op
), 'J'))
1769 if (GET_CODE (op
) == CONST_INT
1770 && CONST_OK_FOR_LETTER_P (INTVAL (op
), 'K'))
1774 if (GET_CODE (op
) == CONST_INT
1775 && CONST_OK_FOR_LETTER_P (INTVAL (op
), 'L'))
1779 if (GET_CODE (op
) == CONST_INT
1780 && CONST_OK_FOR_LETTER_P (INTVAL (op
), 'M'))
1784 if (GET_CODE (op
) == CONST_INT
1785 && CONST_OK_FOR_LETTER_P (INTVAL (op
), 'N'))
1789 if (GET_CODE (op
) == CONST_INT
1790 && CONST_OK_FOR_LETTER_P (INTVAL (op
), 'O'))
1794 if (GET_CODE (op
) == CONST_INT
1795 && CONST_OK_FOR_LETTER_P (INTVAL (op
), 'P'))
1803 if (general_operand (op
, VOIDmode
))
1808 /* For all other letters, we first check for a register class,
1809 otherwise it is an EXTRA_CONSTRAINT. */
1810 if (REG_CLASS_FROM_LETTER (c
) != NO_REGS
)
1813 if (GET_MODE (op
) == BLKmode
)
1815 if (register_operand (op
, VOIDmode
))
1818 #ifdef EXTRA_CONSTRAINT
1819 if (EXTRA_CONSTRAINT (op
, c
))
1829 /* Given an rtx *P, if it is a sum containing an integer constant term,
1830 return the location (type rtx *) of the pointer to that constant term.
1831 Otherwise, return a null pointer. */
1834 find_constant_term_loc (p
)
1838 enum rtx_code code
= GET_CODE (*p
);
1840 /* If *P IS such a constant term, P is its location. */
1842 if (code
== CONST_INT
|| code
== SYMBOL_REF
|| code
== LABEL_REF
1846 /* Otherwise, if not a sum, it has no constant term. */
1848 if (GET_CODE (*p
) != PLUS
)
1851 /* If one of the summands is constant, return its location. */
1853 if (XEXP (*p
, 0) && CONSTANT_P (XEXP (*p
, 0))
1854 && XEXP (*p
, 1) && CONSTANT_P (XEXP (*p
, 1)))
1857 /* Otherwise, check each summand for containing a constant term. */
1859 if (XEXP (*p
, 0) != 0)
1861 tem
= find_constant_term_loc (&XEXP (*p
, 0));
1866 if (XEXP (*p
, 1) != 0)
1868 tem
= find_constant_term_loc (&XEXP (*p
, 1));
1876 /* Return 1 if OP is a memory reference
1877 whose address contains no side effects
1878 and remains valid after the addition
1879 of a positive integer less than the
1880 size of the object being referenced.
1882 We assume that the original address is valid and do not check it.
1884 This uses strict_memory_address_p as a subroutine, so
1885 don't use it before reload. */
1888 offsettable_memref_p (op
)
1891 return ((GET_CODE (op
) == MEM
)
1892 && offsettable_address_p (1, GET_MODE (op
), XEXP (op
, 0)));
1895 /* Similar, but don't require a strictly valid mem ref:
1896 consider pseudo-regs valid as index or base regs. */
1899 offsettable_nonstrict_memref_p (op
)
1902 return ((GET_CODE (op
) == MEM
)
1903 && offsettable_address_p (0, GET_MODE (op
), XEXP (op
, 0)));
1906 /* Return 1 if Y is a memory address which contains no side effects
1907 and would remain valid after the addition of a positive integer
1908 less than the size of that mode.
1910 We assume that the original address is valid and do not check it.
1911 We do check that it is valid for narrower modes.
1913 If STRICTP is nonzero, we require a strictly valid address,
1914 for the sake of use in reload.c. */
1917 offsettable_address_p (strictp
, mode
, y
)
1919 enum machine_mode mode
;
1922 enum rtx_code ycode
= GET_CODE (y
);
1926 int (*addressp
) PARAMS ((enum machine_mode
, rtx
)) =
1927 (strictp
? strict_memory_address_p
: memory_address_p
);
1928 unsigned int mode_sz
= GET_MODE_SIZE (mode
);
1930 if (CONSTANT_ADDRESS_P (y
))
1933 /* Adjusting an offsettable address involves changing to a narrower mode.
1934 Make sure that's OK. */
1936 if (mode_dependent_address_p (y
))
1939 /* ??? How much offset does an offsettable BLKmode reference need?
1940 Clearly that depends on the situation in which it's being used.
1941 However, the current situation in which we test 0xffffffff is
1942 less than ideal. Caveat user. */
1944 mode_sz
= BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
;
1946 /* If the expression contains a constant term,
1947 see if it remains valid when max possible offset is added. */
1949 if ((ycode
== PLUS
) && (y2
= find_constant_term_loc (&y1
)))
1954 *y2
= plus_constant (*y2
, mode_sz
- 1);
1955 /* Use QImode because an odd displacement may be automatically invalid
1956 for any wider mode. But it should be valid for a single byte. */
1957 good
= (*addressp
) (QImode
, y
);
1959 /* In any case, restore old contents of memory. */
1964 if (GET_RTX_CLASS (ycode
) == 'a')
1967 /* The offset added here is chosen as the maximum offset that
1968 any instruction could need to add when operating on something
1969 of the specified mode. We assume that if Y and Y+c are
1970 valid addresses then so is Y+d for all 0<d<c. adjust_address will
1971 go inside a LO_SUM here, so we do so as well. */
1972 if (GET_CODE (y
) == LO_SUM
)
1973 z
= gen_rtx_LO_SUM (GET_MODE (y
), XEXP (y
, 0),
1974 plus_constant (XEXP (y
, 1), mode_sz
- 1));
1976 z
= plus_constant (y
, mode_sz
- 1);
1978 /* Use QImode because an odd displacement may be automatically invalid
1979 for any wider mode. But it should be valid for a single byte. */
1980 return (*addressp
) (QImode
, z
);
1983 /* Return 1 if ADDR is an address-expression whose effect depends
1984 on the mode of the memory reference it is used in.
1986 Autoincrement addressing is a typical example of mode-dependence
1987 because the amount of the increment depends on the mode. */
1990 mode_dependent_address_p (addr
)
1991 rtx addr ATTRIBUTE_UNUSED
; /* Maybe used in GO_IF_MODE_DEPENDENT_ADDRESS. */
1993 GO_IF_MODE_DEPENDENT_ADDRESS (addr
, win
);
1995 /* Label `win' might (not) be used via GO_IF_MODE_DEPENDENT_ADDRESS. */
1996 win
: ATTRIBUTE_UNUSED_LABEL
2000 /* Return 1 if OP is a general operand
2001 other than a memory ref with a mode dependent address. */
2004 mode_independent_operand (op
, mode
)
2005 enum machine_mode mode
;
2010 if (! general_operand (op
, mode
))
2013 if (GET_CODE (op
) != MEM
)
2016 addr
= XEXP (op
, 0);
2017 GO_IF_MODE_DEPENDENT_ADDRESS (addr
, lose
);
2019 /* Label `lose' might (not) be used via GO_IF_MODE_DEPENDENT_ADDRESS. */
2020 lose
: ATTRIBUTE_UNUSED_LABEL
2024 /* Like extract_insn, but save insn extracted and don't extract again, when
2025 called again for the same insn expecting that recog_data still contain the
2026 valid information. This is used primary by gen_attr infrastructure that
2027 often does extract insn again and again. */
2029 extract_insn_cached (insn
)
2032 if (recog_data
.insn
== insn
&& INSN_CODE (insn
) >= 0)
2034 extract_insn (insn
);
2035 recog_data
.insn
= insn
;
2037 /* Do cached extract_insn, constrain_operand and complain about failures.
2038 Used by insn_attrtab. */
2040 extract_constrain_insn_cached (insn
)
2043 extract_insn_cached (insn
);
2044 if (which_alternative
== -1
2045 && !constrain_operands (reload_completed
))
2046 fatal_insn_not_found (insn
);
2048 /* Do cached constrain_operand and complain about failures. */
2050 constrain_operands_cached (strict
)
2053 if (which_alternative
== -1)
2054 return constrain_operands (strict
);
2059 /* Analyze INSN and fill in recog_data. */
2068 rtx body
= PATTERN (insn
);
2070 recog_data
.insn
= NULL
;
2071 recog_data
.n_operands
= 0;
2072 recog_data
.n_alternatives
= 0;
2073 recog_data
.n_dups
= 0;
2074 which_alternative
= -1;
2076 switch (GET_CODE (body
))
2086 if (GET_CODE (SET_SRC (body
)) == ASM_OPERANDS
)
2091 if ((GET_CODE (XVECEXP (body
, 0, 0)) == SET
2092 && GET_CODE (SET_SRC (XVECEXP (body
, 0, 0))) == ASM_OPERANDS
)
2093 || GET_CODE (XVECEXP (body
, 0, 0)) == ASM_OPERANDS
)
2099 recog_data
.n_operands
= noperands
= asm_noperands (body
);
2102 /* This insn is an `asm' with operands. */
2104 /* expand_asm_operands makes sure there aren't too many operands. */
2105 if (noperands
> MAX_RECOG_OPERANDS
)
2108 /* Now get the operand values and constraints out of the insn. */
2109 decode_asm_operands (body
, recog_data
.operand
,
2110 recog_data
.operand_loc
,
2111 recog_data
.constraints
,
2112 recog_data
.operand_mode
);
2115 const char *p
= recog_data
.constraints
[0];
2116 recog_data
.n_alternatives
= 1;
2118 recog_data
.n_alternatives
+= (*p
++ == ',');
2122 fatal_insn_not_found (insn
);
2126 /* Ordinary insn: recognize it, get the operands via insn_extract
2127 and get the constraints. */
2129 icode
= recog_memoized (insn
);
2131 fatal_insn_not_found (insn
);
2133 recog_data
.n_operands
= noperands
= insn_data
[icode
].n_operands
;
2134 recog_data
.n_alternatives
= insn_data
[icode
].n_alternatives
;
2135 recog_data
.n_dups
= insn_data
[icode
].n_dups
;
2137 insn_extract (insn
);
2139 for (i
= 0; i
< noperands
; i
++)
2141 recog_data
.constraints
[i
] = insn_data
[icode
].operand
[i
].constraint
;
2142 recog_data
.operand_mode
[i
] = insn_data
[icode
].operand
[i
].mode
;
2143 /* VOIDmode match_operands gets mode from their real operand. */
2144 if (recog_data
.operand_mode
[i
] == VOIDmode
)
2145 recog_data
.operand_mode
[i
] = GET_MODE (recog_data
.operand
[i
]);
2148 for (i
= 0; i
< noperands
; i
++)
2149 recog_data
.operand_type
[i
]
2150 = (recog_data
.constraints
[i
][0] == '=' ? OP_OUT
2151 : recog_data
.constraints
[i
][0] == '+' ? OP_INOUT
2154 if (recog_data
.n_alternatives
> MAX_RECOG_ALTERNATIVES
)
2158 /* After calling extract_insn, you can use this function to extract some
2159 information from the constraint strings into a more usable form.
2160 The collected data is stored in recog_op_alt. */
2162 preprocess_constraints ()
2166 memset (recog_op_alt
, 0, sizeof recog_op_alt
);
2167 for (i
= 0; i
< recog_data
.n_operands
; i
++)
2170 struct operand_alternative
*op_alt
;
2171 const char *p
= recog_data
.constraints
[i
];
2173 op_alt
= recog_op_alt
[i
];
2175 for (j
= 0; j
< recog_data
.n_alternatives
; j
++)
2177 op_alt
[j
].class = NO_REGS
;
2178 op_alt
[j
].constraint
= p
;
2179 op_alt
[j
].matches
= -1;
2180 op_alt
[j
].matched
= -1;
2182 if (*p
== '\0' || *p
== ',')
2184 op_alt
[j
].anything_ok
= 1;
2194 while (c
!= ',' && c
!= '\0');
2195 if (c
== ',' || c
== '\0')
2200 case '=': case '+': case '*': case '%':
2201 case 'E': case 'F': case 'G': case 'H':
2202 case 's': case 'i': case 'n':
2203 case 'I': case 'J': case 'K': case 'L':
2204 case 'M': case 'N': case 'O': case 'P':
2205 /* These don't say anything we care about. */
2209 op_alt
[j
].reject
+= 6;
2212 op_alt
[j
].reject
+= 600;
2215 op_alt
[j
].earlyclobber
= 1;
2218 case '0': case '1': case '2': case '3': case '4':
2219 case '5': case '6': case '7': case '8': case '9':
2222 op_alt
[j
].matches
= strtoul (p
- 1, &end
, 10);
2223 recog_op_alt
[op_alt
[j
].matches
][j
].matched
= i
;
2229 op_alt
[j
].memory_ok
= 1;
2232 op_alt
[j
].decmem_ok
= 1;
2235 op_alt
[j
].incmem_ok
= 1;
2238 op_alt
[j
].nonoffmem_ok
= 1;
2241 op_alt
[j
].offmem_ok
= 1;
2244 op_alt
[j
].anything_ok
= 1;
2248 op_alt
[j
].is_address
= 1;
2249 op_alt
[j
].class = reg_class_subunion
[(int) op_alt
[j
].class]
2250 [(int) MODE_BASE_REG_CLASS (VOIDmode
)];
2254 op_alt
[j
].class = reg_class_subunion
[(int) op_alt
[j
].class][(int) GENERAL_REGS
];
2258 op_alt
[j
].class = reg_class_subunion
[(int) op_alt
[j
].class][(int) REG_CLASS_FROM_LETTER ((unsigned char) c
)];
2266 /* Check the operands of an insn against the insn's operand constraints
2267 and return 1 if they are valid.
2268 The information about the insn's operands, constraints, operand modes
2269 etc. is obtained from the global variables set up by extract_insn.
2271 WHICH_ALTERNATIVE is set to a number which indicates which
2272 alternative of constraints was matched: 0 for the first alternative,
2273 1 for the next, etc.
2275 In addition, when two operands are match
2276 and it happens that the output operand is (reg) while the
2277 input operand is --(reg) or ++(reg) (a pre-inc or pre-dec),
2278 make the output operand look like the input.
2279 This is because the output operand is the one the template will print.
2281 This is used in final, just before printing the assembler code and by
2282 the routines that determine an insn's attribute.
2284 If STRICT is a positive non-zero value, it means that we have been
2285 called after reload has been completed. In that case, we must
2286 do all checks strictly. If it is zero, it means that we have been called
2287 before reload has completed. In that case, we first try to see if we can
2288 find an alternative that matches strictly. If not, we try again, this
2289 time assuming that reload will fix up the insn. This provides a "best
2290 guess" for the alternative and is used to compute attributes of insns prior
2291 to reload. A negative value of STRICT is used for this internal call. */
2299 constrain_operands (strict
)
2302 const char *constraints
[MAX_RECOG_OPERANDS
];
2303 int matching_operands
[MAX_RECOG_OPERANDS
];
2304 int earlyclobber
[MAX_RECOG_OPERANDS
];
2307 struct funny_match funny_match
[MAX_RECOG_OPERANDS
];
2308 int funny_match_index
;
2310 which_alternative
= 0;
2311 if (recog_data
.n_operands
== 0 || recog_data
.n_alternatives
== 0)
2314 for (c
= 0; c
< recog_data
.n_operands
; c
++)
2316 constraints
[c
] = recog_data
.constraints
[c
];
2317 matching_operands
[c
] = -1;
2324 funny_match_index
= 0;
2326 for (opno
= 0; opno
< recog_data
.n_operands
; opno
++)
2328 rtx op
= recog_data
.operand
[opno
];
2329 enum machine_mode mode
= GET_MODE (op
);
2330 const char *p
= constraints
[opno
];
2335 earlyclobber
[opno
] = 0;
2337 /* A unary operator may be accepted by the predicate, but it
2338 is irrelevant for matching constraints. */
2339 if (GET_RTX_CLASS (GET_CODE (op
)) == '1')
2342 if (GET_CODE (op
) == SUBREG
)
2344 if (GET_CODE (SUBREG_REG (op
)) == REG
2345 && REGNO (SUBREG_REG (op
)) < FIRST_PSEUDO_REGISTER
)
2346 offset
= subreg_regno_offset (REGNO (SUBREG_REG (op
)),
2347 GET_MODE (SUBREG_REG (op
)),
2350 op
= SUBREG_REG (op
);
2353 /* An empty constraint or empty alternative
2354 allows anything which matched the pattern. */
2355 if (*p
== 0 || *p
== ',')
2358 while (*p
&& (c
= *p
++) != ',')
2361 case '?': case '!': case '*': case '%':
2366 /* Ignore rest of this alternative as far as
2367 constraint checking is concerned. */
2368 while (*p
&& *p
!= ',')
2373 earlyclobber
[opno
] = 1;
2376 case '0': case '1': case '2': case '3': case '4':
2377 case '5': case '6': case '7': case '8': case '9':
2379 /* This operand must be the same as a previous one.
2380 This kind of constraint is used for instructions such
2381 as add when they take only two operands.
2383 Note that the lower-numbered operand is passed first.
2385 If we are not testing strictly, assume that this
2386 constraint will be satisfied. */
2391 match
= strtoul (p
- 1, &end
, 10);
2398 rtx op1
= recog_data
.operand
[match
];
2399 rtx op2
= recog_data
.operand
[opno
];
2401 /* A unary operator may be accepted by the predicate,
2402 but it is irrelevant for matching constraints. */
2403 if (GET_RTX_CLASS (GET_CODE (op1
)) == '1')
2404 op1
= XEXP (op1
, 0);
2405 if (GET_RTX_CLASS (GET_CODE (op2
)) == '1')
2406 op2
= XEXP (op2
, 0);
2408 val
= operands_match_p (op1
, op2
);
2411 matching_operands
[opno
] = match
;
2412 matching_operands
[match
] = opno
;
2417 /* If output is *x and input is *--x, arrange later
2418 to change the output to *--x as well, since the
2419 output op is the one that will be printed. */
2420 if (val
== 2 && strict
> 0)
2422 funny_match
[funny_match_index
].this = opno
;
2423 funny_match
[funny_match_index
++].other
= match
;
2429 /* p is used for address_operands. When we are called by
2430 gen_reload, no one will have checked that the address is
2431 strictly valid, i.e., that all pseudos requiring hard regs
2432 have gotten them. */
2434 || (strict_memory_address_p (recog_data
.operand_mode
[opno
],
2439 /* No need to check general_operand again;
2440 it was done in insn-recog.c. */
2442 /* Anything goes unless it is a REG and really has a hard reg
2443 but the hard reg is not in the class GENERAL_REGS. */
2445 || GENERAL_REGS
== ALL_REGS
2446 || GET_CODE (op
) != REG
2447 || (reload_in_progress
2448 && REGNO (op
) >= FIRST_PSEUDO_REGISTER
)
2449 || reg_fits_class_p (op
, GENERAL_REGS
, offset
, mode
))
2454 /* This is used for a MATCH_SCRATCH in the cases when
2455 we don't actually need anything. So anything goes
2461 if (GET_CODE (op
) == MEM
2462 /* Before reload, accept what reload can turn into mem. */
2463 || (strict
< 0 && CONSTANT_P (op
))
2464 /* During reload, accept a pseudo */
2465 || (reload_in_progress
&& GET_CODE (op
) == REG
2466 && REGNO (op
) >= FIRST_PSEUDO_REGISTER
))
2471 if (GET_CODE (op
) == MEM
2472 && (GET_CODE (XEXP (op
, 0)) == PRE_DEC
2473 || GET_CODE (XEXP (op
, 0)) == POST_DEC
))
2478 if (GET_CODE (op
) == MEM
2479 && (GET_CODE (XEXP (op
, 0)) == PRE_INC
2480 || GET_CODE (XEXP (op
, 0)) == POST_INC
))
2486 if (GET_CODE (op
) == CONST_DOUBLE
)
2492 if (GET_CODE (op
) == CONST_DOUBLE
2493 && CONST_DOUBLE_OK_FOR_LETTER_P (op
, c
))
2498 if (GET_CODE (op
) == CONST_INT
2499 || (GET_CODE (op
) == CONST_DOUBLE
2500 && GET_MODE (op
) == VOIDmode
))
2503 if (CONSTANT_P (op
))
2508 if (GET_CODE (op
) == CONST_INT
2509 || (GET_CODE (op
) == CONST_DOUBLE
2510 && GET_MODE (op
) == VOIDmode
))
2522 if (GET_CODE (op
) == CONST_INT
2523 && CONST_OK_FOR_LETTER_P (INTVAL (op
), c
))
2528 if (GET_CODE (op
) == MEM
2529 && ((strict
> 0 && ! offsettable_memref_p (op
))
2531 && !(CONSTANT_P (op
) || GET_CODE (op
) == MEM
))
2532 || (reload_in_progress
2533 && !(GET_CODE (op
) == REG
2534 && REGNO (op
) >= FIRST_PSEUDO_REGISTER
))))
2539 if ((strict
> 0 && offsettable_memref_p (op
))
2540 || (strict
== 0 && offsettable_nonstrict_memref_p (op
))
2541 /* Before reload, accept what reload can handle. */
2543 && (CONSTANT_P (op
) || GET_CODE (op
) == MEM
))
2544 /* During reload, accept a pseudo */
2545 || (reload_in_progress
&& GET_CODE (op
) == REG
2546 && REGNO (op
) >= FIRST_PSEUDO_REGISTER
))
2552 enum reg_class
class;
2554 class = (c
== 'r' ? GENERAL_REGS
: REG_CLASS_FROM_LETTER (c
));
2555 if (class != NO_REGS
)
2559 && GET_CODE (op
) == REG
2560 && REGNO (op
) >= FIRST_PSEUDO_REGISTER
)
2561 || (strict
== 0 && GET_CODE (op
) == SCRATCH
)
2562 || (GET_CODE (op
) == REG
2563 && reg_fits_class_p (op
, class, offset
, mode
)))
2566 #ifdef EXTRA_CONSTRAINT
2567 else if (EXTRA_CONSTRAINT (op
, c
))
2574 constraints
[opno
] = p
;
2575 /* If this operand did not win somehow,
2576 this alternative loses. */
2580 /* This alternative won; the operands are ok.
2581 Change whichever operands this alternative says to change. */
2586 /* See if any earlyclobber operand conflicts with some other
2590 for (eopno
= 0; eopno
< recog_data
.n_operands
; eopno
++)
2591 /* Ignore earlyclobber operands now in memory,
2592 because we would often report failure when we have
2593 two memory operands, one of which was formerly a REG. */
2594 if (earlyclobber
[eopno
]
2595 && GET_CODE (recog_data
.operand
[eopno
]) == REG
)
2596 for (opno
= 0; opno
< recog_data
.n_operands
; opno
++)
2597 if ((GET_CODE (recog_data
.operand
[opno
]) == MEM
2598 || recog_data
.operand_type
[opno
] != OP_OUT
)
2600 /* Ignore things like match_operator operands. */
2601 && *recog_data
.constraints
[opno
] != 0
2602 && ! (matching_operands
[opno
] == eopno
2603 && operands_match_p (recog_data
.operand
[opno
],
2604 recog_data
.operand
[eopno
]))
2605 && ! safe_from_earlyclobber (recog_data
.operand
[opno
],
2606 recog_data
.operand
[eopno
]))
2611 while (--funny_match_index
>= 0)
2613 recog_data
.operand
[funny_match
[funny_match_index
].other
]
2614 = recog_data
.operand
[funny_match
[funny_match_index
].this];
2621 which_alternative
++;
2623 while (which_alternative
< recog_data
.n_alternatives
);
2625 which_alternative
= -1;
2626 /* If we are about to reject this, but we are not to test strictly,
2627 try a very loose test. Only return failure if it fails also. */
2629 return constrain_operands (-1);
2634 /* Return 1 iff OPERAND (assumed to be a REG rtx)
2635 is a hard reg in class CLASS when its regno is offset by OFFSET
2636 and changed to mode MODE.
2637 If REG occupies multiple hard regs, all of them must be in CLASS. */
2640 reg_fits_class_p (operand
, class, offset
, mode
)
2642 enum reg_class
class;
2644 enum machine_mode mode
;
2646 int regno
= REGNO (operand
);
2647 if (regno
< FIRST_PSEUDO_REGISTER
2648 && TEST_HARD_REG_BIT (reg_class_contents
[(int) class],
2653 for (sr
= HARD_REGNO_NREGS (regno
, mode
) - 1;
2655 if (! TEST_HARD_REG_BIT (reg_class_contents
[(int) class],
2664 /* Split single instruction. Helper function for split_all_insns.
2665 Return last insn in the sequence if successful, or NULL if unsuccessful. */
2673 /* Don't split no-op move insns. These should silently
2674 disappear later in final. Splitting such insns would
2675 break the code that handles REG_NO_CONFLICT blocks. */
2677 else if ((set
= single_set (insn
)) != NULL
&& set_noop_p (set
))
2679 /* Nops get in the way while scheduling, so delete them
2680 now if register allocation has already been done. It
2681 is too risky to try to do this before register
2682 allocation, and there are unlikely to be very many
2683 nops then anyways. */
2684 if (reload_completed
)
2685 delete_insn_and_edges (insn
);
2689 /* Split insns here to get max fine-grain parallelism. */
2690 rtx first
= PREV_INSN (insn
);
2691 rtx last
= try_split (PATTERN (insn
), insn
, 1);
2695 /* try_split returns the NOTE that INSN became. */
2696 PUT_CODE (insn
, NOTE
);
2697 NOTE_SOURCE_FILE (insn
) = 0;
2698 NOTE_LINE_NUMBER (insn
) = NOTE_INSN_DELETED
;
2700 /* ??? Coddle to md files that generate subregs in post-
2701 reload splitters instead of computing the proper
2703 if (reload_completed
&& first
!= last
)
2705 first
= NEXT_INSN (first
);
2709 cleanup_subreg_operands (first
);
2712 first
= NEXT_INSN (first
);
2720 /* Split all insns in the function. If UPD_LIFE, update life info after. */
2723 split_all_insns (upd_life
)
2730 blocks
= sbitmap_alloc (n_basic_blocks
);
2731 sbitmap_zero (blocks
);
2734 for (i
= n_basic_blocks
- 1; i
>= 0; --i
)
2736 basic_block bb
= BASIC_BLOCK (i
);
2738 bool finish
= false;
2740 for (insn
= bb
->head
; !finish
; insn
= next
)
2744 /* Can't use `next_real_insn' because that might go across
2745 CODE_LABELS and short-out basic blocks. */
2746 next
= NEXT_INSN (insn
);
2747 finish
= (insn
== bb
->end
);
2748 last
= split_insn (insn
);
2751 /* The split sequence may include barrier, but the
2752 BB boundary we are interested in will be set to previous
2755 while (GET_CODE (last
) == BARRIER
)
2756 last
= PREV_INSN (last
);
2757 SET_BIT (blocks
, i
);
2766 find_many_sub_basic_blocks (blocks
);
2769 if (changed
&& upd_life
)
2771 count_or_remove_death_notes (blocks
, 1);
2772 update_life_info (blocks
, UPDATE_LIFE_LOCAL
, PROP_DEATH_NOTES
);
2774 #ifdef ENABLE_CHECKING
2775 verify_flow_info ();
2778 sbitmap_free (blocks
);
2781 /* Same as split_all_insns, but do not expect CFG to be available.
2782 Used by machine depedent reorg passes. */
2785 split_all_insns_noflow ()
2789 for (insn
= get_insns (); insn
; insn
= next
)
2791 next
= NEXT_INSN (insn
);
2797 #ifdef HAVE_peephole2
2798 struct peep2_insn_data
2804 static struct peep2_insn_data peep2_insn_data
[MAX_INSNS_PER_PEEP2
+ 1];
2805 static int peep2_current
;
2807 /* A non-insn marker indicating the last insn of the block.
2808 The live_before regset for this element is correct, indicating
2809 global_live_at_end for the block. */
2810 #define PEEP2_EOB pc_rtx
2812 /* Return the Nth non-note insn after `current', or return NULL_RTX if it
2813 does not exist. Used by the recognizer to find the next insn to match
2814 in a multi-insn pattern. */
2820 if (n
>= MAX_INSNS_PER_PEEP2
+ 1)
2824 if (n
>= MAX_INSNS_PER_PEEP2
+ 1)
2825 n
-= MAX_INSNS_PER_PEEP2
+ 1;
2827 if (peep2_insn_data
[n
].insn
== PEEP2_EOB
)
2829 return peep2_insn_data
[n
].insn
;
2832 /* Return true if REGNO is dead before the Nth non-note insn
2836 peep2_regno_dead_p (ofs
, regno
)
2840 if (ofs
>= MAX_INSNS_PER_PEEP2
+ 1)
2843 ofs
+= peep2_current
;
2844 if (ofs
>= MAX_INSNS_PER_PEEP2
+ 1)
2845 ofs
-= MAX_INSNS_PER_PEEP2
+ 1;
2847 if (peep2_insn_data
[ofs
].insn
== NULL_RTX
)
2850 return ! REGNO_REG_SET_P (peep2_insn_data
[ofs
].live_before
, regno
);
2853 /* Similarly for a REG. */
2856 peep2_reg_dead_p (ofs
, reg
)
2862 if (ofs
>= MAX_INSNS_PER_PEEP2
+ 1)
2865 ofs
+= peep2_current
;
2866 if (ofs
>= MAX_INSNS_PER_PEEP2
+ 1)
2867 ofs
-= MAX_INSNS_PER_PEEP2
+ 1;
2869 if (peep2_insn_data
[ofs
].insn
== NULL_RTX
)
2872 regno
= REGNO (reg
);
2873 n
= HARD_REGNO_NREGS (regno
, GET_MODE (reg
));
2875 if (REGNO_REG_SET_P (peep2_insn_data
[ofs
].live_before
, regno
+ n
))
2880 /* Try to find a hard register of mode MODE, matching the register class in
2881 CLASS_STR, which is available at the beginning of insn CURRENT_INSN and
2882 remains available until the end of LAST_INSN. LAST_INSN may be NULL_RTX,
2883 in which case the only condition is that the register must be available
2884 before CURRENT_INSN.
2885 Registers that already have bits set in REG_SET will not be considered.
2887 If an appropriate register is available, it will be returned and the
2888 corresponding bit(s) in REG_SET will be set; otherwise, NULL_RTX is
2892 peep2_find_free_register (from
, to
, class_str
, mode
, reg_set
)
2894 const char *class_str
;
2895 enum machine_mode mode
;
2896 HARD_REG_SET
*reg_set
;
2898 static int search_ofs
;
2899 enum reg_class
class;
2903 if (from
>= MAX_INSNS_PER_PEEP2
+ 1 || to
>= MAX_INSNS_PER_PEEP2
+ 1)
2906 from
+= peep2_current
;
2907 if (from
>= MAX_INSNS_PER_PEEP2
+ 1)
2908 from
-= MAX_INSNS_PER_PEEP2
+ 1;
2909 to
+= peep2_current
;
2910 if (to
>= MAX_INSNS_PER_PEEP2
+ 1)
2911 to
-= MAX_INSNS_PER_PEEP2
+ 1;
2913 if (peep2_insn_data
[from
].insn
== NULL_RTX
)
2915 REG_SET_TO_HARD_REG_SET (live
, peep2_insn_data
[from
].live_before
);
2919 HARD_REG_SET this_live
;
2921 if (++from
>= MAX_INSNS_PER_PEEP2
+ 1)
2923 if (peep2_insn_data
[from
].insn
== NULL_RTX
)
2925 REG_SET_TO_HARD_REG_SET (this_live
, peep2_insn_data
[from
].live_before
);
2926 IOR_HARD_REG_SET (live
, this_live
);
2929 class = (class_str
[0] == 'r' ? GENERAL_REGS
2930 : REG_CLASS_FROM_LETTER (class_str
[0]));
2932 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
2934 int raw_regno
, regno
, success
, j
;
2936 /* Distribute the free registers as much as possible. */
2937 raw_regno
= search_ofs
+ i
;
2938 if (raw_regno
>= FIRST_PSEUDO_REGISTER
)
2939 raw_regno
-= FIRST_PSEUDO_REGISTER
;
2940 #ifdef REG_ALLOC_ORDER
2941 regno
= reg_alloc_order
[raw_regno
];
2946 /* Don't allocate fixed registers. */
2947 if (fixed_regs
[regno
])
2949 /* Make sure the register is of the right class. */
2950 if (! TEST_HARD_REG_BIT (reg_class_contents
[class], regno
))
2952 /* And can support the mode we need. */
2953 if (! HARD_REGNO_MODE_OK (regno
, mode
))
2955 /* And that we don't create an extra save/restore. */
2956 if (! call_used_regs
[regno
] && ! regs_ever_live
[regno
])
2958 /* And we don't clobber traceback for noreturn functions. */
2959 if ((regno
== FRAME_POINTER_REGNUM
|| regno
== HARD_FRAME_POINTER_REGNUM
)
2960 && (! reload_completed
|| frame_pointer_needed
))
2964 for (j
= HARD_REGNO_NREGS (regno
, mode
) - 1; j
>= 0; j
--)
2966 if (TEST_HARD_REG_BIT (*reg_set
, regno
+ j
)
2967 || TEST_HARD_REG_BIT (live
, regno
+ j
))
2975 for (j
= HARD_REGNO_NREGS (regno
, mode
) - 1; j
>= 0; j
--)
2976 SET_HARD_REG_BIT (*reg_set
, regno
+ j
);
2978 /* Start the next search with the next register. */
2979 if (++raw_regno
>= FIRST_PSEUDO_REGISTER
)
2981 search_ofs
= raw_regno
;
2983 return gen_rtx_REG (mode
, regno
);
2991 /* Perform the peephole2 optimization pass. */
2994 peephole2_optimize (dump_file
)
2995 FILE *dump_file ATTRIBUTE_UNUSED
;
2997 regset_head rs_heads
[MAX_INSNS_PER_PEEP2
+ 2];
3001 #ifdef HAVE_conditional_execution
3005 bool do_cleanup_cfg
= false;
3007 /* Initialize the regsets we're going to use. */
3008 for (i
= 0; i
< MAX_INSNS_PER_PEEP2
+ 1; ++i
)
3009 peep2_insn_data
[i
].live_before
= INITIALIZE_REG_SET (rs_heads
[i
]);
3010 live
= INITIALIZE_REG_SET (rs_heads
[i
]);
3012 #ifdef HAVE_conditional_execution
3013 blocks
= sbitmap_alloc (n_basic_blocks
);
3014 sbitmap_zero (blocks
);
3017 count_or_remove_death_notes (NULL
, 1);
3020 for (b
= n_basic_blocks
- 1; b
>= 0; --b
)
3022 basic_block bb
= BASIC_BLOCK (b
);
3023 struct propagate_block_info
*pbi
;
3025 /* Indicate that all slots except the last holds invalid data. */
3026 for (i
= 0; i
< MAX_INSNS_PER_PEEP2
; ++i
)
3027 peep2_insn_data
[i
].insn
= NULL_RTX
;
3029 /* Indicate that the last slot contains live_after data. */
3030 peep2_insn_data
[MAX_INSNS_PER_PEEP2
].insn
= PEEP2_EOB
;
3031 peep2_current
= MAX_INSNS_PER_PEEP2
;
3033 /* Start up propagation. */
3034 COPY_REG_SET (live
, bb
->global_live_at_end
);
3035 COPY_REG_SET (peep2_insn_data
[MAX_INSNS_PER_PEEP2
].live_before
, live
);
3037 #ifdef HAVE_conditional_execution
3038 pbi
= init_propagate_block_info (bb
, live
, NULL
, NULL
, 0);
3040 pbi
= init_propagate_block_info (bb
, live
, NULL
, NULL
, PROP_DEATH_NOTES
);
3043 for (insn
= bb
->end
; ; insn
= prev
)
3045 prev
= PREV_INSN (insn
);
3048 rtx
try, before_try
;
3052 /* Record this insn. */
3053 if (--peep2_current
< 0)
3054 peep2_current
= MAX_INSNS_PER_PEEP2
;
3055 peep2_insn_data
[peep2_current
].insn
= insn
;
3056 propagate_one_insn (pbi
, insn
);
3057 COPY_REG_SET (peep2_insn_data
[peep2_current
].live_before
, live
);
3059 /* Match the peephole. */
3060 try = peephole2_insns (PATTERN (insn
), insn
, &match_len
);
3063 /* If we are splitting a CALL_INSN, look for the CALL_INSN
3064 in SEQ and copy our CALL_INSN_FUNCTION_USAGE and other
3065 cfg-related call notes. */
3066 for (i
= 0; i
<= match_len
; ++i
)
3069 rtx old_insn
, new_insn
, note
;
3071 j
= i
+ peep2_current
;
3072 if (j
>= MAX_INSNS_PER_PEEP2
+ 1)
3073 j
-= MAX_INSNS_PER_PEEP2
+ 1;
3074 old_insn
= peep2_insn_data
[j
].insn
;
3075 if (GET_CODE (old_insn
) != CALL_INSN
)
3078 new_insn
= NULL_RTX
;
3079 if (GET_CODE (try) == SEQUENCE
)
3080 for (k
= XVECLEN (try, 0) - 1; k
>= 0; k
--)
3082 rtx x
= XVECEXP (try, 0, k
);
3083 if (GET_CODE (x
) == CALL_INSN
)
3089 else if (GET_CODE (try) == CALL_INSN
)
3094 CALL_INSN_FUNCTION_USAGE (new_insn
)
3095 = CALL_INSN_FUNCTION_USAGE (old_insn
);
3097 for (note
= REG_NOTES (old_insn
);
3099 note
= XEXP (note
, 1))
3100 switch (REG_NOTE_KIND (note
))
3104 case REG_ALWAYS_RETURN
:
3105 REG_NOTES (new_insn
)
3106 = gen_rtx_EXPR_LIST (REG_NOTE_KIND (note
),
3108 REG_NOTES (new_insn
));
3110 /* Discard all other reg notes. */
3114 /* Croak if there is another call in the sequence. */
3115 while (++i
<= match_len
)
3117 j
= i
+ peep2_current
;
3118 if (j
>= MAX_INSNS_PER_PEEP2
+ 1)
3119 j
-= MAX_INSNS_PER_PEEP2
+ 1;
3120 old_insn
= peep2_insn_data
[j
].insn
;
3121 if (GET_CODE (old_insn
) == CALL_INSN
)
3127 i
= match_len
+ peep2_current
;
3128 if (i
>= MAX_INSNS_PER_PEEP2
+ 1)
3129 i
-= MAX_INSNS_PER_PEEP2
+ 1;
3131 note
= find_reg_note (peep2_insn_data
[i
].insn
,
3132 REG_EH_REGION
, NULL_RTX
);
3134 /* Replace the old sequence with the new. */
3135 try = emit_insn_after (try, peep2_insn_data
[i
].insn
);
3136 before_try
= PREV_INSN (insn
);
3137 delete_insn_chain (insn
, peep2_insn_data
[i
].insn
);
3139 /* Re-insert the EH_REGION notes. */
3145 for (eh_edge
= bb
->succ
; eh_edge
3146 ; eh_edge
= eh_edge
->succ_next
)
3147 if (eh_edge
->flags
& EDGE_EH
)
3150 for (x
= try ; x
!= before_try
; x
= PREV_INSN (x
))
3151 if (GET_CODE (x
) == CALL_INSN
3152 || (flag_non_call_exceptions
3153 && may_trap_p (PATTERN (x
))
3154 && !find_reg_note (x
, REG_EH_REGION
, NULL
)))
3157 = gen_rtx_EXPR_LIST (REG_EH_REGION
,
3161 if (x
!= bb
->end
&& eh_edge
)
3166 nfte
= split_block (bb
, x
);
3167 flags
= EDGE_EH
| EDGE_ABNORMAL
;
3168 if (GET_CODE (x
) == CALL_INSN
)
3169 flags
|= EDGE_ABNORMAL_CALL
;
3170 nehe
= make_edge (nfte
->src
, eh_edge
->dest
,
3173 nehe
->probability
= eh_edge
->probability
;
3175 = REG_BR_PROB_BASE
- nehe
->probability
;
3177 do_cleanup_cfg
|= purge_dead_edges (nfte
->dest
);
3178 #ifdef HAVE_conditional_execution
3179 SET_BIT (blocks
, nfte
->dest
->index
);
3187 /* Converting possibly trapping insn to non-trapping is
3188 possible. Zap dummy outgoing edges. */
3189 do_cleanup_cfg
|= purge_dead_edges (bb
);
3192 #ifdef HAVE_conditional_execution
3193 /* With conditional execution, we cannot back up the
3194 live information so easily, since the conditional
3195 death data structures are not so self-contained.
3196 So record that we've made a modification to this
3197 block and update life information at the end. */
3198 SET_BIT (blocks
, b
);
3201 for (i
= 0; i
< MAX_INSNS_PER_PEEP2
+ 1; ++i
)
3202 peep2_insn_data
[i
].insn
= NULL_RTX
;
3203 peep2_insn_data
[peep2_current
].insn
= PEEP2_EOB
;
3205 /* Back up lifetime information past the end of the
3206 newly created sequence. */
3207 if (++i
>= MAX_INSNS_PER_PEEP2
+ 1)
3209 COPY_REG_SET (live
, peep2_insn_data
[i
].live_before
);
3211 /* Update life information for the new sequence. */
3217 i
= MAX_INSNS_PER_PEEP2
;
3218 peep2_insn_data
[i
].insn
= try;
3219 propagate_one_insn (pbi
, try);
3220 COPY_REG_SET (peep2_insn_data
[i
].live_before
, live
);
3222 try = PREV_INSN (try);
3224 while (try != prev
);
3226 /* ??? Should verify that LIVE now matches what we
3227 had before the new sequence. */
3234 if (insn
== bb
->head
)
3238 free_propagate_block_info (pbi
);
3241 for (i
= 0; i
< MAX_INSNS_PER_PEEP2
+ 1; ++i
)
3242 FREE_REG_SET (peep2_insn_data
[i
].live_before
);
3243 FREE_REG_SET (live
);
3245 /* If we eliminated EH edges, we may be able to merge blocks. Further,
3246 we've changed global life since exception handlers are no longer
3251 update_life_info (0, UPDATE_LIFE_GLOBAL_RM_NOTES
, PROP_DEATH_NOTES
);
3253 #ifdef HAVE_conditional_execution
3256 count_or_remove_death_notes (blocks
, 1);
3257 update_life_info (blocks
, UPDATE_LIFE_LOCAL
, PROP_DEATH_NOTES
);
3259 sbitmap_free (blocks
);
3262 #endif /* HAVE_peephole2 */