Краткое руководство Beej к GDB

Это очень быстрое и грязное руководство, предназначенное для начала работы с GNU Debugger, gdb, из командной строки в терминале. Часто gdb запускается через IDE, но многие люди там избегают IDE по разным причинам, и этот урок для вас!

Опять же, это только руководство по началу работы. Намного больше узнать надо о том, что делает отладчик, чем написано в этих нескольких коротких абзацах. Ознакомьтесь с вашими «man» страницами или онлайн-ресурсами, перечисленными ниже, для получения дополнительной информации.

Это учебное пособие предназначено для чтения в порядке, но не включая раздел «Misc».

Содержание

• Компиляция для использования отладчика
• Дополнительная информация
• Лицензия
• Запуск gdb и переход к main()
• Контрольные точки
• Шаги вокруг
• Изучение переменных
• Misc Материал
  • Манипуляция стеками
  • Дополнительные методы шага
  • Прыжки к произвольной секции кода
  • Изменение переменных и значений во время выполнения
  • Аппаратные точки наблюдения
  • Присоединить к запущенному процессу
  • Использование Coredumps для анализа Postmortem
  • Функции окна
  • Отображать регистры и сборку
  • Написание интерфейсного
• Краткая ссылка Шпаргалки

Компилирование 

Вы должны сообщить своему компилятору компилировать свой код с включенной символической отладочной информацией. Вот как это сделать с помощью gcc, с -g switch:

$ gcc -g hello.c -o hello

$ g++ -g hello.cpp -o hello

 После того, как вы это сделали, вы сможете просматривать списки программ в отладчике.

Дополнительная информация

Ознакомьтесь с официальной документацией GDB для получения дополнительной информации, чем вы можете встряхнуть палку!

Кроме того, хорошим GNU GDB front-end является DDD, DataDisplayDebugger.

Лицензия

Краткое руководство Beej к GDB от зала Брайана «Beej Jorgensen» лицензировано по лицензии Creative Commons Attribution-Noncommercial-No Derivative Works 3.0 United States License.

Запуск Отладчика

Во-первых: вы можете ввести help в любом gdb prompt и получить дополнительную информацию. Кроме того, вы можете ввести quit для выхода из отладчика. Наконец, просто нажав RETURN, повторите введенную последнюю команду. Теперь давайте запустим его!

Существует несколько способов запуска отладчика (например, если вы были IDE, вы можете запустить его с особым режимом, который не так удобен для людей), но я расскажу о двух из них: режим консоли ванили и режим ручного графического интерфейса. Графический интерфейс лучше, но давайте быстро рассмотрим простой и запустим программу, названную hello в отладчике:

$ gdb hello
GNU gdb 6.8
Copyright (C) 2008 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later 
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "i486-slackware-linux"...
(gdb) run
Starting program: /home/beej/hello 
Hello, world!

Program exited normally.
(gdb) 

Последняя строка - это gdb prompt, ожидающее, когда вы скажете, что делать. Введите r или run для запуска программы. (gdb позволяет сокращать команды до тех пор, пока они не станут двусмысленными).

Чтобы начать работу с neato и настоятельно рекомендуемым графическим интерфейсом, запустите отладчик с помощью gdb -tui. (Для многих примеров, приведенных ниже, я показываю вывод режима немого терминала gdb, но в реальной жизни я использую только режим TUI.)

И вот скриншот того, что вы увидите, примерно: 

Все нормальные команды gdb будут работать в режиме графического интерфейса, а кроме того, клавиши со стрелками и клавиши pgup / pgdown будут прокручивать окно источника (если у него есть фокус, который он делает по умолчанию). Кроме того, вы можете изменить, какой файл или функция отображается в исходном окне, указав list команд в качестве аргумента, например «list hello.c: 5, чтобы открыть файл hello.c в строке 5. ( См. «Точки останова» ниже, для мест выборки - те же местоположения, которые работают с точками останова, будут работать с командой list.) В качестве примечания стороны list также работает в режиме терминала.

Теперь обратите внимание, что мы передали имя исполняемого файла в командной строке. Другой вариант, который у вас есть, - просто запустить gdb, не имея ничего другого в командной строке, а затем передать ему команды file hello, и это приведет к загрузке «hello» исполняемого файла.

Аргументы командной строки! Что делать, если вам нужно что-то сделать в argv в своей программе? Передайте их в качестве аргументов в команду run при запуске выполнения:

$ gdb hello
GNU gdb 6.8
Copyright (C) 2008 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later 
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "i486-slackware-linux"...
(gdb) run arg1 arg2
Starting program: /home/beej/hello arg1 arg2
Hello, world!

Program exited normally.
(gdb) 

Обратите внимание, где указано «Starting Program» выше, это показывает, что аргументы «arg1» и «arg2» передаются «hello».

Контрольные точки

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

Во-первых, прежде чем вы выполните команду run, вам нужно установить точку останова, которую вы хотите остановить. Вы используете команду break или b и указываете местоположение, которое может быть именем функции, номером строки или исходным файлом и номером строки. Это примеры местоположений, которые используются различными командами, а также break: 

Итак, для этого теста давайте установим точку останова в main() и запустим программу:

$ gdb hello
GNU gdb 6.8
Copyright (C) 2008 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later 
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "i486-slackware-linux"...
(gdb) b main
Breakpoint 1 at 0x8048395: file hello.c, line 5.
(gdb) r
Starting program: /home/beej/hello 

Breakpoint 1, main () at hello.c:5
5		printf("Hello, world!\n");
(gdb)

Как вы видите, мы пришли к main(), и выполнение остановилось в точке останова, которую мы установили там. Если вы работаете в режиме терминала, gdb напечатает строку, которую он выполнит следующим образом. Если вы работаете в прохладном графическом режиме, то строка, которую он будет выполнять дальше, будет выделена в исходном окне.

Чтобы перечислить текущие точки останова, используйте команду info, например: «info breakpoints» (или более короткий «i b»): 

(gdb) b main
Breakpoint 1 at 0x8048395: file hello.c, line 5.
(gdb) i b
Num     Type           Disp Enb Address    What
1       breakpoint     keep y   0x08048395 in main at hello.c:5

Чтобы очистить точку останова, используйте команду clear с местом останова. Вы также можете очистить точку останова по номеру командой delete.

Кроме того, вы можете enable или disable точки останова, хотя эти две команды принимают номер точки останова в качестве аргумента, а не местоположение! Статус включения / отключения точки останова отображается в столбце «Enb» в списке точек останова.

(gdb) i b
Num     Type           Disp Enb Address    What
1       breakpoint     keep y   0x08048395 in main at hello.c:5
(gdb) disable 1
(gdb) i b
Num     Type           Disp Enb Address    What
1       breakpoint     keep n   0x08048395 in main at hello.c:5
(gdb) clear main
Deleted breakpoint 1 
(gdb) i b
No breakpoints or watchpoints.

Шаги вокруг

Когда выполнение останавливается в точке останова, вы можете сказать отладчику сделать несколько вещей. Начнем с next команды (или n). Эта команда переводит вас к следующему оператору в текущей функции (или возвращается к вызывающей функции, если вы отступили от конца функции.) Вот пример запуска; помните, что gdb печатает строку, которую он выполнит следующим образом перед «(gdb)» prompt. Также обратите внимание, что, когда мы запускаем next строку printf(), мы видим вывод.

(gdb) b main
Breakpoint 1 at 0x8048395: file hello.c, line 5.
(gdb) r
Starting program: /home/beej/hello 

Breakpoint 1, main () at hello.c:5
5		printf("Hello, world!\n");
(gdb) next
Hello, world!
7		return 0;
(gdb) next
8	}
(gdb) next
0xb7d6c6a5 in __libc_start_main () from /lib/libc.so.6
(gdb) next
Single stepping until exit from function __libc_start_main, 
which has no line number information.

Program exited normally.
(gdb) 

(Этот странный материал в конце о __libc_start_main() показывает вам, что была другая функция, которая вызвала вашу функцию main()! Она не была скомпилирована с информацией об отладке, поэтому мы не можем видеть источник, но мы все равно можем пройти через нее - что мы делаем - и программа выйдет нормально.)

Теперь обратите внимание, что next steps over вызовами функций. Это не означает, что функция не вызвана; это означает, что next функция будет выполняться до тех пор, пока она не будет выполнена, а затем вернет вас к следующей строке в вашей текущей функции.

Что делать, если у вас есть функция, с которой вы хотите перейти от текущей функции, и отслеживать эту функцию по очереди? Для этого используйте команду step (или s). Он работает так же, как и следующий, за исключением того, что он выполняет функции.

Предположим, вы устали от одного шага, и просто хотите, чтобы программа запускалась снова. Используйте команду continue (или c) для продолжения выполнения.

Что делать, если программа работает, но вы забыли установить точки останова? Вы можете нажать CTRL-C, и это остановит программу, где бы она ни находилась, и вернет вам «(gdb)» prompt. В этот момент вы можете где-то настроить правильную точку останова и продолжить (continue) эту точку останова.

Одним из последних ярлыков является то, что просто нажатие RETURN повторит введенную последнюю команду; это позволит вам печатать снова и снова.

Изучение переменных

Если у вас есть переменные, которые вы хотите проверить в ходе прогона, вы можете отобразить display их, но только если переменная в настоящее время находится в области видимости. Каждый раз, когда вы вводите код, будет отображаться значение переменной (если оно находится в области видимости).

(Следующий вывод не позволяет получить исходный код между строками для ясности - это то, что вы увидите в режиме графического интерфейса. Представьте, что вы видите подсветку, отскакивающую вокруг исходного кода, когда вы используете это :)

(gdb) b main
Breakpoint 1 at 0x8048365: file hello.c, line 5.
(gdb) r
Starting program: /home/beej/hello 

Breakpoint 1, main () at hello.c:5
(gdb) disp i
1: i = -1207447872
(gdb) next
1: i = 1
(gdb) next
1: i = 1
(gdb) next
1: i = 2
(gdb) next
1: i = 2
(gdb) next
1: i = 4
(gdb) next
1: i = 4
(gdb) next
1: i = 4
(gdb) 

Число слева от «i», выше, является номером дисплея переменной. Используйте этот номер, чтобы отключить (undisplay) переменную. Если вы забыли номера дисплея, вы можете ввести информационный дисплей (info display), чтобы получить их:

(gdb) b main
Breakpoint 1 at 0x8048365: file hello.c, line 5.
(gdb) r
Starting program: /home/beej/hello 

Breakpoint 1, main () at hello.c:5
(gdb) display i
1: i = -1207447872
(gdb) info display
Auto-display expressions now in effect:
Num Enb Expression
1:   y  i
(gdb) undisplay 1
(gdb)

Если вы просто хотите разобраться в значении переменной, вы можете ее распечатать (print). Здесь мы видим, что значение «i» равно 40:

(gdb) print i
$1 = 40
(gdb)

(«$» c номером после того, как это что-то значит, но это не важно для новичков.)

Также есть удобная команда printf, которую вы можете использовать для лучшего форматирования вывода, если хотите:

(gdb) printf "%d\n", i
40
(gdb) printf "%08X\n", i
00000028
(gdb)

Misc Материал

Это материал, который не подходит для предыдущих разделов, но он достаточно забав, чтобы что-то перечислить.

Манипуляция стеками

Команда backtrace (или bt) покажет вам текущий стек вызовов функций с текущей функцией вверху и вызывающими абонентами под ним:

(gdb) backtrace
#0  subsubfunction () at hello.c:5
#1  0x080483a7 in subfunction () at hello.c:10
#2  0x080483cf in main () at hello.c:16
(gdb)

Введите help stack для получения дополнительной информации о том, что вы можете с этим сделать.

Дополнительные методы шага

Чтобы выйти из текущей функции и вернуться к вызывающей функции, используйте команду finish.

Чтобы выполнить одну командную команду, используйте команду stepi.

Чтобы продолжить в определенном месте, используйте команду advance, указав расположение, как показано в разделе" Breakpoints" выше. Вот пример, который продвигается от текущего местоположения до вызова функции subsubfunction():

Breakpoint 1, main () at hello.c:15
15		printf("Hello, world!\n");
(gdb) advance subsubfunction
Hello, world!
subsubfunction () at hello.c:5
5		printf("Deepest!\n");
(gdb) 

advance - это просто сокращение для «продолжения этой временной точки останова».

Прыжки к произвольной секции кода

Команда jump работает точно так же, как и continue, за исключением того, что для перехода в качестве аргумента требуется местоположение. (См. Раздел «Точки останова», выше, для получения дополнительной информации о местах.)

Если вам нужно остановиться в пункте назначения прыжка, сначала установите точку останова.

Изменение переменных и значений во время выполнения

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

Breakpoint 1, main () at hello.c:15
15		int i = 10;
(gdb) print i
$1 = -1208234304
(gdb) set (i = 20)
(gdb) print i
$2 = 20
(gdb) set variable i = 40
(gdb) print i
$3 = 40
(gdb) 

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

Аппаратные точки наблюдения

Аппаратные точки наблюдения - это специальные точки останова, которые будут срабатывать при каждом изменении выражения. Часто вы просто хотите знать, когда переменная изменяется (записывается), и для этого вы можете использовать команду watch:

Breakpoint 1, main () at hello.c:5
5		int i = 1;
(gdb) watch i
Hardware watchpoint 2: i
(gdb) continue
Continuing.
Hardware watchpoint 2: i

Old value = -1208361280
New value = 2
main () at hello.c:7
7		while (i < 100) {
(gdb) continue
Continuing.
Hardware watchpoint 2: i

Old value = 2
New value = 3
main () at hello.c:7
7		while (i < 100) {
(gdb)

Обратите внимание, что watch принимают выражение в качестве аргумента, поэтому вы можете поместить там имя переменной или нечто более сложное, например *(p+5) или [15]. Я даже пробовал его с условными выражениями вроде i> 10, но имел смешанные результаты.

Вы можете получить список точек наблюдения с info break или info watch, и вы можете удалить их по номеру с помощью команды delete.

Наконец, вы можете использовать rwatch для обнаружения, когда переменная читается, и вы можете использовать awatch для обнаружения, когда переменная читается или записывается.

Присоединить к запущенному процессу

Если ваша программа уже идет, и вы хотите ее остановить и отладить, сначала вам понадобится идентификатор процесса (PID), который будет числом. (Получите его от команды ps от Unix.) Затем вы будете использовать команду attach с PID для присоединения (и разрыва) запущенной программы.

Для этого вы можете просто запустить gdb без аргументов.

В следующем полном запуске вы заметите несколько вещей. Сначала я присоединяюсь к запущенному процессу, и он говорит мне, что он находится в некоторой функции в глубине, называемой __nanosleep_nocancel(), что не слишком удивительно, так как я назвал sleep() в моем коде. Действительно, запрос на backtrace показывает именно этот стек вызовов. Поэтому я говорю, что закончу (finish) пару раз, чтобы вернуться к main().

$ gdb
GNU gdb 6.8
Copyright (C) 2008 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later 
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "i486-slackware-linux".
(gdb) attach 3490
Attaching to process 3490
Reading symbols from /home/beej/hello...done.
Reading symbols from /lib/libsafe.so.2...done.
Loaded symbols for /lib/libsafe.so.2
Reading symbols from /lib/libc.so.6...done.
Loaded symbols for /lib/libc.so.6
Reading symbols from /lib/libdl.so.2...done.
Loaded symbols for /lib/libdl.so.2
Reading symbols from /lib/ld-linux.so.2...done.
Loaded symbols for /lib/ld-linux.so.2
0xb7eab21b in __nanosleep_nocancel () from /lib/libc.so.6
(gdb) backtrace 
#0  0xb7eab21b in __nanosleep_nocancel () from /lib/libc.so.6
#1  0xb7eab05f in sleep () from /lib/libc.so.6
#2  0x080483ab in main () at hello.c:10
(gdb) finish
Run till exit from #0  0xb7eab21b in __nanosleep_nocancel ()
   from /lib/libc.so.6
0xb7eab05f in sleep () from /lib/libc.so.6
(gdb) finish
Run till exit from #0  0xb7eab05f in sleep () from /lib/libc.so.6
0x080483ab in main () at hello.c:10
10			sleep(1);
(gdb) list
5	{
6		int i = 1;
7	
8		while (i < 60) {
9			i++;
10			sleep(1);
11		}
12	
13		return 0;
14	}
(gdb) print i
$1 = 19
(gdb) quit
The program is running.  Quit anyway (and detach it)? (y or n) y
Detaching from program: /home/beej/hello, process 3490

Обратите внимание, что когда я вернусь к main(), я распечатаю значение i, а 19 - потому что в этом случае программа работает в течение 19 секунд, и я получаю инкремент раз в секунду.

Как только мы покинем debugger и отделимся от программы, программа вернется к нормальной работе.

Смешайте это с set variable, выше, и у вас есть сила!

Использование Coredumps для анализа Postmortem

Предположим, вы создаете и запускаете программу, и по какой-то причине она сбрасывает ядро:

$ cc -g -o foo foo.c
$ ./foo
Segmentation fault (core dumped)

Это означает, что основной файл (с моментальным снимком памяти с момента сбоя) был создан с именем «core». Если вы не получаете основной файл (то есть он говорит только «Ошибка сегментации» и не создается основной файл), у вас может быть слишком низкий уровень ulimit; попробуйте ввести ulimit -c limited в командной строке.

Вы можете запустить gdb с параметром -c, чтобы указать основной файл:

$ gdb -tui -c core foo

И, если в режиме TUI вас встретит экран информации, рассказывающий вам, почему программа вышла («сигнал 11, ошибка сегментации»), и подсветка будет на линии нарушения. (В режиме немой клеммы печатается строка нарушения.)

В этом примере я печатаю переменную, вызывающую проблему. Действительно, это NULL:

Даже если у вас нет всего исходного кода, часто бывает полезно получить backtrace с точки, где программа разбилась.

Функции окна

В режиме TUI вы можете получить список существующих окон с помощью команды info win. Затем вы можете изменить, какое окно фокусируется с помощью команды focus (или fs). focus принимает либо имя окна, либо «prev» или «next» в качестве аргумента. Допустимыми именами окна являются «SRC» (исходное окно), «CMD» (окно команд), «REGS» (окно регистров) и «ASM» (окно сборки). См. Следующий раздел о том, как использовать эти другие окна.

Обратите внимание, что когда окно SRC имеет фокус, клавиши со стрелками перемещают исходный код, но когда окно CMD имеет фокус, клавиши со стрелками будут выбирать предыдущую и следующую команды в истории команд. (Для записи команды для перемещения отдельных окон SRC и отдельных страниц +, -, <, and >).

(gdb) info win
        SRC     (36 lines)  
        CMD     (18 lines)
(gdb) fs next
Focus set to CMD window.
(gdb) info win
        SRC     (36 lines)
        CMD     (18 lines)  
(gdb) fs SRC
Focus set to SRC window.
(gdb)

(Названия окон являются чувствительными к регистру.)

Команда winheight (или wh) задает высоту определенного окна, но мне не повезло, что это хорошо работает.

Отображать регистры и сборку

В режиме TUI команда layout управляет окнами, которые вы видите. Кроме того, tui reg позволяет управлять окном регистра и открывает его, если он еще не открыт.

Команды:

Вот отличный скриншот, чтобы поднять аппетит, показывая источник и сборку в режиме «split»:

Код сборки поставляется в двух вариантах на компьютерах Intel: Intel и AT&T. Вы можете установить, какой из них отображается в окне разборки, с set disassembly-flavor. Допустимыми значениями являются «intel» и «att». Если у вас уже открыто окно сборки, вам придется закрыть его и снова открыть (например, layout src, за которым следует layout split).

Чтобы отображать регистры в режиме терминала, введите info registers для целых регистров или info all-registers для всех.

Написание интерфейса

Вы думаете: «Ого, это довольно круто, но я могу написать интерфейс для убийцы для этой вещи, которая работала намного лучше! Как мне это сделать?»

GDB поддерживает то, что он называет «интерпретатор машинного интерфейса», или GDB/MI. Интерпретатор выбирается в командной строке gdb с помощью переключателя --interpreter.

В основном вы запускаете gdb и читаете команды и результаты в и из него (возможно, используя каналы). Довольно просто.

Для получения подробной информации см. Документацию GDB.

Краткий справочник

Параметры команды выделены курсивом. Дополнительные параметры заключены в квадратные скобки. Все команды могут быть сокращены до тех пор, пока они не станут двусмысленными.

Этот список очень неполный и показывает только то, о чем говорится в этом уроке!