Where does variable length array/alloca allocate in stack

Question

I am really curious about how alloca() function works and therefore, I have written a simple test program as follows:

int test() {
    int a = 0;
    int e;
    char tmp2[a]; //alloca
    int d;
    char* tmp3 = new char[2];
    tmp2[100] = 1;
    return 0;
}

int main(int argc, char** argv) {
    test();
    return 0;
}

According to the document, alloca() will allocate memory in stack. I run the program using gdb and figure out that (char*)&tmp2 - (char*)a = -44 which mean there are 44 bytes between them while the distances between the address of e-a, d-e, tmp3-d are 4 bytes. I really can not understand about how compiler can allocate a variable length array in stack and hope that someone can tell me what the meaning of the 44 bytes is.

Your code doesn't contain a call to a function called `alloca`. It does, however, contain `new`, which allocates memory dynamically. This doesn't happen on a "stack". — Andrew, Oct 08 '15 at 10:21
So sorry but I use \"char tmp2[a];" which allocate a variable length array as same as what alloca does — Truong Hua, Oct 08 '15 at 10:22
Pick a language - `new` is C++ and VLA's are C99. The two are incompatible. — MSalters, Oct 08 '15 at 10:23
I guess you're assuming that GCC's VLA implementation uses `alloca`? — TartanLlama, Oct 08 '15 at 10:24
@TruongHua I don't think that's necessarily true, it could keep track of the stack allocation without using `alloca`. — TartanLlama, Oct 08 '15 at 10:29
@Andrew how ever I use variable length array which is alternative of alloca() in C99. — Truong Hua, Oct 08 '15 at 10:30
This could be due to some optimization. Try to change array size, so it would be non-zero. — Matt, Oct 08 '15 at 10:46
`tmp3-d` = 4 bytes means you were probably looking at the address of the pointer variable `&tmp3`, not the dynamic storage it holds a pointer to. — Peter Cordes, Jul 01 '20 at 21:33

score 3 · Accepted Answer · answered Oct 08 '15 at 10:33

3

alloca() is not a part of standard. It is considered to be compiler/machine dependent. Thus the intrinsics belong to implementation only.

Having said this, if we talk about x86 machine, then stack manipulations are done by the use of dedicated stack pointer register - sp / esp / rsp (16/32/64 bits code) which contains address of last word/dword/qword pushed onto the stack. To reserve more memory we need just subtract some value from sp register.

Thus "typical" alloca(x) implementation in x86 is just a single CPU instruction: sub sp, x.

answered Oct 08 '15 at 10:33

Matt

13,674
1
18
27

1

But in my testing, the x is only 0, so why 44 bytes is shifted – Truong Hua Oct 08 '15 at 10:37
1

@TruongHua have a look at the assembly output from your compiler and see what instructions it generates. – TartanLlama Oct 08 '15 at 10:39
@TruongHua Only disassembly may show the truth. The compiler is not obliged to keep the order of declarations at all. – Matt Oct 08 '15 at 10:43
1

Not a single instruction; it has to round the allocation size up to a multiple of 16 bytes to maintain stack alignment. – Peter Cordes Jul 01 '20 at 21:15

score 1 · Answer 2 · answered Oct 08 '15 at 10:28

char tmp2[a];

where a is a non-constant integer, uses a C99 feature called variable length arrays, or VLAs.

That feature is not available in standard C++, although it's a language extension supported by the g++ compiler in non-conforming mode.

It's unspecified how memory is allocated for a VLA. It might be on the machine stack, like alloca, or it might be dynamically allocated memory.

Where does variable length array/alloca allocate in stack

2 Answers2