Do Modern C/C Compilers Utilize Push/Pop Instructions for Efficient Local Variable Management?

What C/C Compilers Can Utilize Push/Pop Instructions for Creating Local Variables?

Introduction

Contrary to the common practice of incrementally increasing ESP, this question delves into the possibility of employing push and pop instructions to establish local variables, aiming to optimize code compactness and possibly performance.

Compiler Considerations

Compiler Optimization:

• All four major x86 compilers (GCC, ICC, MSVC, clang) have abandoned push for optimizations.
• This is primarily due to the high utilization of push on yesteryear's CPUs, which negatively impacted super-scalar core efficiency.
• However, modern compilers have reintroduced push/pop for performance gains, especially in the manipulation of stack arguments and call-preserved registers.

Stack Engine Optimization:

• Recent CPUs like Intel since Pentium-M and AMD since Bulldozer incorporate a "stack engine" that tracks RSP modifications efficiently.
• This feature enables the use of push/pop/call/ret without incurring performance penalties.
• Careful utilization of push/pop can lead to performance enhancements by optimizing for speed rather than solely code size.

Code Sample

Consider the following example:

int extfunc(int *, int *);

void foo() {
    int a=1, b=2;
    extfunc(&a, &b);
}

Compiler Output

GCC, ICC, MSVC, and clang all generate code that begins with a push instruction, followed by stack manipulation and the call to extfunc. This aligns with the observation that modern compilers utilize push for optimizations.

Optimal Solution

A further optimized solution would be:

push    2                  # only 2 bytes
lea     rdi, [rsp + 4]
mov     dword ptr [rdi], 1
mov     rsi, rsp              # special case for lea rsi, [rsp + 0]
call    extfunc(int*, int*)
pop     rax                 # alternative to add rsp,8
ret

In this case, a single push instruction allocates space for both local variables while leaving the stack 16-byte aligned. This optimizes code size and maintains efficiency.

Additional Considerations

• Mixing push with [rsp] addressing modes can introduce additional stack-sync uops on Intel CPUs, potentially reducing efficiency.
• Compilers generally refrain from implementing this optimization as it requires careful calculation and balancing of tradeoffs to avoid performance degradation.

The above is the detailed content of Do Modern C/C Compilers Utilize Push/Pop Instructions for Efficient Local Variable Management?. For more information, please follow other related articles on the PHP Chinese website!