Friday, October 19, 2007

Caller-saves versus Callee-saves

Consider two functions say fun and bar and bar is calling fun, then bar is called the caller and fun is called the callee. All the registers saved by fun is called callee saved registers and the registers saved by bar is called caller saved registers. Now that we know what caller saved registers and callee saved registers are, let’s look into their role in register allocation.

A good complier will make sure that there are as many registers are available for allocator to work with. This is not always an easy job. When one function calls another function, the values in the registers used by the parent or the caller should not be altered by the child or the callee. One way to make sure this is happening is to save all the registers used by the caller just before calling the callee. Thus the callee can access all the registers without any restrictions and the allocator can also do its function efficiently. Another way for smooth functioning of the allocator is to make the callee save all the registers just before executing its main function body. Yet another way is to make sure that none of the registers used by the caller is allocated to the callee. The caller need to save only those registers which are live across the call and the callee need to save only the registers which are used inside the callee function. This is so because the registers allocator will have information about which all variables are live across a call in the caller and which all variables are used inside a callee function. Whenever a register is saved, it should be reloaded back into the registers either by the caller after the function call or by the callee just before returning to the parent depending on whether its caller saved or callee saved. So basically the only difference between the caller saves and callee saves comes down to when the registers get actually saved.

A compiler can be either use caller save strategy or callee save strategy, but this has got some problems. The entire caller saved registers may not be used in the callee function and not all the registers saved by the callee are live or used across the function call. We cannot avoid these unnecessary saves since when one function is being complied we don’t know the register usage of callee/caller. But unnecessary saves can be reduced by adopting a mix of caller save and callee save strategy. In this some set of registers will be marked as caller save registers and another set will be marked as callee saved registers. No registers will be in both the sets and all the registers available need not be in both the sets. So if any of the registers in the caller save list is live across the function call, then only they need to be saved and not all the registers live across the call. If a mixed strategy is used the variables that are live across a function call should be allocated to callee saved registers. This way, the caller doesn’t have to save these and ,with luck, they don’t have to be saved by the callee either (if the callee doesn’t use these registers in its body).



3 comments:

Arun PC said...

Shafi,
Nice blog. I like it. Not that i understood it all and i can apply it in my day to day job(i dont play with compilers).

This is why i like it.
1) It is focussed. It deals with compilers and compilers only.
2) You dont talk about urself and fill the blog with stories.

Keep up the good work.

Thanks,
Arun.PC
arunpc.wordpress.com

▲NW▲R said...

Hey...the article is excellent...but i never unserstood a single word except compilers...coz am not into compilers...So y dont u write some amateur posts for those who r beginners like me....
Thanks

Anonymous said...

Hi Shafi,
Nice blog!. I want you to give more information on compiler optimizations in coming days.

Regards,
Mallikarjun