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.

Reply via email to