"Victor L. Do Nascimento" <victor.donascime...@arm.com> writes:
> The function `constrain_operands' lacked the logic to consider relaxed
> memory constraints when "traditional" memory constraints were not
> satisfied, creating potential issues as observed during the reload
> compilation pass.
>
> In addition, it was observed that while `constrain_operands' chooses
> to disregard constraints when more than one alternative is provided,
> e.g. "m,r" using CONSTRAINT__UNKNOWN, it has no checks in place to
> determine whether the multiple constraints in a given string are in
> fact repetitions of the same constraint and should thus in fact be
> treated as a single constraint, as ought to be the case for something
> like "m,m".
>
> Both of these issues are dealt with here, thus ensuring that we get
> appropriate pattern matching.
>
> Tested on aarch64-linux-gnu & x86_64-linux-gnu. OK to install?
>
> Victor
>
> gcc/
> * lra-constraints.cc (constraint_unique): New.
> (process_address_1): Apply constraint_unique test.
> * recog.cc (constrain_operands): Allow relaxed memory
> constaints.
> ---
> gcc/lra-constraints.cc | 40 +++++++++++++++++++++++++++++++++++++---
> gcc/recog.cc | 3 ++-
> 2 files changed, 39 insertions(+), 4 deletions(-)
>
> diff --git a/gcc/lra-constraints.cc b/gcc/lra-constraints.cc
> index dd4f68bbfc0..6a13e64d7e1 100644
> --- a/gcc/lra-constraints.cc
> +++ b/gcc/lra-constraints.cc
> @@ -3448,6 +3448,42 @@ skip_constraint_modifiers (const char *str)
> }
> }
>
> +/* Takes a string of 0 or more comma-separated constraints and the
> + constraint_num correspondig to the first constraint. When more
corresponding
> + than one constraint present, evaluate whether they all correspond
is present
> + to a single, repeated constraint (e.g. "r,r") or whether we have
> + more than one distinct constraints (e.g. "r,m"). */
> +static bool
> +constraint_unique (const char *cstr)
> +{
> + enum constraint_num ca, cb;
> + ca = CONSTRAINT__UNKNOWN;
> + for (;;)
> + {
> + cstr = skip_constraint_modifiers (cstr);
> + if (*cstr == '\0' || *cstr == ',')
> + cb = CONSTRAINT_X;
> + else
> + {
> + cb = lookup_constraint (cstr);
> + if (cb == CONSTRAINT__UNKNOWN)
> + return false;
> + cstr += CONSTRAINT_LEN (cstr[0], cstr);
> + }
> + /* Treat the special case of an uninitialized ca. */
Maybe: /* Handle the first iteration of the loop. */
> + if (ca == CONSTRAINT__UNKNOWN)
> + ca = cb;
> + /* Treat the general case of comparing ca with subsequent
> + constraints. */
s/Treat/Handle/
OK with those changes, thanks.
Richard
> + else if (ca != cb)
> + return false;
> + if (*cstr == '\0')
> + return true;
> + if (*cstr == ',')
> + cstr += 1;
> + }
> +}
> +
> /* Major function to make reloads for an address in operand NOP or
> check its correctness (If CHECK_ONLY_P is true). The supported
> cases are:
> @@ -3507,9 +3543,7 @@ process_address_1 (int nop, bool check_only_p,
> operand has one address constraint, probably all others constraints are
> address ones. */
> if (constraint[0] != '\0' && get_constraint_type (cn) != CT_ADDRESS
> - && *skip_constraint_modifiers (constraint
> - + CONSTRAINT_LEN (constraint[0],
> - constraint)) != '\0')
> + && !constraint_unique (constraint))
> cn = CONSTRAINT__UNKNOWN;
> if (insn_extra_address_constraint (cn)
> /* When we find an asm operand with an address constraint that
> diff --git a/gcc/recog.cc b/gcc/recog.cc
> index 200cf4214f1..3ddeab59d92 100644
> --- a/gcc/recog.cc
> +++ b/gcc/recog.cc
> @@ -3234,7 +3234,8 @@ constrain_operands (int strict, alternative_mask
> alternatives)
> else if (constraint_satisfied_p (op, cn))
> win = 1;
>
> - else if (insn_extra_memory_constraint (cn)
> + else if ((insn_extra_memory_constraint (cn)
> + || insn_extra_relaxed_memory_constraint (cn))
> /* Every memory operand can be reloaded to fit. */
> && ((strict < 0 && MEM_P (op))
> /* Before reload, accept what reload can turn
