[Bug c/97971] New: [9/10/11 Regression] ICE in process_alt_operands, at lra-constraints.c:3110

[Bug c/97971] New: [9/10/11 Regression] ICE in process_alt_operands, at lra-constraints.c:3110

[gscfq@t-online.de]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97971

            Bug ID: 97971
           Summary: [9/10/11 Regression] ICE in process_alt_operands, at
                    lra-constraints.c:3110
           Product: gcc
           Version: 11.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c
          Assignee: unassigned at gcc dot gnu.org
          Reporter: gscfq@t-online.de
  Target Milestone: ---

Started with r9 between 20181104 and 20181111 :


$ cat z1.c
int f ()
{
  register _Complex a asm ("rax");
  register int b asm ("rdx");
  asm ("abc %0 %1" : "=&r" (a), "=r" (b));
  return a;
}


$ gcc-11-20201122 -c z1.c
z1.c: In function 'f':
z1.c:7:1: error: unable to generate reloads for impossible constraints:
    7 | }
      | ^
(insn 5 2 6 2 (parallel [
            (set (reg/v:DC 0 ax [ a ])
                (asm_operands:DC ("abc %0 %1") ("=&r") 0 []
                     []
                     [] z1.c:5))
            (set (reg/v:SI 1 dx [ b ])
                (asm_operands:SI ("abc %0 %1") ("=r") 1 []
                     []
                     [] z1.c:5))
            (clobber (reg:CC 17 flags))
        ]) "z1.c":5:3 -1
     (expr_list:REG_UNUSED (reg:CC 17 flags)
        (expr_list:REG_UNUSED (reg/v:SI 1 dx [ b ])
            (expr_list:REG_UNUSED (reg:DI 1 dx)
                (nil)))))
during RTL pass: reload
z1.c:7:1: internal compiler error: in process_alt_operands, at
lra-constraints.c:3110
0x5f12f5 _fatal_insn(char const*, rtx_def const*, char const*, int, char
const*)
        ../../gcc/rtl-error.c:108
0x9de587 process_alt_operands
        ../../gcc/lra-constraints.c:3109
0x9e190b curr_insn_transform
        ../../gcc/lra-constraints.c:4073
0x9e4646 lra_constraints(bool)
        ../../gcc/lra-constraints.c:5138
0x9d28e2 lra(_IO_FILE*)
        ../../gcc/lra.c:2331
0x98dde9 do_reload
        ../../gcc/ira.c:5802
0x98dde9 execute
        ../../gcc/ira.c:5988

[Bug c/97971] [9/10/11 Regression] ICE in process_alt_operands, at lra-constraints.c:3110

[jakub at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97971

Jakub Jelinek <jakub at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |jakub at gcc dot gnu.org

--- Comment #1 from Jakub Jelinek <jakub at gcc dot gnu.org> ---
_Complex with ("rax") occupies the rax/rdx registers, so the testcase is
invalid.
As it is during processing inline asm, I think it should use the standard
reload diagnostics about impossible to reload asm.

[Bug c/97971] [9/10/11 Regression] ICE in process_alt_operands, at lra-constraints.c:3110

[rguenth at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97971

Richard Biener <rguenth at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|---                         |9.4
           Keywords|                            |diagnostic

[Bug c/97971] [9/10/11 Regression] ICE in process_alt_operands, at lra-constraints.c:3110

[rguenth at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97971

Richard Biener <rguenth at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
           Priority|P3                          |P2

[Bug middle-end/97971] [9/10/11 Regression] ICE in process_alt_operands, at lra-constraints.c:3110

[jakub at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97971

--- Comment #2 from Jakub Jelinek <jakub at gcc dot gnu.org> ---
Created attachment 50110
  --> https://gcc.gnu.org/bugzilla/attachment.cgi?id=50110&action=edit
gcc11-pr97971.patch

Untested fix.

[Bug middle-end/97971] [9/10/11 Regression] ICE in process_alt_operands, at lra-constraints.c:3110

[cvs-commit at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97971

--- Comment #3 from CVS Commits <cvs-commit at gcc dot gnu.org> ---
The master branch has been updated by Jakub Jelinek <jakub@gcc.gnu.org>:

https://gcc.gnu.org/g:eb69a49c4d3287e797e0d6279186221354905fe0

commit r11-7051-geb69a49c4d3287e797e0d6279186221354905fe0
Author: Jakub Jelinek <jakub@redhat.com>
Date:   Wed Feb 3 09:07:36 2021 +0100

    lra-constraints: Fix error-recovery for bad inline-asms [PR97971]

    The following testcase has ice-on-invalid, it can't be reloaded, but we
    shouldn't ICE the compiler because the user typed non-sense.

    In current_insn_transform we have:
      if (process_alt_operands (reused_alternative_num))
        alt_p = true;

      if (check_only_p)
        return ! alt_p || best_losers != 0;

      /* If insn is commutative (it's safe to exchange a certain pair of
         operands) then we need to try each alternative twice, the second
         time matching those two operands as if we had exchanged them.  To
         do this, really exchange them in operands.

         If we have just tried the alternatives the second time, return
         operands to normal and drop through.  */

      if (reused_alternative_num < 0 && commutative >= 0)
        {
          curr_swapped = !curr_swapped;
          if (curr_swapped)
            {
              swap_operands (commutative);
              goto try_swapped;
            }
          else
            swap_operands (commutative);
        }

      if (! alt_p && ! sec_mem_p)
        {
          /* No alternative works with reloads??  */
          if (INSN_CODE (curr_insn) >= 0)
            fatal_insn ("unable to generate reloads for:", curr_insn);
          error_for_asm (curr_insn,
                         "inconsistent operand constraints in an %<asm%>");
          lra_asm_error_p = true;
    ...
    and so handle inline asms there differently (and delete/nullify them after
    this) - fatal_insn is only called for non-inline asm.
    But in process_alt_operands we do:
                    /* Both the earlyclobber operand and conflicting operand
                       cannot both be user defined hard registers.  */
                    if (HARD_REGISTER_P (operand_reg[i])
                        && REG_USERVAR_P (operand_reg[i])
                        && operand_reg[j] != NULL_RTX
                        && HARD_REGISTER_P (operand_reg[j])
                        && REG_USERVAR_P (operand_reg[j]))
                      fatal_insn ("unable to generate reloads for "
                                  "impossible constraints:", curr_insn);
    and thus ICE even for inline-asms.

    I think it is inappropriate to delete/nullify the insn in
    process_alt_operands, as it could be done e.g. in the check_only_p mode,
    so this patch just returns false in that case, which results in the
    caller have alt_p false, and as inline asm isn't simple move, sec_mem_p
    will be also false (and it isn't commutative either), so for check_only_p
    it will suggests to the callers it isn't ok and otherwise will emit
    error and delete/nullify the inline asm insn.

    2021-02-03  Jakub Jelinek  <jakub@redhat.com>

            PR middle-end/97971
            * lra-constraints.c (process_alt_operands): For inline asm, don't
call
            fatal_insn, but instead return false.

            * gcc.target/i386/pr97971.c: New test.

[Bug middle-end/97971] [9/10 Regression] ICE in process_alt_operands, at lra-constraints.c:3110

[jakub at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97971

Jakub Jelinek <jakub at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Last reconfirmed|                            |2021-02-03
             Status|UNCONFIRMED                 |ASSIGNED
            Summary|[9/10/11 Regression] ICE in |[9/10 Regression] ICE in
                   |process_alt_operands, at    |process_alt_operands, at
                   |lra-constraints.c:3110      |lra-constraints.c:3110
           Assignee|unassigned at gcc dot gnu.org      |jakub at gcc dot gnu.org
     Ever confirmed|0                           |1

--- Comment #4 from Jakub Jelinek <jakub at gcc dot gnu.org> ---
Fixed on the trunk so far.

[Bug middle-end/97971] [9/10 Regression] ICE in process_alt_operands, at lra-constraints.c:3110

[cvs-commit at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97971

--- Comment #5 from CVS Commits <cvs-commit at gcc dot gnu.org> ---
The releases/gcc-10 branch has been updated by Jakub Jelinek
<jakub@gcc.gnu.org>:

https://gcc.gnu.org/g:4dd7141653b57f638fc32291245d57d4dcfa3813

commit r10-9462-g4dd7141653b57f638fc32291245d57d4dcfa3813
Author: Jakub Jelinek <jakub@redhat.com>
Date:   Wed Feb 3 09:07:36 2021 +0100

    lra-constraints: Fix error-recovery for bad inline-asms [PR97971]

    The following testcase has ice-on-invalid, it can't be reloaded, but we
    shouldn't ICE the compiler because the user typed non-sense.

    In current_insn_transform we have:
      if (process_alt_operands (reused_alternative_num))
        alt_p = true;

      if (check_only_p)
        return ! alt_p || best_losers != 0;

      /* If insn is commutative (it's safe to exchange a certain pair of
         operands) then we need to try each alternative twice, the second
         time matching those two operands as if we had exchanged them.  To
         do this, really exchange them in operands.

         If we have just tried the alternatives the second time, return
         operands to normal and drop through.  */

      if (reused_alternative_num < 0 && commutative >= 0)
        {
          curr_swapped = !curr_swapped;
          if (curr_swapped)
            {
              swap_operands (commutative);
              goto try_swapped;
            }
          else
            swap_operands (commutative);
        }

      if (! alt_p && ! sec_mem_p)
        {
          /* No alternative works with reloads??  */
          if (INSN_CODE (curr_insn) >= 0)
            fatal_insn ("unable to generate reloads for:", curr_insn);
          error_for_asm (curr_insn,
                         "inconsistent operand constraints in an %<asm%>");
          lra_asm_error_p = true;
    ...
    and so handle inline asms there differently (and delete/nullify them after
    this) - fatal_insn is only called for non-inline asm.
    But in process_alt_operands we do:
                    /* Both the earlyclobber operand and conflicting operand
                       cannot both be user defined hard registers.  */
                    if (HARD_REGISTER_P (operand_reg[i])
                        && REG_USERVAR_P (operand_reg[i])
                        && operand_reg[j] != NULL_RTX
                        && HARD_REGISTER_P (operand_reg[j])
                        && REG_USERVAR_P (operand_reg[j]))
                      fatal_insn ("unable to generate reloads for "
                                  "impossible constraints:", curr_insn);
    and thus ICE even for inline-asms.

    I think it is inappropriate to delete/nullify the insn in
    process_alt_operands, as it could be done e.g. in the check_only_p mode,
    so this patch just returns false in that case, which results in the
    caller have alt_p false, and as inline asm isn't simple move, sec_mem_p
    will be also false (and it isn't commutative either), so for check_only_p
    it will suggests to the callers it isn't ok and otherwise will emit
    error and delete/nullify the inline asm insn.

    2021-02-03  Jakub Jelinek  <jakub@redhat.com>

            PR middle-end/97971
            * lra-constraints.c (process_alt_operands): For inline asm, don't
call
            fatal_insn, but instead return false.

            * gcc.target/i386/pr97971.c: New test.

    (cherry picked from commit eb69a49c4d3287e797e0d6279186221354905fe0)

[Bug middle-end/97971] [9 Regression] ICE in process_alt_operands, at lra-constraints.c:3110

[jakub at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97971

Jakub Jelinek <jakub at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
            Summary|[9/10 Regression] ICE in    |[9 Regression] ICE in
                   |process_alt_operands, at    |process_alt_operands, at
                   |lra-constraints.c:3110      |lra-constraints.c:3110

--- Comment #6 from Jakub Jelinek <jakub at gcc dot gnu.org> ---
Fixed for 10.3 too.

[Bug middle-end/97971] [9 Regression] ICE in process_alt_operands, at lra-constraints.c:3110

[cvs-commit at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97971

--- Comment #7 from CVS Commits <cvs-commit at gcc dot gnu.org> ---
The releases/gcc-9 branch has been updated by Jakub Jelinek
<jakub@gcc.gnu.org>:

https://gcc.gnu.org/g:2f9a241a308c32108b922bd768b7576c5c34e440

commit r9-9414-g2f9a241a308c32108b922bd768b7576c5c34e440
Author: Jakub Jelinek <jakub@redhat.com>
Date:   Wed Feb 3 09:07:36 2021 +0100

    lra-constraints: Fix error-recovery for bad inline-asms [PR97971]

    The following testcase has ice-on-invalid, it can't be reloaded, but we
    shouldn't ICE the compiler because the user typed non-sense.

    In current_insn_transform we have:
      if (process_alt_operands (reused_alternative_num))
        alt_p = true;

      if (check_only_p)
        return ! alt_p || best_losers != 0;

      /* If insn is commutative (it's safe to exchange a certain pair of
         operands) then we need to try each alternative twice, the second
         time matching those two operands as if we had exchanged them.  To
         do this, really exchange them in operands.

         If we have just tried the alternatives the second time, return
         operands to normal and drop through.  */

      if (reused_alternative_num < 0 && commutative >= 0)
        {
          curr_swapped = !curr_swapped;
          if (curr_swapped)
            {
              swap_operands (commutative);
              goto try_swapped;
            }
          else
            swap_operands (commutative);
        }

      if (! alt_p && ! sec_mem_p)
        {
          /* No alternative works with reloads??  */
          if (INSN_CODE (curr_insn) >= 0)
            fatal_insn ("unable to generate reloads for:", curr_insn);
          error_for_asm (curr_insn,
                         "inconsistent operand constraints in an %<asm%>");
          lra_asm_error_p = true;
    ...
    and so handle inline asms there differently (and delete/nullify them after
    this) - fatal_insn is only called for non-inline asm.
    But in process_alt_operands we do:
                    /* Both the earlyclobber operand and conflicting operand
                       cannot both be user defined hard registers.  */
                    if (HARD_REGISTER_P (operand_reg[i])
                        && REG_USERVAR_P (operand_reg[i])
                        && operand_reg[j] != NULL_RTX
                        && HARD_REGISTER_P (operand_reg[j])
                        && REG_USERVAR_P (operand_reg[j]))
                      fatal_insn ("unable to generate reloads for "
                                  "impossible constraints:", curr_insn);
    and thus ICE even for inline-asms.

    I think it is inappropriate to delete/nullify the insn in
    process_alt_operands, as it could be done e.g. in the check_only_p mode,
    so this patch just returns false in that case, which results in the
    caller have alt_p false, and as inline asm isn't simple move, sec_mem_p
    will be also false (and it isn't commutative either), so for check_only_p
    it will suggests to the callers it isn't ok and otherwise will emit
    error and delete/nullify the inline asm insn.

    2021-02-03  Jakub Jelinek  <jakub@redhat.com>

            PR middle-end/97971
            * lra-constraints.c (process_alt_operands): For inline asm, don't
call
            fatal_insn, but instead return false.

            * gcc.target/i386/pr97971.c: New test.

    (cherry picked from commit 4dd7141653b57f638fc32291245d57d4dcfa3813)

[Bug middle-end/97971] [9 Regression] ICE in process_alt_operands, at lra-constraints.c:3110

[jakub at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97971

Jakub Jelinek <jakub at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
         Resolution|---                         |FIXED
             Status|ASSIGNED                    |RESOLVED

--- Comment #8 from Jakub Jelinek <jakub at gcc dot gnu.org> ---
Fixed.