Compiler (G++) seems to allocate more memory for instances of classes than it needs

Question

I am learning about how compilers represent C++ programs in assembly. I have a question about something that the compiler does that I can't make sense of. Here is some C++ code:

class Class1 {
public:
  int i;
  char ch;
};

int main() {
  Class1 cls;
}

Compiling with "g++ -S " outputs this (I've stripped out everything but the function definition):

main:
    push    ebp
    mov     ebp, esp
    sub     esp, 16
    mov     eax, 0
    leave
    ret

I don't understand the line sub esp, 16. Why would it allocate 16 bytes for an instance of this class that only requires 8 when you take into account data structure alignment and padding?

It should be

[int i - 4 bytes][char ch - 1 byte][padding - 3 bytes]

should it not?

When I compiled the code with the class definition also including a double, i.e.

class Class1 {
public:
  int i;
  char ch;
  double dub;
}; 

it still allocated 16 bytes, which made sense in that case.

So why does the compiler allocate 16 bytes when it only needs 8?

Answer 1

This has to do with stack-frame alignment, not structure alignment.

If you did a sizeof() on your objects, you'll see what you expect with struct alignment and padding.

However, stack-frames are slightly different. On most systems today, the stack alignment is 16 bytes (or more) to accommodate SSE memory accesses.