Does the C standard have any guarantees on the amount of stack space used?

Question

I am doing embedded programming where saving memory is important.

How much stack space would the following C code occupy at run-time?

if (send_small_message) {
    uint8_t buffer[16000];
    // do something with the buffer
} else {
    uint8_t buffer[32000];
    // do something the with buffer
}

Could some compiler decide to allocate 16000 + 32000 = 48kB stack space for both buffers? Or is it guaranteed that since both buffers will never be used at the same time, the compiler will allocate only 32kB - the size of the larger buffer?

FOLLOW UP QUESTION:

void SendSmallMessage() {
    uint8_t buffer[16000];
    // do something with the buffer
}

void SendLargeMessage() {
    uint8_t buffer[32000];
    // do something with the buffer
}

Can a code compiled by some compiler use 16000 + 32000 bytes at run-time to execute the snippet below:

if (send_small_message) {
   SendSmallMessage(); 
} else {
   SendLargeMessage();
}

Answer 1

Does the C standard guarantee amount of stack used?

No guarantees whatsoever exist for this. The C standard does not mention concepts like stacks. You can even write C for low level CPUs that completely lack a stack.

The C standard does however guarantee that uint8_t is 1 byte large and that 1 byte is 8 bits on your system (or otherwise uint8_t wouldn't be available).

How much stack space would the following C code occupy at run-time?
Could some compiler decide to allocate 16000 + 32000 = 48kB stack space for both buffers?

System-specific, but also depends on exactly how the function is written and what optimizations that take place. Generally though, real world systems allocate room for as much stack as the function requires, given all possible execution paths. So it is quite likely that many compilers would allocate 16k + 32k.

But who cares, since it doesn't make sense to allocate that large amount of memory on the stack in any known system. Not on high-end, PC-like systems and certainly not on memory-restricted embedded systems. You'll get stack overflows all over the place.

The general rule of thumb in embedded is to never allocate any form of buffers on the stack, but always with static storage duration. On PC-like systems, heap allocation is another option.