# V2631. MISRA. Pointers to variably-modified array types should not be used.

This diagnostic rule is based on the MISRA (Motor Industry Software Reliability Association) software development guidelines.

This diagnostic rule is relevant only for C.

The use of pointers to Variable Length Arrays (VLAs) in object declarations or function parameters can lead to potential errors. Therefore, it is not recommended to use them.

A VLA is an array declared as a function parameter or local object whose size is not a compile-time constant. The C language also permits the definition of pointers to VLAs.

Undefined behavior occurs when two pointers to arrays of specified sizes are used in any context that requires them to be compatible, but their sizes differ. For example, this can happen during pointer assignment where one pointer points to the VLA.

Look at the following example:

    void foo(int n, int (*a)[n])
    {
      int (*b)[20] = a; // undefined behavior if n != 20
                        // types are assumed to be compatible
    }

    void bar(int n)
    {
      int a[n];
      foo(n, &a);
    }

    void foobar()
    {
      bar(10);
    }

In this code, the `foo` function accepts the `a` pointer to the VLA whose size is determined by the `n` parameter. Within the function, the pointer is assigned to another `b` pointer which expects a pointer to an array of exactly 20 elements. Such an operation leads to undefined behavior as long as `n != 20`.

To fix this, change the type of the `a` parameter to the VLA and remove the size information from the `b` pointer:

    void foo(int n, int a[n])
    {
      int *b = a; // always well-defined behavior
    }

This diagnostic is classified as:

MISRA-C-2023-18.10