Does gcc optimize c++ code algebraically and if so to what extent?

Question

Consider the following piece of code showing some simple arithmetic operations

    int result = 0;

    result = c * (a + b) + d * (a + b) + e;

Answer 1

GCC (and most C++ compilers, for that matter) does not refactor algebraic expressions.

This is mainly because as far as GCC and general software arithmetic is concerned, the lines

double x = 0.5 * (4.6 + 6.7);
double y = 0.5 * 4.6 + 0.5 * 6.7;

assert(x == y); //Will probably fail!

Are not guaranteed to be evaluate to the exact same number. GCC can't optimize these structures without that kind of guarantee.

Furthermore, order of operations can matter a lot. For example:

int x = y;
int z = (y / 16) * 16;

assert(x == z); //Will only be true if y is a whole multiple of 16

Algebraically, those two lines should be equivalent, right? But if y is an int, what it will actually do is make x equal to "y rounded to the lower whole multiple of 16". Sometimes, that's intended behavior (Like if you're byte aligning). Other times, it's a bug. The important thing is, both are valid computer code and both can be useful depending on the circumstances, and if GCC optimized around those structures, it would prevent programmers from having agency over their code.