Does typedef (pointer to) VLA require evaluation of the size expression?

user_1778275 0
Viewed 82

Does typedef VLA require evaluation of the size expression?

int f(void);
int main(void)
{
    typedef int (T) [ f() ];       // is f required to be evaluated ?
    T x;
    return sizeof x;
}

Does typedef pointer to VLA require evaluation of the size expression?

int f(void);
int main(void)
{
    typedef int (*T) [ f() ];      // is f is required to be evaluated ?
    T x;
    return sizeof x;
}

UPD. In the definition of f is visible, then a call to it may be optimized out:

int f(void)
{
    return 4;
}

int main(void)
{
    typedef int (*T) [ f() ];
    return sizeof(T);
}

Generated code (both GCC and LLVM):

main:
        mov     eax, 8
        ret

It is expected, because there is no real need to call f to determine the size of a pointer.

variable-length-array language-lawyer declaration typedef c
1 Answers

According to the C Standard (§6.7.8 Type definitions)

3 In a declaration whose storage-class specifier is typedef, each declarator defines an identifier to be a typedef name that denotes the type specified for the identifier in the way described in 6.7.6. Any array size expressions associated with variable length array declarators are evaluated each time the declaration of the typedef name is reached in the order of execution.

And there is an example in the C Standard

8 EXAMPLE 5 If a typedef name denotes a variable length array type, the length of the array is fixed at the time the typedef name is defined, not each time it is used:

void copyt(int n)
{
    typedef int B[n]; // B is n ints, n evaluated now
    n += 1;
    B a; // a is n ints, n without += 1
    int b[n]; // a and b are different sizes
    for (int i = 1; i < n; i++)
        a[i-1] = b[i];
}

Here is a demonstration program.

#include <stdio.h>

int f( void )
{
    static int n;
    
    return ++n;
}

void g( void )
{
    typedef int ( *T )[ f() ];
    
    T p;
    
    printf( "sizeof( *p ) = %zu\n", sizeof( *p ) );
}

int main(void) 
{
    for ( size_t i = 0; i < 10; i++ )
    {
        g();
    }
}

The program output is

sizeof( *p ) = 4
sizeof( *p ) = 8
sizeof( *p ) = 12
sizeof( *p ) = 16
sizeof( *p ) = 20
sizeof( *p ) = 24
sizeof( *p ) = 28
sizeof( *p ) = 32
sizeof( *p ) = 36
sizeof( *p ) = 40
user_28772410
Related