Testcase (-Os):

int f(int* a) {
  if (*a > 5 && ((*a % 2 == 0 && *a < 20) || (*a > 10 && *a % 3 != 0))) { 
    *a = *a * 2;
  }
  int arr[5];
  for (int i = 0; i < 5; i++) {
    arr[i] = *a + i;
  }
  for (int j = 0; j < 3; j++) {
    for (int k = 0; k < 2 && arr[j] % 2 == 0; k++) {
      arr[j] += k * 2;
    }
  }

  int sum = 0;
  for (int m = 0; m < 5 && (arr[m] % 3 == 0 || arr[m] > 10); m++) {
    sum += arr[m] * (m % 2 == 0 ? 2 : 3);
    for (int n = 0; n < 2 && (sum % 2 != 0 || m > 2); n++) {
      sum -= n * (m % 2 == 0 ? 1 : 2);
      if (n > 0 && sum > 10 && (arr[m] % 2 != 0 || m < 3)) {
        sum += arr[m] / 2;
      }
    }
    if (sum > 20 && m > 1) {
      sum *= 2;
    }
  }
  arr[0] += sum;

  return arr[0];
}


Bisects to:

commit aadc5c07feb0ab08729ab25d0d896b55860ad9e6                                            
Author: Andrew Pinski <apinski@marvell.com>                                                                                                                                           
Date:   Mon Aug 7 00:05:21 2023 -0700                                                                                                                                                 
                                                                                                                                                                                      
    VR-VALUES [PR28794]: optimize compare assignments also                                                                                                                            
                                                                                                                                                                                      
    This patch fixes the oldish (2006) bug where VRP was not                                                                                                                          
    optimizing the comparison for assignments while handling                                                                                                                          
    them for GIMPLE_COND only.                                                             
    It just happens to also solves PR 103281 due to allowing                               
    to optimize `c < 1` to `c == 0` and then we get                                        
    `(c == 0) == c` (which was handled by r14-2501-g285c9d04).                             
                                                                                           
    OK? Bootstrapped and tested on x86_64-linux-gnu with no                                
    regressions.                                                                           
                                             
            PR tree-optimization/103281      
            PR tree-optimization/28794                                                     
                                             
    gcc/ChangeLog:                           
                                             
            * vr-values.cc (simplify_using_ranges::simplify_cond_using_ranges_1): Split out
            majority to ...                                                                
            (simplify_using_ranges::simplify_compare_using_ranges_1): Here.                
            (simplify_using_ranges::simplify_casted_cond): Rename to ...                   
            (simplify_using_ranges::simplify_casted_compare): This                         
            and change arguments to take op0 and op1.                                      
            (simplify_using_ranges::simplify_compare_assign_using_ranges_1): New method.   
            (simplify_using_ranges::simplify): For tcc_comparison assignments call         
            simplify_compare_assign_using_ranges_1.                                        
            * vr-values.h (simplify_using_ranges): Add                                     
            new methods, simplify_compare_using_ranges_1 and simplify_compare_assign_using_ranges_1.
            Rename simplify_casted_cond and simplify_casted_compare and                    
            update argument types.                                                         
                                             
    gcc/testsuite/ChangeLog:                                                               
                                             
            * gcc.dg/tree-ssa/pr103281-1.c: New test.                                      
            * gcc.dg/tree-ssa/vrp-compare-1.c: New test.                                   

 gcc/testsuite/gcc.dg/tree-ssa/pr103281-1.c    |  19 +++                                   
 gcc/testsuite/gcc.dg/tree-ssa/vrp-compare-1.c |  13 +++                                   
 gcc/vr-values.cc                              | 160 ++++++++++++++++----------            
 gcc/vr-values.h                               |   4 +-                                    
 4 files changed, 134 insertions(+), 62 deletions(-)                                       
 create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr103281-1.c                             
 create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/vrp-compare-1.c