recog/reload: Remove old UNARY_P operand support

reload and constrain_operands had some old code to look through unary
operators.  E.g. an operand could be (sign_extend (reg X)), and the
constraints would match the reg rather than the sign_extend.

This was previously used by the MIPS port.  But relying on it was a
recurring source of problems, so Eric and I removed it in the MIPS
rewrite from ~20 years back.  I don't know of any other port that used it.

Also, the constraints processing in LRA and IRA do not have direct
support for these embedded operators, so I think it was only ever a
reload-specific feature (and probably only a global/local+reload-specific
feature, rather than IRA+reload).

Keeping the checks caused problems for special memory constraints,
leading to:

	  /* A unary operator may be accepted by the predicate, but it
	     is irrelevant for matching constraints.  */
	  /* For special_memory_operand, there could be a memory operand inside,
	     and it would cause a mismatch for constraint_satisfied_p.  */
	  if (UNARY_P (op) && op == extract_mem_from_operand (op))
	    op = XEXP (op, 0);

But inline asms are another source of problems.  Asms don't have
predicates, and so we can't use recog to decide whether a given change
to an asm gives a valid match.  We instead rely on constrain_operands as
something of a recog stand-in.  For an example like:

    void
    foo (int *ptr)
    {
      asm volatile ("%0" :: "r" (-*ptr));
    }

any attempt to propagate the negation into the asm would be allowed,
because it's the negated register that would be checked against the
"r" constraint.  This would later lead to:

    error: invalid 'asm': invalid operand

The same thing happened in gcc.target/aarch64/vneg_s.c with the
upcoming late-combine pass.

Rather than add more workarounds, it seemed better just to delete
this code.

gcc/
	* recog.cc (constrain_operands): Remove UNARY_P handling.
	* reload.cc (find_reloads): Likewise.

diff --git a/gcc/recog.cc b/gcc/recog.cc
index 92f151248a64f1bd581cbf18225e99b3eaeaaf6b..e12b4c9500e3323ceb5675d9aa4263573b0b6a18 100644 (file)
--- a/gcc/recog.cc
+++ b/gcc/recog.cc
@@ -3080,13 +3080,6 @@ constrain_operands (int strict, alternative_mask alternatives)
 
          earlyclobber[opno] = 0;
 
-         /* A unary operator may be accepted by the predicate, but it
-            is irrelevant for matching constraints.  */
-         /* For special_memory_operand, there could be a memory operand inside,
-            and it would cause a mismatch for constraint_satisfied_p.  */
-         if (UNARY_P (op) && op == extract_mem_from_operand (op))
-           op = XEXP (op, 0);
-
          if (GET_CODE (op) == SUBREG)
            {
              if (REG_P (SUBREG_REG (op))
@@ -3152,14 +3145,6 @@ constrain_operands (int strict, alternative_mask alternatives)
                    {
                      rtx op1 = recog_data.operand[match];
                      rtx op2 = recog_data.operand[opno];
-
-                     /* A unary operator may be accepted by the predicate,
-                        but it is irrelevant for matching constraints.  */
-                     if (UNARY_P (op1))
-                       op1 = XEXP (op1, 0);
-                     if (UNARY_P (op2))
-                       op2 = XEXP (op2, 0);
-
                      val = operands_match_p (op1, op2);
                    }
 

diff --git a/gcc/reload.cc b/gcc/reload.cc
index 2e57ebb3cac6c068804fe309d38009e2a24d8283..07256b6cf2f728551f550824eb2af803ab612297 100644 (file)
--- a/gcc/reload.cc
+++ b/gcc/reload.cc
@@ -3077,12 +3077,6 @@ find_reloads (rtx_insn *insn, int replace, int ind_levels, int live_known,
              enum constraint_num cn;
              enum reg_class cl;
 
-             /* If the predicate accepts a unary operator, it means that
-                we need to reload the operand, but do not do this for
-                match_operator and friends.  */
-             if (UNARY_P (operand) && *p != 0)
-               operand = XEXP (operand, 0);
-
              /* If the operand is a SUBREG, extract
                 the REG or MEM (or maybe even a constant) within.
                 (Constants can occur as a result of reg_equiv_constant.)  */