[Bug c/106981] [10/11/12/13 Regression][OpenACC][OpenMP] ICE in decompose, at wide-int.h:984 with '#pragma omp/acc atomic capture'

["burnus at gcc dot gnu.org" <gcc-bugzilla@gcc.gnu.org>]

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

Tobias Burnus <burnus at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
           Keywords|ice-on-valid-code           |ice-on-invalid-code

--- Comment #2 from Tobias Burnus <burnus at gcc dot gnu.org> ---
Fails in

c_parser_binary_expression's POP  for the second c_type_equal, which is
probably:

    stack[sp].expr                                                            \
      = convert_lvalue_to_rvalue (stack[sp].loc,                              \
                                  stack[sp].expr, true, true);                \

there:

c_tree_equal (t1=0x7ffff710dce0, t2=0x7ffff710dba0) at
../../repos/gcc-trunk-commit/gcc/c/c-typeck.cc:16039

(gdb) p debug((tree)0x7ffff710dce0)
*(totals + (sizetype) ((long unsigned int) (x % ((int) n / 10 + 1)) * 8))

(gdb) p debug((tree)0x7ffff710dba0)
*(totals + (sizetype) ((long unsigned int) (x % (int) ((unsigned int) (n / 10)
+ 1)) * 8))

where 'n' is 'long long' and 'x' and the digits are 'int' - the expr right of
'%' differs in terms of casts.


The ICE can be prevented with:
------------------------
--- a/gcc/c/c-typeck.cc
+++ b/gcc/c/c-typeck.cc
@@ -16216,6 +16216,9 @@ c_tree_equal (tree t1, tree t2)
            && n != TREE_OPERAND_LENGTH (t2))
          return false;

+       if (n >= TREE_OPERAND_LENGTH (t2))
+         return false;
+
        for (i = 0; i < n; ++i)
          if (!c_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)))
            return false;

------------------------


With this patch, the code fails – but C++ and C have different messages.

* gcc – points to tailing ';':
input5.i:7:86: error: invalid form of ‘#pragma omp atomic’ before ‘;’ token
    7 |       c[x] = totals[x%((int)(n/10 + 1))] = (a[x] + b[x]) +
totals[x%((int) n/10 + 1)];
      |                                                                        
             ^


* g++ - points to '(' in '... = (a[x ...':
input5.i:7:44: error: invalid form of ‘#pragma omp atomic’ before ‘(’ token
    7 |       c[x] = totals[x%((int)(n/10 + 1))] = (a[x] + b[x]) +
totals[x%((int) n/10 + 1)];
      |                                            ^


**************

Open... specification view. The expression is in the source code:
 __v_ = __x________________________ = ____expr_____ +
________x'________________
 c[x] = totals[x%((int)(n/10 + 1))] = (a[x] + b[x]) + totals[x%((int) n/10 +
1)];

and, obviously, x != x' due to the cast differences.

Looking at the OpenACC 3.2 spec, he last expr fits, except that x != x':
---------
If the atomic-clause is capture:
  v = x++;
  v = x--;
  v = ++x;
  v = --x;
  v = x binop= expr;
  v = x = x binop expr;
  v = x = expr binop x;
---------

Likewise in OpenMP 5.2:
---------
An update-atomic structured block is update-expr-stmt, an update expression
statement that has one of the following forms:
...
x = x binop expr;
x = expr binop x;

...
A capture-atomic structured block is capture-stmt, a capture statement that
has one of the following forms:
v = expr-stmt
...
---------