Q:

What is the function execution order in code like foo(bar())?

Assume we have code like this in C or C++:
foo(bar());

What is the function execution order in this case?

Is it required that bar() is called first, and foo() is called no earlier than bar() returns, in which case foo() is passed the return value of bar()?
Is it permitted that the compiler reorders the above, namely that it calls foo() first, and delays calling bar() until in the code of foo() the value of foo()’s parameter is actually needed?

Case 2 could be useful for optimization should foo() be defined like this:
void foo(someType par) {
    if(someTest())
        baz1();
    else
        baz2(par);
}

In which case calling bar() could even be completely skipped if someTest() returns false.
However, case 2 would also make the programmer have to be more careful, as it could sometimes lead to subtle bugs (for example with recurrence).

A:

In C++, [intro.execution]:

When calling a function (whether or not the function is inline), every value computation and side effect associated with any argument expression, or with the postfix expression designating the called function, is sequenced before execution of every expression or statement in the body of the called function.

bar() must be evaluated before the call to foo begins. 
There was some change in C++17 that the expression a(b) now evaluates a before b whereas before they were unsequenced. In this case, the evaluation of foo doesn't do anything, it's just an identifier. But had we had foo()(bar()), then the call to foo() would be sequenced before the call to bar(), whereas prior to C++17, the two were unsequenced. 

A:

Is it required that bar() is called first […]?

The code is required to behave as if that's what's happening.

Is it permitted that the compiler reorders the above […]?

Yes, if the observable behavior is the same as if bar() was evaluated first.
This is known as the "as-if" rule:

[…] an implementation is free to disregard any requirement of this International Standard as long as the result is as if the requirement had been obeyed, as far as can be determined from the observable behavior of the program.

