Do recent C++ compilers detect repeated mathematical operations automatically?

Let's say I have the following Code:

const int n = fun1();
const double x = fun2();
for(int i=0; i < n; i++) {
    double y = fun3(i) / std::sqrt(x);
    double z = fun4(i) / std::sqrt(x);
    // Do something with the values, e.g., assign them to an array outside the loop
}

Do recent compilers manage to optimize it into

const int n = fun1();
const double x = fun2();
const double sqrtx = std::sqrt(x); // only computed once instead of possibly 2*n times
for(int i=0; i < n; i++) {
    double y = fun3(i) / sqrtx;
    double z = fun4(i) / sqrtx;
    // Do something with the values, e.g., assign them to an array outside the loop
}

or is it still worth to do such optimizations by hand?

(as of the time of writing) clang and gcc don't make this optimisation but MSVC does: https://godbolt.org/z/eKcva1heT. Clang and GCC both call sqrt twice, it's too complex for them to determine whether std::sqrt has side effects so they can't optimise away the calls.

With libc++ clang implements std::sqrt with a single sqrtsd instruction but still uses that instruction twice: https://godbolt.org/z/G5sEPYqEP.

If it was an inline function then the compiler potentially can remove duplicate operations. If we change your example to:

inline double square(double value)
{
    return value * value;
}

int main()
{
    const int n = fun1();
    const double x = fun2();
    for(int i=0; i < n; i++) {
        double y = fun3(i) / square(x);
        double z = fun4(i) / square(x);
        std::cout << x << y;
    }    
}

Then all three compilers only do the square once: https://godbolt.org/z/Ys6xPcsc1

Alan's answer is very good. I'm only here to supplement it:

Yes you should always "do such optimizations by hand", even if you have a "sufficiently smart compiler". The reason is that it makes your intentions more obvious.

Also, you should hoist the division too. Multiplications are less strenuous:

const int n = fun1();
const double x = fun2();
const double inv_sqrtx = 1 / std::sqrt(x); // only computed once instead of possibly 2*n times
for(int i=0; i < n; i++) {
	double y = fun3(i) * inv_sqrtx;
	double z = fun4(i) * inv_sqrtx;
	// Do something with the values, e.g., assign them to an array outside the loop
}

If you are really dumping yand z sequentially into arrays, it might even be profitable to use whatever SIMD intrinsics your CPU allows for.