[Bug c/97434] New: Missed dead code optimization from data flow analysis

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

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

            Bug ID: 97434
           Summary: Missed dead code optimization from data flow analysis
           Product: gcc
           Version: 8.3.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c
          Assignee: unassigned at gcc dot gnu.org
          Reporter: jwerner at chromium dot org
  Target Milestone: ---

I found a pretty simple case where GCC cannot optimize out a redundant check.
I've reduced it to the following minimal test case:


unsigned int random_number(void);                                               
void eliminate_me(void);                                                        

void main(void)                                                                 
{                                                                               
        unsigned int a = random_number();                                       
        unsigned int b = random_number();                                       

        if (b > a)                                                              
                return;                                                         

        int x = b - 8;                                                          

        if (x > 0 && x > a)                                                     
                eliminate_me();                                                 
}


I think it should be really easy to prove that eliminate_me() cannot be called,
because x can never be greater than a (otherwise b would have also been greater
than a and the function would have terminated earlier). I don't know anything
about how compilers do data flow analysis in detail, but GCC can usually figure
out so much that I'm surprised it cannot figure out this one.