How does const affects code generation in C/C++? Last time I checked, const was purely informational. Compilers can't eliminate reads for const pointer data, because const_cast exists. Compilers can't eliminate double calls to const methods, because inside function definition such functions can still legally modify mutable variables (and have many side effects).

What actually may help is __attribute__((pure)) and __attribute__((const)), but I don't see them often in real code (unfortunately).

Const affects code generation when used on variables. If you have a `const int i` then the compiler can assume that i never changes.

But you're right that this does not hold true for const pointers or references.

> What actually may help is __attribute__((pure)) and __attribute__((const)), but I don't see them often in real code (unfortunately).

It's disppointing that these haven't been standardized. I'd prefer different semantics though, e.g. something that allows things like memoization or other forms of caching that are technically side effects but where you still are ok with allowing the compiler to remove / reorder / eliminate calls.

Do you have an example where a const on a variable changes codegen? I would be surprised if the compiler couldn't figure out variable constness itself.

Sure, in the following example the compiler is able to propagate the constant to the return statement with const in f1 but needs to load it back from the stack without const in f0:

https://godbolt.org/z/6ebrbaM7b

In general, whenever you call a function that the compiler cannot inspect (because it is in another TU) and the compiler cannot prove that that function doesn't have any reference to your variable it has to assume that the function might change your variable. Only passing a const reference won't help you here because it is legal to cast away constness and modify the variable unless the original variable was const.

I wish that const meant something on reference or pointers and you had to do something more explicit like a mutable member to allow modifying a variable. But even that would not help if the compiler can't prove that a non-const pointer hasn't escaped somehow. You could add __attribute__((pure)) to the function to help the compiler but that is a lot stricter so can't always be used.

If you modify a const variable, compiler will error out and refuse to compile.

> If you have a `const int i` then the compiler can assume that i never changes.

Plus, you can’t even compile your code if you try to modify a const variable.

This isn't guaranteed: Modification after const cast on a const variable is ill formed but the compiler is not required to diagnose it - an generally it can't because it doesn't know what your reference/pointer points to.