c99 перейти к предыдущей инициализации

Вы можете попросить gcc предупреждать вас, когда вы переходите через определение переменной, используя -Wjump-misses-init, а затем вы можете использовать -Werror (или, точнее, -Werror=jump-misses-init), чтобы заставить пользователей иметь с этим дело. Это предупреждение включено в -Wc++-compat, чтобы разработчики gcc знали, что код ведет себя по-разному в C по сравнению с C++.

Вы также можете немного изменить код:

int func()
{
    char *p1 = malloc(...);
    if (p1 == NULL)
        goto err_exit_1;

    char *p2 = malloc(...);
    if (p2 == NULL)
        goto err_exit_2;

    ...

err_exit_2:
    free(p2);
err_exit_1:
    free(p1);

    return -1;
}

... и просто продолжайте соединять метки с инициализированными переменными. У вас будет та же проблема с вызовом многих других функций с унифицированными переменными, просто free оказывается более очевидной.

Такой прыжок действительно разрешен стандартом, так что это не ошибка в GCC. Стандарт перечисляет эту ситуацию в качестве рекомендуемого предупреждения в Приложении I.

Единственное ограничение, наложенное на переходы в C99 в отношении области видимости, заключается в том, что недопустимо переходить в область действия переменной изменяемого типа, например VLA.

int main() {
  int n = 5;
  goto label; // <- ERROR: illegal jump
  int a[n];
label:;
}

Другими словами, неправильно говорить, что «прыжок — это просто прыжок в C». Переходы несколько ограничены, когда дело доходит до входа в область переменных, хотя и не так строго, как в C++. Ситуация, которую вы описываете, не является одной из ограниченных.

Хм, не потому, что новый стандарт позволяет объявлять переменные где угодно, всегда полезно его использовать. В вашем случае я бы поступил так же, как мы делали это в классическом C.

int func()
{
char *p1 = NULL;    /* So we have a defined value */
char *p2 = NULL;

  p1 = malloc(...);
  if(!p1)
    goto err_exit;

  p2 = malloc(...);
  if(!p2)
    goto err_exit;

  ...

  err_exit:
    free(p2);
    free(p1);

  return -1;
}

Это не ошибка в gcc. Прыжок — это просто прыжок в C. Никакой специальной логики не применяется. Проблема в том, что вы сначала не инициализируете свои указатели на NULL. Если бы вы сделали это, то ваш бесплатный вызов был бы free(NULL), который не рухнул бы. Запустите функцию с char *p1 = NULL, *p2 = NULL; и все будет хорошо.

если я скомпилирую этот код с флагом -O2

gcc -Wall -std=c99 -O2 jump.c

у меня есть предупреждение:

jump.c: In function ‘func’:
jump.c:10: warning: ‘p2’ may be used uninitialised in this function

и никаких предупреждений без оптимизации

Как говорит AndreyT, переход через инициализацию разрешен C99. Вы можете исправить свою логику, используя отдельные метки для двух сбоев:

int func()
{
    char *p1 = malloc(...);
    if (p1 == NULL)
        goto err_exit_p1;

    char *p2 = malloc(...);
    if (p2 == NULL)
        goto err_exit;

    ...

err_exit:
    free(p2);
err_exit_p1:
    free(p1);

    return -1;
}

Это стандартный шаблон — «ранние ошибки» вызывают переход к более поздней части кода выхода из ошибки.

Использование gotos — не самая разумная идея, и вы только что нашли одну из причин, почему. Вы должны вызывать функцию обработки ошибок для каждой отдельной ошибки.