编译器优化call-ret vs jmp

Question

I am building one of the projects and I am looking at the generated list file.(target: x86-64) My code looks like:

int func_1(var1,var2){
       asm_inline_(
       )
       func_2(var1,var2);
       return_1;      
}
void func_2(var_1,var_2){
     asm __inline__(
     )
     func_3();
}
/**** Jump to kernel ---> System call stub in assembly. This func in .S file***/
void func_3(){
}

When I see the assembly code, I find "jmp" instruction is used instead of "call-return" pair when calling func_2 and func_3. I am sure it is one of the compiler optimization and I have not explored how to disable it. (GCC) The moment I add some volatile variables to func_2 and func_3 and increment them then "jmp" gets replaced by "call-ret" pair. I am bemused to see the behavior because those variables are useless and they don't serve any purpose. Can someone please explain the behavior?

Thanks

Answer 1

If code jumps to the start of another function rather than calling it, when the jumped-to function returns, it will return back to the point where the outer function was called from, ignoring any more of the first function after that point. Assuming the behaviour is correct (the first function contributed nothing else to the execution after that point anyway), this is an optimisation because it reduces the number of instructions and stack manipulations by one level.

In the given example, the behaviour is correct; there's no local stack to pop and no value to return, so there is no code that needs to run after the call. ( return_1 , assuming it's not a macro for something, is a pure expression and therefore does nothing no matter its value.) So there's no reason to keep the stack frame around for the future when it has nothing more to contribute to events.

If you add volatile variables to the function bodies, you aren't just adding variables whose flow the compiler can analyse - you're adding slots that you've explicitly told the compiler could be accessed outside the normal control flow it can predict. The volatile qualifier warns the compiler that even though there's no obvious way for the variables to escape, something outside has a way to get their address and write to it at any time. So it can't reduce their lifetime, because it's been told that code outside the function might still try to write to that stack space; and obviously that means the stack frame needs to continue to exist for its entire declared lifespan.