Index: genrecog.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/genrecog.c,v
retrieving revision 1.125
diff -p -r1.125 genrecog.c
*** genrecog.c	17 May 2003 01:40:41 -0000	1.125
--- genrecog.c	22 May 2003 16:32:25 -0000
*************** validate_pattern (pattern, insn, set, se
*** 623,629 ****
  	    && allows_non_const
  	    && ! special_mode_pred
  	    && pred_name[0] != '\0'
! 	    && strcmp (pred_name, "address_operand") != 0
  	    && strstr (c_test, "operands") == NULL
  	    && ! (set
  		  && GET_CODE (set) == SET
--- 623,629 ----
  	    && allows_non_const
  	    && ! special_mode_pred
  	    && pred_name[0] != '\0'
! 	    && strstr (pred_name, "address_operand") == NULL
  	    && strstr (c_test, "operands") == NULL
  	    && ! (set
  		  && GET_CODE (set) == SET
*************** validate_pattern (pattern, insn, set, se
*** 667,673 ****
  	/* The mode of an ADDRESS_OPERAND is the mode of the memory
  	   reference, not the mode of the address.  */
  	if (GET_CODE (src) == MATCH_OPERAND
! 	    && ! strcmp (XSTR (src, 1), "address_operand"))
  	  ;
  
          /* The operands of a SET must have the same mode unless one
--- 667,673 ----
  	/* The mode of an ADDRESS_OPERAND is the mode of the memory
  	   reference, not the mode of the address.  */
  	if (GET_CODE (src) == MATCH_OPERAND
! 	    && strstr (XSTR (src, 1), "address_operand") == NULL)
  	  ;
  
          /* The operands of a SET must have the same mode unless one
*************** add_to_sequence (pattern, last, position
*** 868,876 ****
  
  	       If we know that the predicate does not allow CONST_INT,
  	       we know that the only way the predicate can match is if
! 	       the modes match (here we use the kludge of relying on the
! 	       fact that "address_operand" accepts CONST_INT; otherwise,
! 	       it would have to be a special case), so we can test the
  	       mode (but we need not).  This fact should considerably
  	       simplify the generated code.  */
  
--- 868,876 ----
  
  	       If we know that the predicate does not allow CONST_INT,
  	       we know that the only way the predicate can match is if
! 	       the modes match (here we used to use the kludge of relying
! 	       on "address_operand" accepting CONST_INT, but that is not
! 	       true for all architectures), so we can test the
  	       mode (but we need not).  This fact should considerably
  	       simplify the generated code.  */
  
*************** add_to_sequence (pattern, last, position
*** 900,906 ****
  	  }
  
  	/* Can't enforce a mode if we allow const_int.  */
! 	if (allows_const_int)
  	  mode = VOIDmode;
  
  	/* Accept the operand, ie. record it in `operands'.  */
--- 900,908 ----
  	  }
  
  	/* Can't enforce a mode if we allow const_int.  */
! 	if (allows_const_int
! 	    || (GET_CODE (pattern) == MATCH_OPERAND
! 		&& strstr (XSTR (pattern, 1), "address_operand") != NULL))
  	  mode = VOIDmode;
  
  	/* Accept the operand, ie. record it in `operands'.  */
*************** maybe_both_true_2 (d1, d2)
*** 1111,1117 ****
  		     mode of the memory, not the operand.  It can only
  		     be used for testing the predicate, so we must
  		     ignore it here.  */
! 		  && strcmp (d1->u.pred.name, "address_operand") != 0)
  		return 0;
  	    }
  	  /* Don't check two predicate modes here, because if both predicates
--- 1113,1119 ----
  		     mode of the memory, not the operand.  It can only
  		     be used for testing the predicate, so we must
  		     ignore it here.  */
! 		  && strstr (d1->u.pred.name, "address_operand") == NULL)
  		return 0;
  	    }
  	  /* Don't check two predicate modes here, because if both predicates