GDB для начинающих: точки останова, шаги и стек вызовов

Как собрать программу для отладки, остановить её на нужной строке, пройти код по шагам, смотреть переменные и по стеку вызовов найти место падения.

Программа считает неправильно, и вы вставляете printf через строчку, пересобираете, смотрите, удаляете. Пока функций три, это терпимо. Отладчик gdb делает то же самое без правки кода: останавливает программу на нужной строке, показывает любые переменные, выполняет код по одной строке и после падения говорит, в какой функции и на какой строке оно случилось. Ниже разберём две учебные программы: одна выдаёт неверный ответ, другая падает с Segmentation fault. Все сессии сняты в Debian 12 с gcc 12 и gdb 13. Адреса и случайные значения у вас будут другими, команды и смысл вывода те же.

Сборка для отладки: -g и -O0

Отладчику нужна таблица символов: какая строка исходника соответствует какой инструкции и где лежит каждая переменная. Её добавляет флаг -g. Флаг -O0 выключает оптимизацию, чтобы код выполнялся в том порядке, в каком написан.

gcc -g -O0 -Wall -Wextra avg.c -o avg
g++ -g -O0 -Wall -Wextra main.cpp -o main

Без -g gdb видит только имена функций. Попросите показать переменную, получите No symbol "sum" in current context., а шаг по строкам превращается в which has no line number information.

С -O2 отлаживать тоже можно, но неудобно: компилятор держит переменные в регистрах и выбрасывает лишние, поэтому вместо значения gdb пишет <optimized out>, а текущая строка прыгает вперёд и назад. Для отладки собирайте с -O0, а замеры времени и финальную версию делайте с теми флагами, которые требует задание.

Программа для опытов

Файл avg.c читает числа и печатает среднее:

#include <stdio.h>

int read_numbers(int *a, int max) {
    int n = 0;
    while (n < max && scanf("%d", &a[n]) == 1)
        n++;
    return n;
}

double average(const int *a, int n) {
    int sum = 0;
    for (int i = 0; i < n; i++)
        sum += a[i];
    return sum / n;
}

int main(void) {
    int a[100];
    int n = read_numbers(a, 100);
    printf("n = %d, average = %.2f\n", n, average(a, n));
    return 0;
}
$ echo "2 3 4 4" > input.txt
$ ./avg < input.txt
n = 4, average = 3.00

Должно быть 13 / 4 = 3.25. Предупреждений компилятор не выдал, программа не падает. Найдём ошибку отладчиком.

Запуск: run, аргументы и ввод из файла

$ gdb ./avg
(gdb) run < input.txt

run запускает программу. После него можно написать аргументы командной строки и перенаправление ввода, как в терминале: run < input.txt, run data.txt 10. Второй способ передать аргументы: gdb --args ./students Gleb, а потом просто run.

Ввод из файла удобнее ввода с клавиатуры: программу придётся перезапускать много раз, и вводить одни и те же числа каждый раз надоедает. Если программа всё же ждёт ввода с клавиатуры, набирайте его прямо в окне gdb.

Без точек останова программа просто отработает до конца. Чтобы остановиться в самом начале main, есть start: он ставит временную точку на main и запускает программу. Выход из gdb: quit или Ctrl+D.

Точки останова

Команда Что делает
break average остановка на входе в функцию
break avg.c:14 на строке 14 файла avg.c
break 14 на строке 14 текущего файла
break 13 if i == 3 только когда условие верно
info breakpoints список точек с номерами
delete 2 удалить точку номер 2
disable 1, enable 1 выключить и включить, не удаляя

Комментарии после команды gdb не понимает: строку break average # вход он примет за имя функции целиком.

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

(gdb) break 13 if i == 3
Breakpoint 1 at 0x854: file avg.c, line 13.
(gdb) run < input.txt
Breakpoint 1, average (a=0xfffffffff928, n=4) at avg.c:13
13	        sum += a[i];
(gdb) print sum
$1 = 9

Шаги: next, step, finish, continue

Войлочный кот Тиль стоит на бумажном камне посреди ручья, на следующем камне воткнут оранжевый флажок

Четыре команды, которыми ходят по программе:

  • next (n) выполняет текущую строку целиком. Если в ней вызов функции, функция отработает без остановки.
  • step (s) заходит внутрь функции, которая вызывается на текущей строке. В библиотечные функции вроде printf он не заходит, у них нет отладочной информации.
  • finish выполняет функцию до конца, возвращается к вызывающему коду и печатает возвращённое значение.
  • continue (c) идёт до следующей точки останова или до конца программы.

Пустой Enter повторяет последнюю команду, так что по циклу удобно шагать одним n и Enter.

(gdb) break main
Breakpoint 1 at 0x8b0: file avg.c, line 19.
(gdb) run < input.txt
Breakpoint 1, main () at avg.c:19
19	    int n = read_numbers(a, 100);
(gdb) step
read_numbers (a=0xfffffffff928, max=100) at avg.c:4
4	    int n = 0;
(gdb) finish
Run till exit from #0  read_numbers (a=0xfffffffff928, max=100) at avg.c:4
0x0000aaaaaaaa08bc in main () at avg.c:19
19	    int n = read_numbers(a, 100);
Value returned is $1 = 4
(gdb) next
20	    printf("n = %d, average = %.2f\n", n, average(a, n));
(gdb) step
average (a=0xfffffffff928, n=4) at avg.c:11
11	    int sum = 0;

read_numbers вернула 4: все числа прочитаны, ввод не виноват. Идём внутрь average.

Главное правило: строка, на которой gdb остановился, ещё не выполнена. Он показывает ту, что выполнится следующей.

Переменные: print, display, info locals

(gdb) print *a@n
$2 = {2, 3, 4, 4}
(gdb) display sum
1: sum = 4
(gdb) next
12	    for (int i = 0; i < n; i++)
1: sum = 0
(gdb) next
13	        sum += a[i];
1: sum = 0
(gdb) next
12	    for (int i = 0; i < n; i++)
1: sum = 2
(gdb) info locals
i = 0
sum = 2

Что здесь произошло:

  • a внутри функции всего лишь указатель, и print a покажет адрес. Запись *a@n значит «n элементов, начиная с *a». Так смотрят массивы, переданные в функцию.
  • display sum печатает sum после каждого шага. Первое значение 4 взялось из мусора в памяти: строка int sum = 0; ещё не выполнилась. Убрать слежение: undisplay 1.
  • info locals показывает все локальные переменные, info args аргументы функции.

print понимает выражения на C: print a[i] * 2, print sum / n, print (double) sum / n. Формат меняется после косой черты: print/x sum выводит в шестнадцатеричном виде. Значение можно и поменять: set var sum = 0.

Дойдём до return и проверим арифметику:

(gdb) break 14
Breakpoint 2 at 0xaaaaaaaa0890: file avg.c, line 14.
(gdb) continue
Continuing.

Breakpoint 2, average (a=0xfffffffff928, n=4) at avg.c:14
14	    return sum / n;
1: sum = 13
(gdb) print sum / n
$3 = 3
(gdb) print (double) sum / n
$4 = 3.25

Сумма верная, ошибка в делении. sum и n целые, поэтому 13 / 4 даёт 3, и только потом 3 превращается в double. Исправление: return (double) sum / n;. После пересборки программа печатает n = 4, average = 3.25.

watch: кто поменял переменную

Бывает, что переменная получает неверное значение, а где именно, непонятно. Точка наблюдения останавливает программу при каждом изменении:

(gdb) break average
(gdb) run < input.txt
Breakpoint 1, average (a=0xfffffffff928, n=4) at avg.c:11
11	    int sum = 0;
(gdb) next
12	    for (int i = 0; i < n; i++)
(gdb) watch sum
Hardware watchpoint 2: sum
(gdb) continue
Continuing.

Hardware watchpoint 2: sum

Old value = 0
New value = 2
average (a=0xfffffffff928, n=4) at avg.c:12
12	    for (int i = 0; i < n; i++)

watch ловит любую запись в эту память, даже через чужой указатель или при выходе за границу соседнего массива. Так находится классика: массив переполнился и затёр переменную рядом. Наблюдение за локальной переменной снимается, когда функция завершается, gdb так и пишет: Watchpoint 2 deleted because the program has left the block.

Разбор падения: Segmentation fault и bt

Программа students.c ищет студента по имени из аргумента и печатает его балл:

#include <stdio.h>
#include <string.h>

struct student {
    char name[32];
    int score;
};

struct student *find(struct student *list, int n, const char *name) {
    for (int i = 0; i < n; i++)
        if (strcmp(list[i].name, name) == 0)
            return &list[i];
    return NULL;
}

void print_score(const struct student *s) {
    printf("%s: %d\n", s->name, s->score);
}

int main(int argc, char *argv[]) {
    struct student group[] = {{"Anna", 87}, {"Boris", 72}, {"Vera", 95}};
    const char *who = argc > 1 ? argv[1] : "Anna";
    print_score(find(group, 3, who));
    return 0;
}
$ ./students Vera
Vera: 95
$ ./students Gleb
Segmentation fault (core dumped)

Запускаем под отладчиком с тем же аргументом:

$ gdb ./students
(gdb) run Gleb
Program received signal SIGSEGV, Segmentation fault.
0x0000aaaaaaaa0880 in print_score (s=0x0) at students.c:17
17	    printf("%s: %d\n", s->name, s->score);
(gdb) bt
#0  0x0000aaaaaaaa0880 in print_score (s=0x0) at students.c:17
#1  0x0000aaaaaaaa0914 in main (argc=2, argv=0xfffffffffc18) at students.c:23
(gdb) frame 1
#1  0x0000aaaaaaaa0914 in main (argc=2, argv=0xfffffffffc18) at students.c:23
23	    print_score(find(group, 3, who));
(gdb) print who
$1 = 0xfffffffffe56 "Gleb"

Как это читать. bt (backtrace) печатает стек вызовов: кадр #0 там, где программа упала, #1 тот, кто его вызвал, и так до main. Аргументы видны прямо в стеке: s=0x0, то есть print_score получила NULL. frame 1 переключает gdb в кадр main, и print теперь показывает её переменные. Там видно, что искали "Gleb", которого в группе нет, и find честно вернула NULL. Ошибка не в строке 17, где упало, а в строке 23, где результат поиска не проверили:

    const struct student *s = find(group, 3, who);
    if (s == NULL) {
        printf("%s: нет в списке\n", who);
        return 1;
    }
    print_score(s);

Если кадр #0 оказался внутри библиотеки, например __strlen_asimd () at ../sysdeps/... и рядом No such file or directory, не ищите этот файл. Имя функции зависит от системы, а виновата почти всегда ваша функция ниже по стеку, которая передала туда NULL или испорченный указатель. Переходите к первому кадру со своим файлом через frame N или командами up и down.

Если gdb нет: Mac и Windows

На Mac с процессором Apple gdb не отлаживает обычные программы: Homebrew его ставит, но запустить под ним программу для arm64 не получится (обсуждение в Homebrew). Там есть lldb из Xcode Command Line Tools, при первой отладке macOS может спросить разрешение. Команды похожи (таблица соответствия):

gdb lldb
run < input.txt process launch -i input.txt
break avg.c:14 b avg.c:14
next, step, finish next, step, finish
print sum p sum
info locals frame variable
bt, frame 1 bt, frame select 1
watch sum watchpoint set variable sum

В Windows проще всего работать в WSL: это обычный Linux, gdb ставится командой sudo apt install gdb.

Шпаргалка

Команда Что делает
run args < file запустить с аргументами и вводом из файла
start запустить и остановиться в начале main
break f, break 14 if i == 3 точка останова, в том числе с условием
next, step, finish, continue строка, вход в функцию, выход из неё, до следующей точки
print x, print *a@n, display x показать значение, массив по указателю, следить за переменной
info locals, info args все локальные переменные и аргументы
bt, frame N, up, down стек вызовов и переход между кадрами
watch x остановиться, когда x изменится

Общий порядок такой: воспроизвести ошибку на маленьком вводе, поставить точку перед подозрительным местом, проверить, совпадают ли значения с тем, что вы ждёте, и сдвигаться к месту, где они разошлись.

Как это решает Tilpi

Исполнитель Tilpi собирает и запускает код в отдельной изолированной машине, где уже стоят gcc, g++, gdb и valgrind, так что программу можно проверить и тогда, когда на вашем компьютере gdb нет, например на Mac. Он ищет ошибки и предлагает исправления, ход работы виден в задании, а чат задания объясняет код и решение по шагам. Исполнитель входит во все тарифы: в «Лайт» и «Стандарт» на уровне «Быстрая», в «Плюс» на всех уровнях, а без тарифа работает на «Быстрой» из бесплатных ежемесячных кредитов, общих с чатом.

Запустим ваш код. Даже с телефона.

ИИ-исполнитель соберёт программу в отдельной машине, запустит её и пришлёт вывод и файлы. Ставить компилятор не нужно.

Разобрать падение программы в Tilpi