When compiling C code that combines a goto statement with a Variable-Length Array (VLA), you might run into this compilation error from GCC or Clang:

error: jump into scope of identifier with variably modified type
    8 |         goto exit;
      |         ^~~~

This error can be confusing if your target label is placed after the array declaration, because it looks like you are simply skipping over the array. Let’s break down why this error occurs according to the C standard and explore the best ways to fix it.

Why Does This Error Happen?

In C, an array whose length is evaluated at runtime (such as int x[function()];) is known as a Variable-Length Array (VLA), and its type is referred to as a variably modified type.

Two key rules explain why jumping over a VLA triggers a compiler error:

  1. Block Scope: In C, the scope of a declared variable extends from the point of its declaration to the very end of the enclosing block (the closing brace }). That means the label exit: placed later in the function is technically inside the scope of x.
  2. The C Standard Constraint: The C standard (C99 §6.8.6.1 and later) explicitly forbids this behavior:
    "A goto statement shall not jump from outside the scope of an identifier having a variably modified type to inside the scope of that identifier."

Because VLAs require dynamic stack allocation and internal bookkeeping (evaluating the size expression at runtime), jumping into their scope without executing their initialization leaves the runtime stack and compiler expectations in an invalid state.

How to Fix the Issue

Depending on your code structure and design preferences, here are the most effective ways to solve this problem.

Method 1: Confine the VLA to Its Own Scope Block

The cleanest and most idiomatic fix while keeping goto is to wrap the VLA in an isolated block using curly braces { ... }. This terminates the scope of the variable before the label, allowing the jump to succeed.

int function(void) {
    return 7;
}

int main(void) {
    goto exit;

    {
        // x is only in scope inside these braces
        int x[function()];
        // do work with x
    }

exit:
    return 0;
}

Method 2: Use Dynamic Allocation (malloc / free)

VLAs were made optional starting in C11 and can be dangerous because large sizes cause stack overflows without any graceful error recovery. Replacing the VLA with heap allocation removes the variably modified type entirely:

#include <stdlib.h>

int function(void) {
    return 7;
}

int main(void) {
    int *x = NULL;

    goto exit;

    x = malloc(sizeof(int) * function());
    if (!x) {
        return 1;
    }

    // ... use x ...

exit:
    free(x);
    return 0;
}

Method 3: Refactor Away from goto

If you are using goto for control flow or early exit, restructuring your logic with structured programming constructs (like if/else, break, or dedicated helper functions) often eliminates the error while improving code readability:

int run_task(void) {
    int x[function()];
    // perform operations with x
    return 0;
}

int main(void) {
    if (/* condition to skip */ 1) {
        return 0;
    }

    return run_task();
}

Summary

  • A goto cannot jump across a VLA declaration within the same block because it jumps into the identifier's scope without properly allocating the variably modified type.
  • To resolve the error, restrict the VLA’s scope using an inner { ... } block, switch to heap allocation via malloc, or restructure your control flow to avoid the jump.