Clang编译C++代码中重复lea指令的原因问询

Great question—this is a super common observation when you’re digging into the low-level mechanics of C++ virtual functions, and it ties directly into how compilers balance debuggability, safety, and optimization. Let’s break down the most likely reasons you’re seeing those duplicate lea instructions:

1. Debug Mode Compilation (No Optimizations) #

If you compiled your code with Clang’s default -O0 flag (debug mode), the compiler prioritizes 1:1 correspondence between source code lines and assembly instructions over efficiency. It avoids most optimizations that would rearrange or reuse register values, so every time your code triggers a virtual function call, the compiler will explicitly reload the object’s address into rdi (the x86-64 calling convention’s first argument register, which holds the this pointer for member functions).

Even if the object’s address hasn’t changed between two virtual calls, -O0 won’t assume it can reuse the value already in rdi—it’ll generate the lea instruction each time to keep the assembly straightforward for debugging.

2. Register Spilling Between Calls #

If there’s code between your two virtual function calls that uses the rdi register for another purpose (like passing an argument to a non-virtual function, or storing a temporary value), the compiler will "spill" the original value of rdi (your object’s address) and overwrite it. When it’s time for the next virtual call, it has to reload the object’s address from the stack (hence the repeated lea rdi,[rbp-0x18]) because rdi no longer holds that value.

For example, if your code looks like this:

Derived obj;
Base* ptr = &obj;
ptr->virtualFunc1();
printf("Some message"); // Uses rdi for the format string
ptr->virtualFunc2();

The printf call will overwrite rdi, so the compiler has to reload obj’s address from the stack before calling virtualFunc2.

3. Missing Cross-Call Optimization #

At lower optimization levels (like -O0), the compiler doesn’t perform inter-procedural or cross-call optimizations that would track register values across function invocations. Even if the object’s address is static (like a stack-allocated object), the compiler won’t make the assumption that it’s safe to reuse the register value—instead, it plays it safe by reloading the address every time.

If you recompile with -O1 or higher (e.g., clang++ -O1 your_code.cpp), you’ll almost certainly see these duplicate lea instructions disappear. The optimizer will recognize that the object’s address hasn’t changed, keep it in rdi, and skip the redundant load.

Quick Example to Verify #

Let’s take a simple test case:

#include <iostream>
class Base {
public:
    virtual void foo() = 0;
    virtual void bar() = 0;
};

class Derived : public Base {
public:
    void foo() override { std::cout << "Derived::foo\n"; }
    void bar() override { std::cout << "Derived::bar\n"; }
};

int main() {
    Derived d;
    Base* b = &d;
    b->foo();
    b->bar();
    return 0;
}

• Compile with clang++ -O0 -c test.cpp && objdump -d test.o: You’ll see two identical lea rdi, [rbp-0x18] lines before each virtual function call.
• Recompile with clang++ -O1 -c test.cpp && objdump -d test.o: The lea instruction will only appear once, and rdi will be reused for both calls.

In short, those duplicate instructions are almost always a side effect of debug-mode compilation or unoptimized register management. Crank up the optimization level, and they’ll vanish!

内容的提问来源于stack exchange，提问作者Mustakimur Khandaker