当函数调用返回时，压入堆栈的参数会发生什么变化？

Question

Assume this C code:

int add(int a, int b){
 int c = a+b;
 return c;
}

int main(){
  int c = add(3,4);
  printf("%d", c);
  return 0;
}

When calling add the following happens:

Push 4 on the stack
Push 3 on the stack
Push the address of `printf` on the stack (return address)
call `add`
// do stuff under add
pop the stack and and goto `printf`

But values 4 and 3 under add are still on the stack -0x18(%rbp) . Are they not supposed to be cleared?

00000000000005fa <add>:
 5fa:   55                      push   %rbp
 5fb:   48 89 e5                mov    %rsp,%rbp
 5fe:   89 7d ec                mov    %edi,-0x14(%rbp)
 601:   89 75 e8                mov    %esi,-0x18(%rbp)
 604:   8b 55 ec                mov    -0x14(%rbp),%edx
 607:   8b 45 e8                mov    -0x18(%rbp),%eax
 60a:   01 d0                   add    %edx,%eax
 60c:   89 45 fc                mov    %eax,-0x4(%rbp)
 60f:   8b 45 fc                mov    -0x4(%rbp),%eax
 612:   5d                      pop    %rbp
 613:   c3                      retq   

0000000000000614 <main>:
 614:   55                      push   %rbp
 615:   48 89 e5                mov    %rsp,%rbp
 618:   be 04 00 00 00          mov    $0x4,%esi
 61d:   bf 03 00 00 00          mov    $0x3,%edi
 622:   e8 d3 ff ff ff          callq  5fa <add>
 627:   5d                      pop    %rbp
 628:   c3                      retq  

Answer 1

But values 4 and 3 under add are still on the stack

Not really, because stack no longer covers the memory where 4 and 3 are stored. They are in the memory beyond the stack pointer. Although the values are still in the place in memory that used to be part of stack, they are now part of uninitialized garbage. Accessing them after the stack has moved on, eg by storing their addresses, would be undefined behavior.

Are they not supposed to be cleared?

No, clearing these values is unnecessary, and could impact run-time efficiency of the program.

Answer 2

When you call the pop instruction, the value at the top of the stack is stored in the specified register and the SP (stack pointer) register is incremented (on x86 the stack grows down). It does NOT modify the memory location that was previously the top of the stack as there's no need to do so.

Whatever value was at the top of the stack will remain there until a new value is pushed on top of it.