Optimizing away static variable / passing by reference

In this question Will a static variable always use up memory? it is stated that compilers are allowed to optimize away a static variable if the address is never taken, e.g. like following:

void f() {
   static int i = 3;
   printf( "%d", i );
}

1. If there exists a function which takes its arguments by reference, is the compiler still allowed to optimize away the variable, e.g. as in

void ref( int & i ) {
    printf( "%d", i );
}
void f() {
   static int i = 3;
   g( i );
}

2. Is the situation different for the "perfect forwarding" case. Here the function body is empty on purpose:

template< typename T >
void fwd( T && i ) {
}
void f() {
   static int i = 3;
   fwd( i );
}

3. Furthermore, would the compiler be allowed to optimize the call in the following case. (The function body is empty on purpose again):

void ptr( int * i ) {
}
void f() {
   static int i = 3;
   ptr( &i );
}

My questions arise from the fact, that references are not a pointer by the standard - but implemented as one usually.

Apart from, "is the compiler allowed to?" I am actually more interested in whether compilers do this kind of optimization?

Solution 1:

that compilers are allowed to optimize away a static variable if the address is never taken

You seem to concentrated on the wrong part of the answer. The answer states:

the compiler can do anything it wants to your code so long as the observable behavior is the same

The end. You can take the address, don't take it, calculate the meaning of life and calculate how to heal cancer, the only thing that matters is observable effect. As long as you don't actually heal cancer (or output the results of calculations...), all calculations are just no-op.

f there exists a function which takes its arguments by reference, is the compiler still allowed to optimize away the variable

Yes. The code is just putc('3').

Is the situation different for the "perfect forwarding" case

No. The code is still just putc('3').

would the compiler be allowed to optimize the call in the following case

Yes. This code has no observable effect, contrary to the previous ones. The call to f() can just be removed.

in whether compilers do this kind of optimization?

Copy your code to https://godbolt.org/ and inspect the assembly code. Even with no experience in assembly code, you will see differences with different code and compilers.

Choose x86 gcc (trunk) and remember to enable optimizations -O. Copy code with static, then remove static - did the code change? Repeat for all code snippets.

Solution 2:

Compilers are allowed to optimize out variables under the "as-if" rule, meaning that the compiler is allowed to do any optimization that doesn't alter the observable behaviour of the program. Whether the optimization actually occurs depends on how good the compiler's optimizer is, what optimization level you request, and whether the optimization belongs to a class of optimizations that actually improve performance (humans are not very good at predicting this).

In all of the examples you gave, the as-if rule gives the compiler latitude to eliminate the static variable.

In example 1, the definition of f is equivalent to void f() { printf("%d", 3); }. Since this has the exact same observable behaviour as the f you wrote, the compiler is allowed to replace one by the other, optimizing out the variable.

In example 2, since fwd does nothing, the definition of f is equivalent to void f() {}. Again, the as-if rule allows the compiler to replace the f you wrote with this empty function.

Example 3 is very similar to example 2 in terms of the implications of the as-if rule.

If you want to see whether a compiler will actually perform these optimizations, Godbolt is very useful. For example, if you look here, you'll see that at -O2, both GCC and Clang will perform the optimization described for example 1. They probably do this by first inlining ref into f.