C99 Variable Length Array Max sizes and sizeof Function

Question

I am experimenting with the use of Variable Length Arrays (VLAs) in my C code and trying to iron out my understanding of what they should and shouldn't do.

I have the following snippet from my function:

void get_pdw_frame_usb(pdws_t *pdw_frame, pdw_io_t *pdw_io)
{
...
unsigned char buf[pdw_io->packet_size];
unsigned char *pdw_buf;
memset(buf, '\0', sizeof(buf));

pdw_io is a data structure containing, amongst other things, packet_size, which is of type size_t

the char array buf is to be used to store the contents of a usb bulk transfer packet

I'm trying to instantiate it here as an automatic variable using the C99 VLA approach. I'm then trying to ensure its contents are all zeros.

I'm having a few issues.

Firstly, if pdw_io->packet_size is set to 8 (quite small), then buf is set to a reasonable looking value, i.e. debugging with gdb i can inspect it as follows:

(gdb) p buf
$27 = 0xbffe5be8 "\270", <incomplete sequence \370\267>

If pdw_io->packet_size is set to 12008 (fair bit larger), then I get the following which doesn't look so good:

(gdb) p buf
$29 = 0xbffe2d08 ""

Is 12008 chars too large for a VLA? Or perhaps that gdb output is not something to worry about, it just looks a bit like it hasn't allocated anything to me?

Also when inspecting the size of buf I get the following in both cases:

(gdb) p sizeof(buf)
$30 = 0

which I would have expected to be 8 in the 1st instance and 12008 in the 2nd

Am I wrong in thinking it should be possible to use the sizeof function in this way with a VLA?

My problem is that the subsequent usb bulk transfer is failing and I want to try and rule out the fact it may have something to do with my use of VLAs, which are a bit of a new area for me..

UPDATE

Wrote the following minimal, complete and hopefully verifiable program to try and confirm my observations:

#include <stdio.h>

void test_vla(size_t n)
{
    unsigned char buf[n];
    printf("sizeof buf = %zu\n", sizeof buf);    
}

int main()
{
    test_vla(12008);
    return 0;
}

now if I break on the printf statement with gdb and run p sizeof buf I get 0 but printf outputs 12008.

gdb version is:

(gdb) show version
GNU gdb (Ubuntu 7.7.1-0ubuntu5~14.04.2) 7.7.1

Note that a compiler doesn't need to support VLA:s to be compatible with C11. This means that VLA:s should be avoided for portability reasons and that they will probably be removed in future C standards. — Klas Lindbäck
– Klas Lindbäck, Commented Sep 21, 2015 at 14:08
@bph gdb prints a char array as a zero-terminated string, so all that output tells you is that the first character is zero. I don't think you have an actual issue here. — interjay
– interjay, Commented Sep 21, 2015 at 14:34
Your update doesn't use a VLA, so of course it doesn't trigger the problem. Older versions of gdb don't support sizeof on VLAs; newer versions do. See my updated answer. — Keith Thompson
– Keith Thompson, Commented Sep 21, 2015 at 15:57

Keith Thompson · Accepted Answer · 2015-09-22 20:32:31Z

The problem you're running into is a bug (or perhaps more accurately a missing feature) in gdb. gdb does not correctly handle the sizeof operator applied to a VLA (variable-length array).

This message from a gdb mailing list indicates that support for sizeof on VLAs has been implemented in gdb, but only relatively recently. Apparently it isn't in the version you and I are both using (gdb 7.7.1). Without that fix, it incorrectly prints the size of a VLA as 0. Your code itself should behave correctly; it's just gdb that isn't handling it properly.

There's nothing particularly wrong with your code, as long as (a) it's compiled with a compiler that supports VLAs, and (b) the size of the array is positive and not too large. (VLAs are not supported in C90, except perhaps as an extension, were introduced as a standard feature in C99, and were made optional in C11.)

A possible workaround is to modify your program to save the value of sizeof vla to a variable that you can then print from gdb.

Another problem with gdb is that printing the VLA object itself behaves differently than printing a fixed-size array object. It apparently treats a VLA as a pointer to its first element rather than as an array object.

Here's a gdb transcript that illustrates the problem:

GNU gdb (Ubuntu 7.7.1-0ubuntu5~14.04.2) 7.7.1
[SNIP]
(gdb) list
1       #include <stdio.h>
2       #include <string.h>
3       int main(void) {
4           int len = 6;
5           char vla[len];
6           const size_t vla_size = sizeof vla;
7           char arr[6];
8           strcpy(vla, "hello");
9           strcpy(arr, "world");
10      }
(gdb) break 10
Breakpoint 1 at 0x400600: file c.c, line 10.
(gdb) run
Starting program: /home/kst/c 

Breakpoint 1, main () at c.c:10
10      }
(gdb) print sizeof vla
$1 = 0
(gdb) print vla_size
$2 = 6
(gdb) print sizeof arr
$3 = 6
(gdb) print vla
$4 = 0x7fffffffdc10 "hello"
(gdb) print arr
$5 = "world"
(gdb) print arr+0
$6 = 0x7fffffffdc40 "world"
(gdb) continue
Continuing.
[Inferior 1 (process 28430) exited normally]
(gdb) quit

Is 12008 chars too large for a VLA?

Probably not. For most implementations, a VLA can be just as large as a fixed-size array. There's no real difference (in terms of memory allocation) between:

{
    int size = 12008;
    char buf[size];
}

and

{
    int buf[12008];
}

Many systems limit the amount of memory you can allocate on the stack, but a 12008-byte array isn't likely to push those limits.

Still, if you're going to be allocating large arrays, it's probably better to do so via malloc() (which means you'll need to explicitly call free() for each allocated object).

I just ran the code through gdb with pdw_io->packet_size set to 8. the prinf statement output 8, and p sizeof(buf) from the gdb prompt output 0. So I'm happy that my VLA is working as expected, I was just wrong to assume that running p sizeof(buf) would give me the same result. I just ran it with pdw_io->packet_size set to 12008 as well and the printf output 12008 and gdb output 0, so the same behaviour. Thats great so I know the VLA is working fine for a size of 12008 bytes - my problem must lie elsewhere so back to the drawing board..

Collectives™ on Stack Overflow

C99 Variable Length Array Max sizes and sizeof Function

1 Answer 1

1 Comment

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

1 Comment

Your Answer

Sign up or log in

Post as a guest

Linked

Related