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

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

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

--- Comment #5 from Jakub Jelinek <jakub at gcc dot gnu.org> ---
Slightly more reduced:
void
foo (int a, double *b, double *c, double *d, long long e)
{
#pragma omp atomic capture
  c[a] = d[((int) (e / 10 + 1))] = b[a] + d[((int) e / 10 + 1)];
}
The fix could be either partially backport what C++ FE did in
--- gcc/c/c-typeck.cc.jj        2022-09-23 09:02:56.525318361 +0200
+++ gcc/c/c-typeck.cc   2022-09-23 10:33:06.596467788 +0200
@@ -16069,6 +16069,9 @@ c_tree_equal (tree t1, tree t2)
   if (code1 != code2)
     return false;

+  if (CONSTANT_CLASS_P (t1) && !comptypes (TREE_TYPE (t1), TREE_TYPE (t2)))
+    return false;
+
   switch (code1)
     {
     case INTEGER_CST:
Or we could
--- gcc/c/c-typeck.cc.jj        2022-09-23 09:02:56.525318361 +0200
+++ gcc/c/c-typeck.cc   2022-09-23 10:33:06.596467788 +0200
@@ -16072,7 +16070,7 @@ c_tree_equal (tree t1, tree t2)
   switch (code1)
     {
     case INTEGER_CST:
-      return wi::to_wide (t1) == wi::to_wide (t2);
+      return wi::to_widest (t1) == wi::to_widest (t2);

     case REAL_CST:
       return real_equal (&TREE_REAL_CST (t1), &TREE_REAL_CST (t2));
but then it is accepted instead of rejected unlike C++.
I'm afraid even the
  for (code1 = TREE_CODE (t1);
       CONVERT_EXPR_CODE_P (code1)
         || code1 == NON_LVALUE_EXPR;
       code1 = TREE_CODE (t1))
    t1 = TREE_OPERAND (t1, 0);
  for (code2 = TREE_CODE (t2);
       CONVERT_EXPR_CODE_P (code2)
         || code2 == NON_LVALUE_EXPR;
       code2 = TREE_CODE (t2))
    t2 = TREE_OPERAND (t2, 0);
stuff is dangerous, I guess one could construct a valid OpenMP testcase like:
void
bar (int *a)
{
  unsigned int b = 0x100;
  #pragma omp atomic update
  a[(unsigned char) b] = a[(unsigned short) b] + a[(unsigned char) b];
  #pragma omp atomic update
  a[(unsigned char) b] = a[(unsigned char) b] + a[(unsigned short) b];
}
where for C++ I think we do the right thing in both cases, atomic increment of
a[0] by a[0x100], but in C we do atomic increment of a[0] by a[0] in the first
case.  Now, wonder what will break if I just strip same type casts and for
others like in C++ require same type.