1 /* Subroutines used by or related to instruction recognition.
2 Copyright (C) 1987, 1988, 1991, 1992, 1993 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
24 #include "insn-config.h"
25 #include "insn-attr.h"
26 #include "insn-flags.h"
27 #include "insn-codes.h"
30 #include "hard-reg-set.h"
34 #ifndef STACK_PUSH_CODE
35 #ifdef STACK_GROWS_DOWNWARD
36 #define STACK_PUSH_CODE PRE_DEC
38 #define STACK_PUSH_CODE PRE_INC
42 /* Import from final.c: */
43 extern rtx
alter_subreg ();
45 int strict_memory_address_p ();
46 int memory_address_p ();
48 /* Nonzero means allow operands to be volatile.
49 This should be 0 if you are generating rtl, such as if you are calling
50 the functions in optabs.c and expmed.c (most of the time).
51 This should be 1 if all valid insns need to be recognized,
52 such as in regclass.c and final.c and reload.c.
54 init_recog and init_recog_no_volatile are responsible for setting this. */
58 /* On return from `constrain_operands', indicate which alternative
61 int which_alternative
;
63 /* Nonzero after end of reload pass.
64 Set to 1 or 0 by toplev.c.
65 Controls the significance of (SUBREG (MEM)). */
69 /* Initialize data used by the function `recog'.
70 This must be called once in the compilation of a function
71 before any insn recognition may be done in the function. */
74 init_recog_no_volatile ()
85 /* Try recognizing the instruction INSN,
86 and return the code number that results.
87 Remeber the code so that repeated calls do not
88 need to spend the time for actual rerecognition.
90 This function is the normal interface to instruction recognition.
91 The automatically-generated function `recog' is normally called
92 through this one. (The only exception is in combine.c.) */
98 if (INSN_CODE (insn
) < 0)
99 INSN_CODE (insn
) = recog (PATTERN (insn
), insn
, NULL_PTR
);
100 return INSN_CODE (insn
);
103 /* Check that X is an insn-body for an `asm' with operands
104 and that the operands mentioned in it are legitimate. */
107 check_asm_operands (x
)
110 int noperands
= asm_noperands (x
);
119 operands
= (rtx
*) alloca (noperands
* sizeof (rtx
));
120 decode_asm_operands (x
, operands
, NULL_PTR
, NULL_PTR
, NULL_PTR
);
122 for (i
= 0; i
< noperands
; i
++)
123 if (!general_operand (operands
[i
], VOIDmode
))
129 /* Static data for the next two routines.
131 The maximum number of changes supported is defined as the maximum
132 number of operands times 5. This allows for repeated substitutions
133 inside complex indexed address, or, alternatively, changes in up
136 #define MAX_CHANGE_LOCS (MAX_RECOG_OPERANDS * 5)
138 static rtx change_objects
[MAX_CHANGE_LOCS
];
139 static int change_old_codes
[MAX_CHANGE_LOCS
];
140 static rtx
*change_locs
[MAX_CHANGE_LOCS
];
141 static rtx change_olds
[MAX_CHANGE_LOCS
];
143 static int num_changes
= 0;
145 /* Validate a proposed change to OBJECT. LOC is the location in the rtl for
146 at which NEW will be placed. If OBJECT is zero, no validation is done,
147 the change is simply made.
149 Two types of objects are supported: If OBJECT is a MEM, memory_address_p
150 will be called with the address and mode as parameters. If OBJECT is
151 an INSN, CALL_INSN, or JUMP_INSN, the insn will be re-recognized with
154 IN_GROUP is non-zero if this is part of a group of changes that must be
155 performed as a group. In that case, the changes will be stored. The
156 function `apply_change_group' will validate and apply the changes.
158 If IN_GROUP is zero, this is a single change. Try to recognize the insn
159 or validate the memory reference with the change applied. If the result
160 is not valid for the machine, suppress the change and return zero.
161 Otherwise, perform the change and return 1. */
164 validate_change (object
, loc
, new, in_group
)
172 if (old
== new || rtx_equal_p (old
, new))
175 if (num_changes
>= MAX_CHANGE_LOCS
176 || (in_group
== 0 && num_changes
!= 0))
181 /* Save the information describing this change. */
182 change_objects
[num_changes
] = object
;
183 change_locs
[num_changes
] = loc
;
184 change_olds
[num_changes
] = old
;
186 if (object
&& GET_CODE (object
) != MEM
)
188 /* Set INSN_CODE to force rerecognition of insn. Save old code in
190 change_old_codes
[num_changes
] = INSN_CODE (object
);
191 INSN_CODE (object
) = -1;
196 /* If we are making a group of changes, return 1. Otherwise, validate the
197 change group we made. */
202 return apply_change_group ();
205 /* Apply a group of changes previously issued with `validate_change'.
206 Return 1 if all changes are valid, zero otherwise. */
209 apply_change_group ()
213 /* The changes have been applied and all INSN_CODEs have been reset to force
216 The changes are valid if we aren't given an object, or if we are
217 given a MEM and it still is a valid address, or if this is in insn
218 and it is recognized. In the latter case, if reload has completed,
219 we also require that the operands meet the constraints for
220 the insn. We do not allow modifying an ASM_OPERANDS after reload
221 has completed because verifying the constraints is too difficult. */
223 for (i
= 0; i
< num_changes
; i
++)
225 rtx object
= change_objects
[i
];
230 if (GET_CODE (object
) == MEM
)
232 if (! memory_address_p (GET_MODE (object
), XEXP (object
, 0)))
235 else if ((recog_memoized (object
) < 0
236 && (asm_noperands (PATTERN (object
)) < 0
237 || ! check_asm_operands (PATTERN (object
))
238 || reload_completed
))
240 && (insn_extract (object
),
241 ! constrain_operands (INSN_CODE (object
), 1))))
243 rtx pat
= PATTERN (object
);
245 /* Perhaps we couldn't recognize the insn because there were
246 extra CLOBBERs at the end. If so, try to re-recognize
247 without the last CLOBBER (later iterations will cause each of
248 them to be eliminated, in turn). But don't do this if we
249 have an ASM_OPERAND. */
250 if (GET_CODE (pat
) == PARALLEL
251 && GET_CODE (XVECEXP (pat
, 0, XVECLEN (pat
, 0) - 1)) == CLOBBER
252 && asm_noperands (PATTERN (object
)) < 0)
256 if (XVECLEN (pat
, 0) == 2)
257 newpat
= XVECEXP (pat
, 0, 0);
262 newpat
= gen_rtx (PARALLEL
, VOIDmode
,
263 gen_rtvec (XVECLEN (pat
, 0) - 1));
264 for (j
= 0; j
< XVECLEN (newpat
, 0); j
++)
265 XVECEXP (newpat
, 0, j
) = XVECEXP (pat
, 0, j
);
268 /* Add a new change to this group to replace the pattern
269 with this new pattern. Then consider this change
270 as having succeeded. The change we added will
271 cause the entire call to fail if things remain invalid.
273 Note that this can lose if a later change than the one
274 we are processing specified &XVECEXP (PATTERN (object), 0, X)
275 but this shouldn't occur. */
277 validate_change (object
, &PATTERN (object
), newpat
, 1);
279 else if (GET_CODE (pat
) == USE
|| GET_CODE (pat
) == CLOBBER
)
280 /* If this insn is a CLOBBER or USE, it is always valid, but is
288 if (i
== num_changes
)
300 /* Return the number of changes so far in the current group. */
303 num_validated_changes ()
308 /* Retract the changes numbered NUM and up. */
316 /* Back out all the changes. Do this in the opposite order in which
318 for (i
= num_changes
- 1; i
>= num
; i
--)
320 *change_locs
[i
] = change_olds
[i
];
321 if (change_objects
[i
] && GET_CODE (change_objects
[i
]) != MEM
)
322 INSN_CODE (change_objects
[i
]) = change_old_codes
[i
];
327 /* Replace every occurrence of FROM in X with TO. Mark each change with
328 validate_change passing OBJECT. */
331 validate_replace_rtx_1 (loc
, from
, to
, object
)
333 rtx from
, to
, object
;
337 register rtx x
= *loc
;
338 enum rtx_code code
= GET_CODE (x
);
340 /* X matches FROM if it is the same rtx or they are both referring to the
341 same register in the same mode. Avoid calling rtx_equal_p unless the
342 operands look similar. */
345 || (GET_CODE (x
) == REG
&& GET_CODE (from
) == REG
346 && GET_MODE (x
) == GET_MODE (from
)
347 && REGNO (x
) == REGNO (from
))
348 || (GET_CODE (x
) == GET_CODE (from
) && GET_MODE (x
) == GET_MODE (from
)
349 && rtx_equal_p (x
, from
)))
351 validate_change (object
, loc
, to
, 1);
355 /* For commutative or comparison operations, try replacing each argument
356 separately and seeing if we made any changes. If so, put a constant
358 if (GET_RTX_CLASS (code
) == '<' || GET_RTX_CLASS (code
) == 'c')
360 int prev_changes
= num_changes
;
362 validate_replace_rtx_1 (&XEXP (x
, 0), from
, to
, object
);
363 validate_replace_rtx_1 (&XEXP (x
, 1), from
, to
, object
);
364 if (prev_changes
!= num_changes
&& CONSTANT_P (XEXP (x
, 0)))
366 validate_change (object
, loc
,
367 gen_rtx (GET_RTX_CLASS (code
) == 'c' ? code
368 : swap_condition (code
),
369 GET_MODE (x
), XEXP (x
, 1), XEXP (x
, 0)),
379 /* If we have have a PLUS whose second operand is now a CONST_INT, use
380 plus_constant to try to simplify it. */
381 if (GET_CODE (XEXP (x
, 1)) == CONST_INT
&& XEXP (x
, 1) == to
)
382 validate_change (object
, loc
,
383 plus_constant (XEXP (x
, 0), INTVAL (XEXP (x
, 1))), 1);
388 /* In these cases, the operation to be performed depends on the mode
389 of the operand. If we are replacing the operand with a VOIDmode
390 constant, we lose the information. So try to simplify the operation
391 in that case. If it fails, substitute in something that we know
392 won't be recognized. */
393 if (GET_MODE (to
) == VOIDmode
394 && (XEXP (x
, 0) == from
395 || (GET_CODE (XEXP (x
, 0)) == REG
&& GET_CODE (from
) == REG
396 && GET_MODE (XEXP (x
, 0)) == GET_MODE (from
)
397 && REGNO (XEXP (x
, 0)) == REGNO (from
))))
399 rtx
new = simplify_unary_operation (code
, GET_MODE (x
), to
,
402 new = gen_rtx (CLOBBER
, GET_MODE (x
), const0_rtx
);
404 validate_change (object
, loc
, new, 1);
410 /* If we have a SUBREG of a register that we are replacing and we are
411 replacing it with a MEM, make a new MEM and try replacing the
412 SUBREG with it. Don't do this if the MEM has a mode-dependent address
413 or if we would be widening it. */
415 if (SUBREG_REG (x
) == from
416 && GET_CODE (from
) == REG
417 && GET_CODE (to
) == MEM
418 && ! mode_dependent_address_p (XEXP (to
, 0))
419 && ! MEM_VOLATILE_P (to
)
420 && GET_MODE_SIZE (GET_MODE (x
)) <= GET_MODE_SIZE (GET_MODE (to
)))
422 int offset
= SUBREG_WORD (x
) * UNITS_PER_WORD
;
423 enum machine_mode mode
= GET_MODE (x
);
427 offset
+= (MIN (UNITS_PER_WORD
,
428 GET_MODE_SIZE (GET_MODE (SUBREG_REG (x
))))
429 - MIN (UNITS_PER_WORD
, GET_MODE_SIZE (mode
)));
432 new = gen_rtx (MEM
, mode
, plus_constant (XEXP (to
, 0), offset
));
433 MEM_VOLATILE_P (new) = MEM_VOLATILE_P (to
);
434 RTX_UNCHANGING_P (new) = RTX_UNCHANGING_P (to
);
435 MEM_IN_STRUCT_P (new) = MEM_IN_STRUCT_P (to
);
436 validate_change (object
, loc
, new, 1);
443 /* If we are replacing a register with memory, try to change the memory
444 to be the mode required for memory in extract operations (this isn't
445 likely to be an insertion operation; if it was, nothing bad will
446 happen, we might just fail in some cases). */
448 if (XEXP (x
, 0) == from
&& GET_CODE (from
) == REG
&& GET_CODE (to
) == MEM
449 && GET_CODE (XEXP (x
, 1)) == CONST_INT
450 && GET_CODE (XEXP (x
, 2)) == CONST_INT
451 && ! mode_dependent_address_p (XEXP (to
, 0))
452 && ! MEM_VOLATILE_P (to
))
454 enum machine_mode wanted_mode
= VOIDmode
;
455 enum machine_mode is_mode
= GET_MODE (to
);
456 int width
= INTVAL (XEXP (x
, 1));
457 int pos
= INTVAL (XEXP (x
, 2));
460 if (code
== ZERO_EXTRACT
)
461 wanted_mode
= insn_operand_mode
[(int) CODE_FOR_extzv
][1];
464 if (code
== SIGN_EXTRACT
)
465 wanted_mode
= insn_operand_mode
[(int) CODE_FOR_extv
][1];
468 /* If we have a narrower mode, we can do something. */
469 if (wanted_mode
!= VOIDmode
470 && GET_MODE_SIZE (wanted_mode
) < GET_MODE_SIZE (is_mode
))
472 int offset
= pos
/ BITS_PER_UNIT
;
475 /* If the bytes and bits are counted differently, we
476 must adjust the offset. */
477 #if BYTES_BIG_ENDIAN != BITS_BIG_ENDIAN
478 offset
= (GET_MODE_SIZE (is_mode
) - GET_MODE_SIZE (wanted_mode
)
482 pos
%= GET_MODE_BITSIZE (wanted_mode
);
484 newmem
= gen_rtx (MEM
, wanted_mode
,
485 plus_constant (XEXP (to
, 0), offset
));
486 RTX_UNCHANGING_P (newmem
) = RTX_UNCHANGING_P (to
);
487 MEM_VOLATILE_P (newmem
) = MEM_VOLATILE_P (to
);
488 MEM_IN_STRUCT_P (newmem
) = MEM_IN_STRUCT_P (to
);
490 validate_change (object
, &XEXP (x
, 2), GEN_INT (pos
), 1);
491 validate_change (object
, &XEXP (x
, 0), newmem
, 1);
498 fmt
= GET_RTX_FORMAT (code
);
499 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
502 validate_replace_rtx_1 (&XEXP (x
, i
), from
, to
, object
);
503 else if (fmt
[i
] == 'E')
504 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
505 validate_replace_rtx_1 (&XVECEXP (x
, i
, j
), from
, to
, object
);
509 /* Try replacing every occurrence of FROM in INSN with TO. After all
510 changes have been made, validate by seeing if INSN is still valid. */
513 validate_replace_rtx (from
, to
, insn
)
516 validate_replace_rtx_1 (&PATTERN (insn
), from
, to
, insn
);
517 return apply_change_group ();
521 /* Return 1 if the insn using CC0 set by INSN does not contain
522 any ordered tests applied to the condition codes.
523 EQ and NE tests do not count. */
526 next_insn_tests_no_inequality (insn
)
529 register rtx next
= next_cc0_user (insn
);
531 /* If there is no next insn, we have to take the conservative choice. */
535 return ((GET_CODE (next
) == JUMP_INSN
536 || GET_CODE (next
) == INSN
537 || GET_CODE (next
) == CALL_INSN
)
538 && ! inequality_comparisons_p (PATTERN (next
)));
541 #if 0 /* This is useless since the insn that sets the cc's
542 must be followed immediately by the use of them. */
543 /* Return 1 if the CC value set up by INSN is not used. */
546 next_insns_test_no_inequality (insn
)
549 register rtx next
= NEXT_INSN (insn
);
551 for (; next
!= 0; next
= NEXT_INSN (next
))
553 if (GET_CODE (next
) == CODE_LABEL
554 || GET_CODE (next
) == BARRIER
)
556 if (GET_CODE (next
) == NOTE
)
558 if (inequality_comparisons_p (PATTERN (next
)))
560 if (sets_cc0_p (PATTERN (next
)) == 1)
562 if (! reg_mentioned_p (cc0_rtx
, PATTERN (next
)))
570 /* This is used by find_single_use to locate an rtx that contains exactly one
571 use of DEST, which is typically either a REG or CC0. It returns a
572 pointer to the innermost rtx expression containing DEST. Appearances of
573 DEST that are being used to totally replace it are not counted. */
576 find_single_use_1 (dest
, loc
)
581 enum rtx_code code
= GET_CODE (x
);
598 /* If the destination is anything other than CC0, PC, a REG or a SUBREG
599 of a REG that occupies all of the REG, the insn uses DEST if
600 it is mentioned in the destination or the source. Otherwise, we
601 need just check the source. */
602 if (GET_CODE (SET_DEST (x
)) != CC0
603 && GET_CODE (SET_DEST (x
)) != PC
604 && GET_CODE (SET_DEST (x
)) != REG
605 && ! (GET_CODE (SET_DEST (x
)) == SUBREG
606 && GET_CODE (SUBREG_REG (SET_DEST (x
))) == REG
607 && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (x
))))
608 + (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
)
609 == ((GET_MODE_SIZE (GET_MODE (SET_DEST (x
)))
610 + (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
))))
613 return find_single_use_1 (dest
, &SET_SRC (x
));
617 return find_single_use_1 (dest
, &XEXP (x
, 0));
620 /* If it wasn't one of the common cases above, check each expression and
621 vector of this code. Look for a unique usage of DEST. */
623 fmt
= GET_RTX_FORMAT (code
);
624 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
628 if (dest
== XEXP (x
, i
)
629 || (GET_CODE (dest
) == REG
&& GET_CODE (XEXP (x
, i
)) == REG
630 && REGNO (dest
) == REGNO (XEXP (x
, i
))))
633 this_result
= find_single_use_1 (dest
, &XEXP (x
, i
));
636 result
= this_result
;
637 else if (this_result
)
638 /* Duplicate usage. */
641 else if (fmt
[i
] == 'E')
645 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
647 if (XVECEXP (x
, i
, j
) == dest
648 || (GET_CODE (dest
) == REG
649 && GET_CODE (XVECEXP (x
, i
, j
)) == REG
650 && REGNO (XVECEXP (x
, i
, j
)) == REGNO (dest
)))
653 this_result
= find_single_use_1 (dest
, &XVECEXP (x
, i
, j
));
656 result
= this_result
;
657 else if (this_result
)
666 /* See if DEST, produced in INSN, is used only a single time in the
667 sequel. If so, return a pointer to the innermost rtx expression in which
670 If PLOC is non-zero, *PLOC is set to the insn containing the single use.
672 This routine will return usually zero either before flow is called (because
673 there will be no LOG_LINKS notes) or after reload (because the REG_DEAD
674 note can't be trusted).
676 If DEST is cc0_rtx, we look only at the next insn. In that case, we don't
677 care about REG_DEAD notes or LOG_LINKS.
679 Otherwise, we find the single use by finding an insn that has a
680 LOG_LINKS pointing at INSN and has a REG_DEAD note for DEST. If DEST is
681 only referenced once in that insn, we know that it must be the first
682 and last insn referencing DEST. */
685 find_single_use (dest
, insn
, ploc
)
697 next
= NEXT_INSN (insn
);
699 || (GET_CODE (next
) != INSN
&& GET_CODE (next
) != JUMP_INSN
))
702 result
= find_single_use_1 (dest
, &PATTERN (next
));
709 if (reload_completed
|| reload_in_progress
|| GET_CODE (dest
) != REG
)
712 for (next
= next_nonnote_insn (insn
);
713 next
!= 0 && GET_CODE (next
) != CODE_LABEL
;
714 next
= next_nonnote_insn (next
))
715 if (GET_RTX_CLASS (GET_CODE (next
)) == 'i' && dead_or_set_p (next
, dest
))
717 for (link
= LOG_LINKS (next
); link
; link
= XEXP (link
, 1))
718 if (XEXP (link
, 0) == insn
)
723 result
= find_single_use_1 (dest
, &PATTERN (next
));
733 /* Return 1 if OP is a valid general operand for machine mode MODE.
734 This is either a register reference, a memory reference,
735 or a constant. In the case of a memory reference, the address
736 is checked for general validity for the target machine.
738 Register and memory references must have mode MODE in order to be valid,
739 but some constants have no machine mode and are valid for any mode.
741 If MODE is VOIDmode, OP is checked for validity for whatever mode
744 The main use of this function is as a predicate in match_operand
745 expressions in the machine description.
747 For an explanation of this function's behavior for registers of
748 class NO_REGS, see the comment for `register_operand'. */
751 general_operand (op
, mode
)
753 enum machine_mode mode
;
755 register enum rtx_code code
= GET_CODE (op
);
756 int mode_altering_drug
= 0;
758 if (mode
== VOIDmode
)
759 mode
= GET_MODE (op
);
761 /* Don't accept CONST_INT or anything similar
762 if the caller wants something floating. */
763 if (GET_MODE (op
) == VOIDmode
&& mode
!= VOIDmode
764 && GET_MODE_CLASS (mode
) != MODE_INT
765 && GET_MODE_CLASS (mode
) != MODE_PARTIAL_INT
)
769 return ((GET_MODE (op
) == VOIDmode
|| GET_MODE (op
) == mode
)
770 #ifdef LEGITIMATE_PIC_OPERAND_P
771 && (! flag_pic
|| LEGITIMATE_PIC_OPERAND_P (op
))
773 && LEGITIMATE_CONSTANT_P (op
));
775 /* Except for certain constants with VOIDmode, already checked for,
776 OP's mode must match MODE if MODE specifies a mode. */
778 if (GET_MODE (op
) != mode
)
783 #ifdef INSN_SCHEDULING
784 /* On machines that have insn scheduling, we want all memory
785 reference to be explicit, so outlaw paradoxical SUBREGs. */
786 if (GET_CODE (SUBREG_REG (op
)) == MEM
787 && GET_MODE_SIZE (mode
) > GET_MODE_SIZE (GET_MODE (SUBREG_REG (op
))))
791 op
= SUBREG_REG (op
);
792 code
= GET_CODE (op
);
794 /* No longer needed, since (SUBREG (MEM...))
795 will load the MEM into a reload reg in the MEM's own mode. */
796 mode_altering_drug
= 1;
801 /* A register whose class is NO_REGS is not a general operand. */
802 return (REGNO (op
) >= FIRST_PSEUDO_REGISTER
803 || REGNO_REG_CLASS (REGNO (op
)) != NO_REGS
);
807 register rtx y
= XEXP (op
, 0);
808 if (! volatile_ok
&& MEM_VOLATILE_P (op
))
810 /* Use the mem's mode, since it will be reloaded thus. */
811 mode
= GET_MODE (op
);
812 GO_IF_LEGITIMATE_ADDRESS (mode
, y
, win
);
817 if (mode_altering_drug
)
818 return ! mode_dependent_address_p (XEXP (op
, 0));
822 /* Return 1 if OP is a valid memory address for a memory reference
825 The main use of this function is as a predicate in match_operand
826 expressions in the machine description. */
829 address_operand (op
, mode
)
831 enum machine_mode mode
;
833 return memory_address_p (mode
, op
);
836 /* Return 1 if OP is a register reference of mode MODE.
837 If MODE is VOIDmode, accept a register in any mode.
839 The main use of this function is as a predicate in match_operand
840 expressions in the machine description.
842 As a special exception, registers whose class is NO_REGS are
843 not accepted by `register_operand'. The reason for this change
844 is to allow the representation of special architecture artifacts
845 (such as a condition code register) without extending the rtl
846 definitions. Since registers of class NO_REGS cannot be used
847 as registers in any case where register classes are examined,
848 it is most consistent to keep this function from accepting them. */
851 register_operand (op
, mode
)
853 enum machine_mode mode
;
855 if (GET_MODE (op
) != mode
&& mode
!= VOIDmode
)
858 if (GET_CODE (op
) == SUBREG
)
860 /* Before reload, we can allow (SUBREG (MEM...)) as a register operand
861 because it is guaranteed to be reloaded into one.
862 Just make sure the MEM is valid in itself.
863 (Ideally, (SUBREG (MEM)...) should not exist after reload,
864 but currently it does result from (SUBREG (REG)...) where the
865 reg went on the stack.) */
866 if (! reload_completed
&& GET_CODE (SUBREG_REG (op
)) == MEM
)
867 return general_operand (op
, mode
);
868 op
= SUBREG_REG (op
);
871 /* We don't consider registers whose class is NO_REGS
872 to be a register operand. */
873 return (GET_CODE (op
) == REG
874 && (REGNO (op
) >= FIRST_PSEUDO_REGISTER
875 || REGNO_REG_CLASS (REGNO (op
)) != NO_REGS
));
878 /* Return 1 if OP should match a MATCH_SCRATCH, i.e., if it is a SCRATCH
879 or a hard register. */
882 scratch_operand (op
, mode
)
884 enum machine_mode mode
;
886 return (GET_MODE (op
) == mode
887 && (GET_CODE (op
) == SCRATCH
888 || (GET_CODE (op
) == REG
889 && REGNO (op
) < FIRST_PSEUDO_REGISTER
)));
892 /* Return 1 if OP is a valid immediate operand for mode MODE.
894 The main use of this function is as a predicate in match_operand
895 expressions in the machine description. */
898 immediate_operand (op
, mode
)
900 enum machine_mode mode
;
902 /* Don't accept CONST_INT or anything similar
903 if the caller wants something floating. */
904 if (GET_MODE (op
) == VOIDmode
&& mode
!= VOIDmode
905 && GET_MODE_CLASS (mode
) != MODE_INT
906 && GET_MODE_CLASS (mode
) != MODE_PARTIAL_INT
)
909 return (CONSTANT_P (op
)
910 && (GET_MODE (op
) == mode
|| mode
== VOIDmode
911 || GET_MODE (op
) == VOIDmode
)
912 #ifdef LEGITIMATE_PIC_OPERAND_P
913 && (! flag_pic
|| LEGITIMATE_PIC_OPERAND_P (op
))
915 && LEGITIMATE_CONSTANT_P (op
));
918 /* Returns 1 if OP is an operand that is a CONST_INT. */
921 const_int_operand (op
, mode
)
923 enum machine_mode mode
;
925 return GET_CODE (op
) == CONST_INT
;
928 /* Returns 1 if OP is an operand that is a constant integer or constant
929 floating-point number. */
932 const_double_operand (op
, mode
)
934 enum machine_mode mode
;
936 /* Don't accept CONST_INT or anything similar
937 if the caller wants something floating. */
938 if (GET_MODE (op
) == VOIDmode
&& mode
!= VOIDmode
939 && GET_MODE_CLASS (mode
) != MODE_INT
940 && GET_MODE_CLASS (mode
) != MODE_PARTIAL_INT
)
943 return ((GET_CODE (op
) == CONST_DOUBLE
|| GET_CODE (op
) == CONST_INT
)
944 && (mode
== VOIDmode
|| GET_MODE (op
) == mode
945 || GET_MODE (op
) == VOIDmode
));
948 /* Return 1 if OP is a general operand that is not an immediate operand. */
951 nonimmediate_operand (op
, mode
)
953 enum machine_mode mode
;
955 return (general_operand (op
, mode
) && ! CONSTANT_P (op
));
958 /* Return 1 if OP is a register reference or immediate value of mode MODE. */
961 nonmemory_operand (op
, mode
)
963 enum machine_mode mode
;
967 /* Don't accept CONST_INT or anything similar
968 if the caller wants something floating. */
969 if (GET_MODE (op
) == VOIDmode
&& mode
!= VOIDmode
970 && GET_MODE_CLASS (mode
) != MODE_INT
971 && GET_MODE_CLASS (mode
) != MODE_PARTIAL_INT
)
974 return ((GET_MODE (op
) == VOIDmode
|| GET_MODE (op
) == mode
)
975 #ifdef LEGITIMATE_PIC_OPERAND_P
976 && (! flag_pic
|| LEGITIMATE_PIC_OPERAND_P (op
))
978 && LEGITIMATE_CONSTANT_P (op
));
981 if (GET_MODE (op
) != mode
&& mode
!= VOIDmode
)
984 if (GET_CODE (op
) == SUBREG
)
986 /* Before reload, we can allow (SUBREG (MEM...)) as a register operand
987 because it is guaranteed to be reloaded into one.
988 Just make sure the MEM is valid in itself.
989 (Ideally, (SUBREG (MEM)...) should not exist after reload,
990 but currently it does result from (SUBREG (REG)...) where the
991 reg went on the stack.) */
992 if (! reload_completed
&& GET_CODE (SUBREG_REG (op
)) == MEM
)
993 return general_operand (op
, mode
);
994 op
= SUBREG_REG (op
);
997 /* We don't consider registers whose class is NO_REGS
998 to be a register operand. */
999 return (GET_CODE (op
) == REG
1000 && (REGNO (op
) >= FIRST_PSEUDO_REGISTER
1001 || REGNO_REG_CLASS (REGNO (op
)) != NO_REGS
));
1004 /* Return 1 if OP is a valid operand that stands for pushing a
1005 value of mode MODE onto the stack.
1007 The main use of this function is as a predicate in match_operand
1008 expressions in the machine description. */
1011 push_operand (op
, mode
)
1013 enum machine_mode mode
;
1015 if (GET_CODE (op
) != MEM
)
1018 if (GET_MODE (op
) != mode
)
1023 if (GET_CODE (op
) != STACK_PUSH_CODE
)
1026 return XEXP (op
, 0) == stack_pointer_rtx
;
1029 /* Return 1 if ADDR is a valid memory address for mode MODE. */
1032 memory_address_p (mode
, addr
)
1033 enum machine_mode mode
;
1036 GO_IF_LEGITIMATE_ADDRESS (mode
, addr
, win
);
1043 /* Return 1 if OP is a valid memory reference with mode MODE,
1044 including a valid address.
1046 The main use of this function is as a predicate in match_operand
1047 expressions in the machine description. */
1050 memory_operand (op
, mode
)
1052 enum machine_mode mode
;
1056 if (! reload_completed
)
1057 /* Note that no SUBREG is a memory operand before end of reload pass,
1058 because (SUBREG (MEM...)) forces reloading into a register. */
1059 return GET_CODE (op
) == MEM
&& general_operand (op
, mode
);
1061 if (mode
!= VOIDmode
&& GET_MODE (op
) != mode
)
1065 if (GET_CODE (inner
) == SUBREG
)
1066 inner
= SUBREG_REG (inner
);
1068 return (GET_CODE (inner
) == MEM
&& general_operand (op
, mode
));
1071 /* Return 1 if OP is a valid indirect memory reference with mode MODE;
1072 that is, a memory reference whose address is a general_operand. */
1075 indirect_operand (op
, mode
)
1077 enum machine_mode mode
;
1079 /* Before reload, a SUBREG isn't in memory (see memory_operand, above). */
1080 if (! reload_completed
1081 && GET_CODE (op
) == SUBREG
&& GET_CODE (SUBREG_REG (op
)) == MEM
)
1083 register int offset
= SUBREG_WORD (op
) * UNITS_PER_WORD
;
1084 rtx inner
= SUBREG_REG (op
);
1086 #if BYTES_BIG_ENDIAN
1087 offset
-= (MIN (UNITS_PER_WORD
, GET_MODE_SIZE (GET_MODE (op
)))
1088 - MIN (UNITS_PER_WORD
, GET_MODE_SIZE (GET_MODE (inner
))));
1091 /* The only way that we can have a general_operand as the resulting
1092 address is if OFFSET is zero and the address already is an operand
1093 or if the address is (plus Y (const_int -OFFSET)) and Y is an
1096 return ((offset
== 0 && general_operand (XEXP (inner
, 0), Pmode
))
1097 || (GET_CODE (XEXP (inner
, 0)) == PLUS
1098 && GET_CODE (XEXP (XEXP (inner
, 0), 1)) == CONST_INT
1099 && INTVAL (XEXP (XEXP (inner
, 0), 1)) == -offset
1100 && general_operand (XEXP (XEXP (inner
, 0), 0), Pmode
)));
1103 return (GET_CODE (op
) == MEM
1104 && memory_operand (op
, mode
)
1105 && general_operand (XEXP (op
, 0), Pmode
));
1108 /* Return 1 if this is a comparison operator. This allows the use of
1109 MATCH_OPERATOR to recognize all the branch insns. */
1112 comparison_operator (op
, mode
)
1114 enum machine_mode mode
;
1116 return ((mode
== VOIDmode
|| GET_MODE (op
) == mode
)
1117 && GET_RTX_CLASS (GET_CODE (op
)) == '<');
1120 /* If BODY is an insn body that uses ASM_OPERANDS,
1121 return the number of operands (both input and output) in the insn.
1122 Otherwise return -1. */
1125 asm_noperands (body
)
1128 if (GET_CODE (body
) == ASM_OPERANDS
)
1129 /* No output operands: return number of input operands. */
1130 return ASM_OPERANDS_INPUT_LENGTH (body
);
1131 if (GET_CODE (body
) == SET
&& GET_CODE (SET_SRC (body
)) == ASM_OPERANDS
)
1132 /* Single output operand: BODY is (set OUTPUT (asm_operands ...)). */
1133 return ASM_OPERANDS_INPUT_LENGTH (SET_SRC (body
)) + 1;
1134 else if (GET_CODE (body
) == PARALLEL
1135 && GET_CODE (XVECEXP (body
, 0, 0)) == SET
1136 && GET_CODE (SET_SRC (XVECEXP (body
, 0, 0))) == ASM_OPERANDS
)
1138 /* Multiple output operands, or 1 output plus some clobbers:
1139 body is [(set OUTPUT (asm_operands ...))... (clobber (reg ...))...]. */
1143 /* Count backwards through CLOBBERs to determine number of SETs. */
1144 for (i
= XVECLEN (body
, 0); i
> 0; i
--)
1146 if (GET_CODE (XVECEXP (body
, 0, i
- 1)) == SET
)
1148 if (GET_CODE (XVECEXP (body
, 0, i
- 1)) != CLOBBER
)
1152 /* N_SETS is now number of output operands. */
1155 /* Verify that all the SETs we have
1156 came from a single original asm_operands insn
1157 (so that invalid combinations are blocked). */
1158 for (i
= 0; i
< n_sets
; i
++)
1160 rtx elt
= XVECEXP (body
, 0, i
);
1161 if (GET_CODE (elt
) != SET
)
1163 if (GET_CODE (SET_SRC (elt
)) != ASM_OPERANDS
)
1165 /* If these ASM_OPERANDS rtx's came from different original insns
1166 then they aren't allowed together. */
1167 if (ASM_OPERANDS_INPUT_VEC (SET_SRC (elt
))
1168 != ASM_OPERANDS_INPUT_VEC (SET_SRC (XVECEXP (body
, 0, 0))))
1171 return (ASM_OPERANDS_INPUT_LENGTH (SET_SRC (XVECEXP (body
, 0, 0)))
1174 else if (GET_CODE (body
) == PARALLEL
1175 && GET_CODE (XVECEXP (body
, 0, 0)) == ASM_OPERANDS
)
1177 /* 0 outputs, but some clobbers:
1178 body is [(asm_operands ...) (clobber (reg ...))...]. */
1181 /* Make sure all the other parallel things really are clobbers. */
1182 for (i
= XVECLEN (body
, 0) - 1; i
> 0; i
--)
1183 if (GET_CODE (XVECEXP (body
, 0, i
)) != CLOBBER
)
1186 return ASM_OPERANDS_INPUT_LENGTH (XVECEXP (body
, 0, 0));
1192 /* Assuming BODY is an insn body that uses ASM_OPERANDS,
1193 copy its operands (both input and output) into the vector OPERANDS,
1194 the locations of the operands within the insn into the vector OPERAND_LOCS,
1195 and the constraints for the operands into CONSTRAINTS.
1196 Write the modes of the operands into MODES.
1197 Return the assembler-template.
1199 If MODES, OPERAND_LOCS, CONSTRAINTS or OPERANDS is 0,
1200 we don't store that info. */
1203 decode_asm_operands (body
, operands
, operand_locs
, constraints
, modes
)
1208 enum machine_mode
*modes
;
1214 if (GET_CODE (body
) == SET
&& GET_CODE (SET_SRC (body
)) == ASM_OPERANDS
)
1216 rtx asmop
= SET_SRC (body
);
1217 /* Single output operand: BODY is (set OUTPUT (asm_operands ....)). */
1219 noperands
= ASM_OPERANDS_INPUT_LENGTH (asmop
) + 1;
1221 for (i
= 1; i
< noperands
; i
++)
1224 operand_locs
[i
] = &ASM_OPERANDS_INPUT (asmop
, i
- 1);
1226 operands
[i
] = ASM_OPERANDS_INPUT (asmop
, i
- 1);
1228 constraints
[i
] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop
, i
- 1);
1230 modes
[i
] = ASM_OPERANDS_INPUT_MODE (asmop
, i
- 1);
1233 /* The output is in the SET.
1234 Its constraint is in the ASM_OPERANDS itself. */
1236 operands
[0] = SET_DEST (body
);
1238 operand_locs
[0] = &SET_DEST (body
);
1240 constraints
[0] = ASM_OPERANDS_OUTPUT_CONSTRAINT (asmop
);
1242 modes
[0] = GET_MODE (SET_DEST (body
));
1243 template = ASM_OPERANDS_TEMPLATE (asmop
);
1245 else if (GET_CODE (body
) == ASM_OPERANDS
)
1248 /* No output operands: BODY is (asm_operands ....). */
1250 noperands
= ASM_OPERANDS_INPUT_LENGTH (asmop
);
1252 /* The input operands are found in the 1st element vector. */
1253 /* Constraints for inputs are in the 2nd element vector. */
1254 for (i
= 0; i
< noperands
; i
++)
1257 operand_locs
[i
] = &ASM_OPERANDS_INPUT (asmop
, i
);
1259 operands
[i
] = ASM_OPERANDS_INPUT (asmop
, i
);
1261 constraints
[i
] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop
, i
);
1263 modes
[i
] = ASM_OPERANDS_INPUT_MODE (asmop
, i
);
1265 template = ASM_OPERANDS_TEMPLATE (asmop
);
1267 else if (GET_CODE (body
) == PARALLEL
1268 && GET_CODE (XVECEXP (body
, 0, 0)) == SET
)
1270 rtx asmop
= SET_SRC (XVECEXP (body
, 0, 0));
1271 int nparallel
= XVECLEN (body
, 0); /* Includes CLOBBERs. */
1272 int nin
= ASM_OPERANDS_INPUT_LENGTH (asmop
);
1273 int nout
= 0; /* Does not include CLOBBERs. */
1275 /* At least one output, plus some CLOBBERs. */
1277 /* The outputs are in the SETs.
1278 Their constraints are in the ASM_OPERANDS itself. */
1279 for (i
= 0; i
< nparallel
; i
++)
1281 if (GET_CODE (XVECEXP (body
, 0, i
)) == CLOBBER
)
1282 break; /* Past last SET */
1285 operands
[i
] = SET_DEST (XVECEXP (body
, 0, i
));
1287 operand_locs
[i
] = &SET_DEST (XVECEXP (body
, 0, i
));
1289 constraints
[i
] = XSTR (SET_SRC (XVECEXP (body
, 0, i
)), 1);
1291 modes
[i
] = GET_MODE (SET_DEST (XVECEXP (body
, 0, i
)));
1295 for (i
= 0; i
< nin
; i
++)
1298 operand_locs
[i
+ nout
] = &ASM_OPERANDS_INPUT (asmop
, i
);
1300 operands
[i
+ nout
] = ASM_OPERANDS_INPUT (asmop
, i
);
1302 constraints
[i
+ nout
] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop
, i
);
1304 modes
[i
+ nout
] = ASM_OPERANDS_INPUT_MODE (asmop
, i
);
1307 template = ASM_OPERANDS_TEMPLATE (asmop
);
1309 else if (GET_CODE (body
) == PARALLEL
1310 && GET_CODE (XVECEXP (body
, 0, 0)) == ASM_OPERANDS
)
1312 /* No outputs, but some CLOBBERs. */
1314 rtx asmop
= XVECEXP (body
, 0, 0);
1315 int nin
= ASM_OPERANDS_INPUT_LENGTH (asmop
);
1317 for (i
= 0; i
< nin
; i
++)
1320 operand_locs
[i
] = &ASM_OPERANDS_INPUT (asmop
, i
);
1322 operands
[i
] = ASM_OPERANDS_INPUT (asmop
, i
);
1324 constraints
[i
] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop
, i
);
1326 modes
[i
] = ASM_OPERANDS_INPUT_MODE (asmop
, i
);
1329 template = ASM_OPERANDS_TEMPLATE (asmop
);
1335 /* Given an rtx *P, if it is a sum containing an integer constant term,
1336 return the location (type rtx *) of the pointer to that constant term.
1337 Otherwise, return a null pointer. */
1340 find_constant_term_loc (p
)
1344 register enum rtx_code code
= GET_CODE (*p
);
1346 /* If *P IS such a constant term, P is its location. */
1348 if (code
== CONST_INT
|| code
== SYMBOL_REF
|| code
== LABEL_REF
1352 /* Otherwise, if not a sum, it has no constant term. */
1354 if (GET_CODE (*p
) != PLUS
)
1357 /* If one of the summands is constant, return its location. */
1359 if (XEXP (*p
, 0) && CONSTANT_P (XEXP (*p
, 0))
1360 && XEXP (*p
, 1) && CONSTANT_P (XEXP (*p
, 1)))
1363 /* Otherwise, check each summand for containing a constant term. */
1365 if (XEXP (*p
, 0) != 0)
1367 tem
= find_constant_term_loc (&XEXP (*p
, 0));
1372 if (XEXP (*p
, 1) != 0)
1374 tem
= find_constant_term_loc (&XEXP (*p
, 1));
1382 /* Return 1 if OP is a memory reference
1383 whose address contains no side effects
1384 and remains valid after the addition
1385 of a positive integer less than the
1386 size of the object being referenced.
1388 We assume that the original address is valid and do not check it.
1390 This uses strict_memory_address_p as a subroutine, so
1391 don't use it before reload. */
1394 offsettable_memref_p (op
)
1397 return ((GET_CODE (op
) == MEM
)
1398 && offsettable_address_p (1, GET_MODE (op
), XEXP (op
, 0)));
1401 /* Similar, but don't require a strictly valid mem ref:
1402 consider pseudo-regs valid as index or base regs. */
1405 offsettable_nonstrict_memref_p (op
)
1408 return ((GET_CODE (op
) == MEM
)
1409 && offsettable_address_p (0, GET_MODE (op
), XEXP (op
, 0)));
1412 /* Return 1 if Y is a memory address which contains no side effects
1413 and would remain valid after the addition of a positive integer
1414 less than the size of that mode.
1416 We assume that the original address is valid and do not check it.
1417 We do check that it is valid for narrower modes.
1419 If STRICTP is nonzero, we require a strictly valid address,
1420 for the sake of use in reload.c. */
1423 offsettable_address_p (strictp
, mode
, y
)
1425 enum machine_mode mode
;
1428 register enum rtx_code ycode
= GET_CODE (y
);
1432 int (*addressp
) () = (strictp
? strict_memory_address_p
: memory_address_p
);
1434 if (CONSTANT_ADDRESS_P (y
))
1437 /* Adjusting an offsettable address involves changing to a narrower mode.
1438 Make sure that's OK. */
1440 if (mode_dependent_address_p (y
))
1443 /* If the expression contains a constant term,
1444 see if it remains valid when max possible offset is added. */
1446 if ((ycode
== PLUS
) && (y2
= find_constant_term_loc (&y1
)))
1451 *y2
= plus_constant (*y2
, GET_MODE_SIZE (mode
) - 1);
1452 /* Use QImode because an odd displacement may be automatically invalid
1453 for any wider mode. But it should be valid for a single byte. */
1454 good
= (*addressp
) (QImode
, y
);
1456 /* In any case, restore old contents of memory. */
1461 if (ycode
== PRE_DEC
|| ycode
== PRE_INC
1462 || ycode
== POST_DEC
|| ycode
== POST_INC
)
1465 /* The offset added here is chosen as the maximum offset that
1466 any instruction could need to add when operating on something
1467 of the specified mode. We assume that if Y and Y+c are
1468 valid addresses then so is Y+d for all 0<d<c. */
1470 z
= plus_constant_for_output (y
, GET_MODE_SIZE (mode
) - 1);
1472 /* Use QImode because an odd displacement may be automatically invalid
1473 for any wider mode. But it should be valid for a single byte. */
1474 return (*addressp
) (QImode
, z
);
1477 /* Return 1 if ADDR is an address-expression whose effect depends
1478 on the mode of the memory reference it is used in.
1480 Autoincrement addressing is a typical example of mode-dependence
1481 because the amount of the increment depends on the mode. */
1484 mode_dependent_address_p (addr
)
1487 GO_IF_MODE_DEPENDENT_ADDRESS (addr
, win
);
1493 /* Return 1 if OP is a general operand
1494 other than a memory ref with a mode dependent address. */
1497 mode_independent_operand (op
, mode
)
1498 enum machine_mode mode
;
1503 if (! general_operand (op
, mode
))
1506 if (GET_CODE (op
) != MEM
)
1509 addr
= XEXP (op
, 0);
1510 GO_IF_MODE_DEPENDENT_ADDRESS (addr
, lose
);
1516 /* Given an operand OP that is a valid memory reference
1517 which satisfies offsettable_memref_p,
1518 return a new memory reference whose address has been adjusted by OFFSET.
1519 OFFSET should be positive and less than the size of the object referenced.
1523 adj_offsettable_operand (op
, offset
)
1527 register enum rtx_code code
= GET_CODE (op
);
1531 register rtx y
= XEXP (op
, 0);
1534 if (CONSTANT_ADDRESS_P (y
))
1536 new = gen_rtx (MEM
, GET_MODE (op
), plus_constant_for_output (y
, offset
));
1537 RTX_UNCHANGING_P (new) = RTX_UNCHANGING_P (op
);
1541 if (GET_CODE (y
) == PLUS
)
1544 register rtx
*const_loc
;
1548 const_loc
= find_constant_term_loc (&z
);
1551 *const_loc
= plus_constant_for_output (*const_loc
, offset
);
1556 new = gen_rtx (MEM
, GET_MODE (op
), plus_constant_for_output (y
, offset
));
1557 RTX_UNCHANGING_P (new) = RTX_UNCHANGING_P (op
);
1563 #ifdef REGISTER_CONSTRAINTS
1565 /* Check the operands of an insn (found in recog_operands)
1566 against the insn's operand constraints (found via INSN_CODE_NUM)
1567 and return 1 if they are valid.
1569 WHICH_ALTERNATIVE is set to a number which indicates which
1570 alternative of constraints was matched: 0 for the first alternative,
1571 1 for the next, etc.
1573 In addition, when two operands are match
1574 and it happens that the output operand is (reg) while the
1575 input operand is --(reg) or ++(reg) (a pre-inc or pre-dec),
1576 make the output operand look like the input.
1577 This is because the output operand is the one the template will print.
1579 This is used in final, just before printing the assembler code and by
1580 the routines that determine an insn's attribute.
1582 If STRICT is a positive non-zero value, it means that we have been
1583 called after reload has been completed. In that case, we must
1584 do all checks strictly. If it is zero, it means that we have been called
1585 before reload has completed. In that case, we first try to see if we can
1586 find an alternative that matches strictly. If not, we try again, this
1587 time assuming that reload will fix up the insn. This provides a "best
1588 guess" for the alternative and is used to compute attributes of insns prior
1589 to reload. A negative value of STRICT is used for this internal call. */
1597 constrain_operands (insn_code_num
, strict
)
1601 char *constraints
[MAX_RECOG_OPERANDS
];
1602 int matching_operands
[MAX_RECOG_OPERANDS
];
1603 enum op_type
{OP_IN
, OP_OUT
, OP_INOUT
} op_types
[MAX_RECOG_OPERANDS
];
1604 int earlyclobber
[MAX_RECOG_OPERANDS
];
1606 int noperands
= insn_n_operands
[insn_code_num
];
1608 struct funny_match funny_match
[MAX_RECOG_OPERANDS
];
1609 int funny_match_index
;
1610 int nalternatives
= insn_n_alternatives
[insn_code_num
];
1612 if (noperands
== 0 || nalternatives
== 0)
1615 for (c
= 0; c
< noperands
; c
++)
1617 constraints
[c
] = insn_operand_constraint
[insn_code_num
][c
];
1618 matching_operands
[c
] = -1;
1619 op_types
[c
] = OP_IN
;
1622 which_alternative
= 0;
1624 while (which_alternative
< nalternatives
)
1628 funny_match_index
= 0;
1630 for (opno
= 0; opno
< noperands
; opno
++)
1632 register rtx op
= recog_operand
[opno
];
1633 enum machine_mode mode
= GET_MODE (op
);
1634 register char *p
= constraints
[opno
];
1639 earlyclobber
[opno
] = 0;
1641 if (GET_CODE (op
) == SUBREG
)
1643 if (GET_CODE (SUBREG_REG (op
)) == REG
1644 && REGNO (SUBREG_REG (op
)) < FIRST_PSEUDO_REGISTER
)
1645 offset
= SUBREG_WORD (op
);
1646 op
= SUBREG_REG (op
);
1649 /* An empty constraint or empty alternative
1650 allows anything which matched the pattern. */
1651 if (*p
== 0 || *p
== ',')
1654 while (*p
&& (c
= *p
++) != ',')
1665 op_types
[opno
] = OP_OUT
;
1669 op_types
[opno
] = OP_INOUT
;
1673 earlyclobber
[opno
] = 1;
1681 /* This operand must be the same as a previous one.
1682 This kind of constraint is used for instructions such
1683 as add when they take only two operands.
1685 Note that the lower-numbered operand is passed first.
1687 If we are not testing strictly, assume that this constraint
1688 will be satisfied. */
1692 val
= operands_match_p (recog_operand
[c
- '0'],
1693 recog_operand
[opno
]);
1695 matching_operands
[opno
] = c
- '0';
1696 matching_operands
[c
- '0'] = opno
;
1700 /* If output is *x and input is *--x,
1701 arrange later to change the output to *--x as well,
1702 since the output op is the one that will be printed. */
1703 if (val
== 2 && strict
> 0)
1705 funny_match
[funny_match_index
].this = opno
;
1706 funny_match
[funny_match_index
++].other
= c
- '0';
1711 /* p is used for address_operands. When we are called by
1712 gen_input_reload, no one will have checked that the
1713 address is strictly valid, i.e., that all pseudos
1714 requiring hard regs have gotten them. */
1716 || (strict_memory_address_p
1717 (insn_operand_mode
[insn_code_num
][opno
], op
)))
1721 /* No need to check general_operand again;
1722 it was done in insn-recog.c. */
1724 /* Anything goes unless it is a REG and really has a hard reg
1725 but the hard reg is not in the class GENERAL_REGS. */
1727 || GENERAL_REGS
== ALL_REGS
1728 || GET_CODE (op
) != REG
1729 || (reload_in_progress
1730 && REGNO (op
) >= FIRST_PSEUDO_REGISTER
)
1731 || reg_fits_class_p (op
, GENERAL_REGS
, offset
, mode
))
1738 && GET_CODE (op
) == REG
1739 && REGNO (op
) >= FIRST_PSEUDO_REGISTER
)
1740 || (strict
== 0 && GET_CODE (op
) == SCRATCH
)
1741 || (GET_CODE (op
) == REG
1742 && ((GENERAL_REGS
== ALL_REGS
1743 && REGNO (op
) < FIRST_PSEUDO_REGISTER
)
1744 || reg_fits_class_p (op
, GENERAL_REGS
,
1750 /* This is used for a MATCH_SCRATCH in the cases when we
1751 don't actually need anything. So anything goes any time. */
1756 if (GET_CODE (op
) == MEM
1757 /* Before reload, accept what reload can turn into mem. */
1758 || (strict
< 0 && CONSTANT_P (op
))
1759 /* During reload, accept a pseudo */
1760 || (reload_in_progress
&& GET_CODE (op
) == REG
1761 && REGNO (op
) >= FIRST_PSEUDO_REGISTER
))
1766 if (GET_CODE (op
) == MEM
1767 && (GET_CODE (XEXP (op
, 0)) == PRE_DEC
1768 || GET_CODE (XEXP (op
, 0)) == POST_DEC
))
1773 if (GET_CODE (op
) == MEM
1774 && (GET_CODE (XEXP (op
, 0)) == PRE_INC
1775 || GET_CODE (XEXP (op
, 0)) == POST_INC
))
1780 /* Match any CONST_DOUBLE, but only if
1781 we can examine the bits of it reliably. */
1782 if ((HOST_FLOAT_FORMAT
!= TARGET_FLOAT_FORMAT
1783 || HOST_BITS_PER_WIDE_INT
!= BITS_PER_WORD
)
1784 && GET_MODE (op
) != VOIDmode
&& ! flag_pretend_float
)
1786 if (GET_CODE (op
) == CONST_DOUBLE
)
1791 if (GET_CODE (op
) == CONST_DOUBLE
)
1797 if (GET_CODE (op
) == CONST_DOUBLE
1798 && CONST_DOUBLE_OK_FOR_LETTER_P (op
, c
))
1803 if (GET_CODE (op
) == CONST_INT
1804 || (GET_CODE (op
) == CONST_DOUBLE
1805 && GET_MODE (op
) == VOIDmode
))
1808 if (CONSTANT_P (op
))
1813 if (GET_CODE (op
) == CONST_INT
1814 || (GET_CODE (op
) == CONST_DOUBLE
1815 && GET_MODE (op
) == VOIDmode
))
1827 if (GET_CODE (op
) == CONST_INT
1828 && CONST_OK_FOR_LETTER_P (INTVAL (op
), c
))
1832 #ifdef EXTRA_CONSTRAINT
1838 if (EXTRA_CONSTRAINT (op
, c
))
1844 if (GET_CODE (op
) == MEM
1845 && ! offsettable_memref_p (op
))
1850 if ((strict
> 0 && offsettable_memref_p (op
))
1851 || (strict
== 0 && offsettable_nonstrict_memref_p (op
))
1852 /* Before reload, accept what reload can handle. */
1854 && (CONSTANT_P (op
) || GET_CODE (op
) == MEM
))
1855 /* During reload, accept a pseudo */
1856 || (reload_in_progress
&& GET_CODE (op
) == REG
1857 && REGNO (op
) >= FIRST_PSEUDO_REGISTER
))
1864 && GET_CODE (op
) == REG
1865 && REGNO (op
) >= FIRST_PSEUDO_REGISTER
)
1866 || (strict
== 0 && GET_CODE (op
) == SCRATCH
)
1867 || (GET_CODE (op
) == REG
1868 && reg_fits_class_p (op
, REG_CLASS_FROM_LETTER (c
),
1873 constraints
[opno
] = p
;
1874 /* If this operand did not win somehow,
1875 this alternative loses. */
1879 /* This alternative won; the operands are ok.
1880 Change whichever operands this alternative says to change. */
1885 /* See if any earlyclobber operand conflicts with some other
1889 for (eopno
= 0; eopno
< noperands
; eopno
++)
1890 /* Ignore earlyclobber operands now in memory,
1891 because we would often report failure when we have
1892 two memory operands, one of which was formerly a REG. */
1893 if (earlyclobber
[eopno
]
1894 && GET_CODE (recog_operand
[eopno
]) == REG
)
1895 for (opno
= 0; opno
< noperands
; opno
++)
1896 if ((GET_CODE (recog_operand
[opno
]) == MEM
1897 || op_types
[opno
] != OP_OUT
)
1899 /* Ignore things like match_operator operands. */
1900 && *constraints
[opno
] != 0
1901 && ! (matching_operands
[opno
] == eopno
1902 && rtx_equal_p (recog_operand
[opno
],
1903 recog_operand
[eopno
]))
1904 && ! safe_from_earlyclobber (recog_operand
[opno
],
1905 recog_operand
[eopno
]))
1910 while (--funny_match_index
>= 0)
1912 recog_operand
[funny_match
[funny_match_index
].other
]
1913 = recog_operand
[funny_match
[funny_match_index
].this];
1920 which_alternative
++;
1923 /* If we are about to reject this, but we are not to test strictly,
1924 try a very loose test. Only return failure if it fails also. */
1926 return constrain_operands (insn_code_num
, -1);
1931 /* Return 1 iff OPERAND (assumed to be a REG rtx)
1932 is a hard reg in class CLASS when its regno is offsetted by OFFSET
1933 and changed to mode MODE.
1934 If REG occupies multiple hard regs, all of them must be in CLASS. */
1937 reg_fits_class_p (operand
, class, offset
, mode
)
1939 register enum reg_class
class;
1941 enum machine_mode mode
;
1943 register int regno
= REGNO (operand
);
1944 if (regno
< FIRST_PSEUDO_REGISTER
1945 && TEST_HARD_REG_BIT (reg_class_contents
[(int) class],
1950 for (sr
= HARD_REGNO_NREGS (regno
, mode
) - 1;
1952 if (! TEST_HARD_REG_BIT (reg_class_contents
[(int) class],
1961 #endif /* REGISTER_CONSTRAINTS */