What is the state of the registers after a function call?

Question

I have limited knowledge in assembly, but I can at least read through it and match with the corresponding C or C++ code. I can see that the function arguments are passed either by pushing them to the stack or by registers, and the function body uses some registers to do its operations. But it also seems to use the same registers that were used in the caller. Does this mean that the caller has no guarantee that the state of the registers will be the same after a function call? What if the whole body of the function is unknown during compilation? How does the compiler deal with this?

Answer 1

The compiler-generated assembler code follows some calling convention. A calling convention typically specifies

• how are arguments passed to the function
• how return values are passed from the called function to the caller
• which registers should be saved within a function call and which can be modified

If all functions being called follow the same calling convention, no problems with using the same registers should occur.

Answer 2

As the comments allude to, the fact is that there is no standard for this. It is left entirely to the implementors of the particular c++ compiler you are using.

A more explicit question, like this: "when compiling on version N of compiler A with compiler options B, calling a function signature of C, for target CPU D, using ABI E, what are the guarantees vis-a-vis register preservation?"

In which case an expert (or the manual) on that particular toolset can answer.

As you can probably infer, for any kind of industrial-strength project, it's the wrong question to ask, because as your compiler evolves the answer will change, and you don't want that fact to impact the reliability of your program.

It's a good question, because it's nice to know what the compiler is doing under the hood - it aids learning.

But on the whole, the golden rule is to express clear uncomplicated logic to the compiler in your program, and allow the compiler to handle the details of turning that logic into optimised machine code, at which modern compilers are excellent.