Linux gdb команды. Изучаем С используя GDB
Цель отладки программы - устранение ошибок в её коде. Для этого вам, скорее всего, придётся исследовать состояние переменных во время выполнения , равно как и сам процесс выполнения (например, отслеживать условные переходы). Тут отладчик - наш первый помощник. Конечно же, в Си достаточно много возможностей отладки без непосредственной остановки программы: от простогоprintf(3) до специальных систем ведения логов по сети и syslog . В ассемблере такие методы тоже применимы, но вам может понадобиться наблюдение за состоянием регистров, образ ( dump ) оперативной памяти и другие вещи, которые гораздо удобнее сделать в интерактивном отладчике. В общем, если вы пишете на ассемблере, то без отладчика вы вряд ли обойдётесь.
Начать отладку можно с определения точки останова ( breakpoint ), если вы уже приблизительно знаете, какой участок кода нужно исследовать. Этот способ используется чаще всего: ставим точку останова, запускам программу и проходим её выполнение по шагам, попутно наблюдая за необходимыми переменными и регистрами. Вы также можете просто запустить программу под отладчиком и поймать момент, когда она аварийно завершается из-за segmentation fault, - так можно узнать, какая инструкция пытается получить доступ к памяти, подробнее рассмотреть приводящую к ошибке переменную и так далее. Теперь можно исследовать этот код ещё раз, пройти его по шагам, поставив точку останова чуть раньше момента сбоя.
Начнём с простого. Возьмём программу Hello world и скомпилируем её с отладочной информацией при помощи ключа компилятора -g :
$ gcc -g hello.s -o hello $
Запускаем gdb:
$ gdb ./hello GNU gdb 6.4.90-debian Copyright (C) 2006 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions. Type "show copying" to see the conditions. There is absolutely no warranty for GDB. Type "show warranty" for details. This GDB was configured as "i486-linux-gnu"...Using host libthread_db library "/lib/tls/libthread_db.so.1". (gdb)
GDB запустился, загрузил исследуемую программу, вывел на экран приглашение (gdb) и ждёт команд. Мы хотим пройти программу "по шагам" ( single-step mode ). Для этого нужно указать команду, на которой программа должна остановиться. Можно указать подпрограмму - тогда остановка будет осуществлена перед началом исполнения инструкций этой подпрограммы. Ещё можно указать имя файла и номер строки.
(gdb) b main Breakpoint 1 at 0x8048324: file hello.s, line 17. (gdb)
b - сокращение от break . Все команды в GDB можно сокращать, если это не создаёт двусмысленных расшифровок. Запускаем программу командой run . Эта же команда используется для перезапуска ранее запущенной программы.
(gdb) r Starting program: /tmp/hello Breakpoint 1, main () at hello.s:17 17 movl $4, %eax /* поместить номер системного вызова write = 4 Current language: auto; currently asm (gdb)
GDB остановил программу и ждёт команд. Вы видите команду вашей программы, которая будет выполнена следующей, имя функции , которая сейчас исполняется, имя файла и номер строки. Для пошагового исполнения у нас есть две команды: step (сокращённо s ) и next (сокращённо n ). Команда step производит выполнение программы с заходом в тела подпрограмм. Команда next выполняет пошагово только инструкции текущей подпрограммы.
(gdb) n 20 movl $1, %ebx /* первый параметр - в регистр %ebx */ (gdb)
Итак, инструкция на строке 17 выполнена, и мы ожидаем, что в регистре %eax находится число 4. Для вывода на экран различных выражений используется команда print (сокращённо p ). В отличие от команд ассемблера, GDB в записи регистров использует знак $ вместо % . Посмотрим, что в регистре %eax :
(gdb) p $eax $1 = 4 (gdb)
Действительно 4! GDB нумерует все выведенные выражения. Сейчас мы видим первое выражение ($1 ), которое равно 4. Теперь к этому выражению можно обращаться по имени. Также можно производить простые вычисления:
(gdb) p $1 $2 = 4 (gdb) p $1 + 10 $3 = 14 (gdb) p 0x10 + 0x1f $4 = 47 (gdb)
Пока мы играли с командой print , мы уже забыли, какая инструкция исполняется следующей. Команда info line выводит информацию об указанной строке кода. Без аргументов выводит информацию о текущей строке.
(gdb) info line
Line 20 of "hello.s" starts at address 0x8048329
Команда list (сокращённо l ) выводит на экран исходный код вашей программы. В качестве аргументов ей можно передать:
- номер_строки - номер строки в текущем файле;
- файл:номер_строки - номер строки в указанном файле;
- имя_функции - имя функции, если нет неоднозначности;
- файл:имя_функции - имя функции в указанном файле;
- *адрес - адрес в памяти, по которому расположена необходимая инструкция.
Если передавать один аргумент , команда list выведет 10 строк исходного кода вокруг этого места. Передавая два аргумента, вы указываете строку начала и строку конца листинга.
(gdb) l main 12 за пределами этого файла */ 13 .type main, @function /* main - функция (а не данные) */ 14 15 16 main: 17 movl $4, %eax /* поместить номер системного вызова 18 write = 4 в регистр %eax */ 19 20 movl $1, %ebx /* первый параметр поместить в регистр 21 %ebx; номер файлового дескриптора 22 stdout = 1 */ (gdb) l *$eip 0x8048329 is at hello.s:20. 15 16 main: 17 movl $4, %eax /* поместить номер системного вызова 18 write = 4 в регистр %eax */ 19 20 movl $1, %ebx /* первый параметр поместить в регистр 21 %ebx; номер файлового дескриптора 22 stdout = 1 */ 23 movl $hello_str, %ecx /* второй параметр поместить в 24 регистр %ecx; указатель на строку */ (gdb) l 20, 25 20 movl $1, %ebx /* первый параметр поместить в регистр 21 %ebx; номер файлового дескриптора 22 stdout = 1 */ 23 movl $hello_str, %ecx /* второй параметр поместить в 24 регистр %ecx; указатель на строку */ 25 (gdb)
Запомните эту команду: list *$eip . С её помощью вы всегда можете просмотреть исходный код вокруг инструкции, выполняющейся в текущий момент. Выполняем нашу программу дальше:
(gdb) n 23 movl $hello_str, %ecx /* второй параметр поместить в регистр %ecx (gdb) n 26 movl $hello_str_length, %edx /* третий параметр поместить в регистр %edx (gdb)
Не правда ли, утомительно каждый раз нажимать n ? Если просто нажать Enter , GDB повторит последнюю команду:
(gdb) 29 int $0x80 /* вызвать прерывание 0x80 */ (gdb) Hello, world! 31 movl $1, %eax /* номер системного вызова exit = 1 */ (gdb)
Ещё одна удобная команда , о которой стоит знать - info registers . Конечно же, её можно сократить до i r . Ей можно передать параметр - список регистров, которые необходимо напечатать. Например, когда выполнение происходит в защищённом режиме, нам вряд ли будут интересны значения сегментных регистров.
(gdb) info registers
eax 0xe 14
ecx 0x804955c 134518108
edx 0xe 14
ebx 0x1 1
esp 0xbfabb55c 0xbfabb55c
ebp 0xbfabb5a8 0xbfabb5a8
esi 0x0 0
edi 0xb7f6bcc0 -1208566592
eip 0x804833a 0x804833a
Так, а кроме регистров у нас ведь есть ещё и
Поговорим об отладчиках для Microsoft Windows. Их существует довольно много, вспомнить хотя бы всеми любимый OllyDbg, некогда популярный, но в настоящее время практически умерший SoftIce, а также Sycer, Immunity Debugger, x64dbg и бесчисленное количество отладчиков, встроенных в IDE. По моим наблюдениям, WinDbg нравится далеко не всем. Думаю, в основном это связано с командным интерфейсом отладчика. Любителям Linux и FreeBSD, бесспорно, он пришелся бы по душе. Но закоренелым пользователям Windows он кажется странным и неудобным. А тем временем, по функционалу WinDbg ничем не уступает другим отладчикам. Как минимум, он точно нечем не хуже классического GDB или там LLDB . В чем мы сегодня с вами и убедимся.
В мире Windows, все, как обычно, немного через жопу. Официальный инсталятор WinDbg можно скачать на сайте MS. Инсталятор этот помимо WinDbg также поставит вам свежую версию.NET Framework и перезагрузит систему без спроса. После установки не факт, что отладчик вообще заработает, особенно под старыми версиями Windows. Поэтому лучше скачать неофициальную сборку WinDbg или . Настоятельно советую воспользоваться именно одной из этих версий — это самый простой и быстрый способ установить WinDbg.
Есть две версии WinDbg, x86 и x64. Чтобы не возникало никаких проблем, отлаживайте x86 приложения с помощью x86 дебагера, а x64 приложения — с помощью x64 дебагера. После первого запуска выглядеть WinDbg будет довольно убого. Но не беспокойтесь по этому поводу. Поработав буквально несколько минут с WinDbg, вы подстроите его под себя и выглядеть он будет вполне няшненько. Например, как-то так (кликабельно, 51 Кб, 1156 x 785):
На этом скриншоте изображена отладка программы из заметки Получаем список запущенных процессов на Windows API . Как видите, WinDbg подцепил исходники программы. Справа отображаются значения локальных переменных. Внизу находится окно для ввода команд, где при помощи команды kn был выведен стэк вызовов. В верхней части отладчика находятся кнопки, при помощи которых можно выполнять простые действия вроде «шаг вперед», а также открыть дополнительные окна. При помощи этих окон можно посмотреть содержимое оперативной памяти, значения регистров, дизассемблерный листинг программы и много других интересных вещей.
Вообще, очень многое в WinDbg можно делать через GUI. Например, в окне с исходным кодом можно поставить курсор на нужном месте и нажатием на икноку с ладонью создать там точку останова. Или выполнить run to cursor. Также выполнение команды можно в любой момент остановить при помощи кнопки Break в панели вверху. На этом всем подробно останавливаться не будем. Но учтите, что такие возможности есть и они заслуживают изучения!
Прежде, чем приступить к отладке при помощи WinDbg, нужно сделать несколько несложных телодвижений. Откройте File → Symbol File Path и введите:
SRV*C:\symbols*http://msdl.microsoft.com/download/symbols
Затем нажмите Browse и укажите путь до файлов c отладочной информацией (.pdb) вашего проекта. Аналогичным образом в File → Source File Path укажите путь до каталога с исходниками. Если сомневаетесь, укажите путь, по которому находится файл проекта Visual Studio, не ошибетесь. Затем скажите File → Save Workspace, чтобы все эти пути не приходилось указывать заново при каждом запуске WinDbg.
Теперь, когда все настроено, есть несколько способов начать отладку. Можно запустить новый процесс под отладчиком, можно подключиться к уже существующему, можно открыть крэшдамп. Все это делается через меню File. Особого внимания заслуживает возможность удаленной отладки. Например, если при помощи WinDbg вы отлаживаете драйверы, то особого выбора, кроме как использовать удаленную отладку, у вас как бы и нет. Что не удивительно, ведь малейшая ошибка в коде драйвера может привести к BSOD.
Если вы уже отлаживаете процесс, но хотели бы начать делать это удаленно, говорим:
Server tcp:port=3003
Нужно проверить, что порт открыт, что особенно актуально на Windows Server. На клиенте делаем File → Connect to a Remote Session, вводим:
tcp:Port=3003,Server=10.110.0.10
Кроме того, можно запустить сервер, позволяющий отлаживать любой процесс в системе:
dbgsrv.exe -t tcp:port=3003
На клиенте подключаемся через File → Connect to Remote Stub. После этого через интерфейс можно как обычно выбрать процесс из списка или запустить новый. Только работать процессы будут на удаленной машине.
Теперь, наконец-то, рассмотрим основные команды WinDbg.
Важно! Иногда команды могут выполняется очень долго, например, если вы решили загрузить сразу все отладочные символы. Если устанете ждать, просто нажмите Ctr+C в поле ввода команды, и WinDbg тут же перестанет делать то, что он сейчас делает.
Help
.hh команда
Очистить вывод в окне Command:
Добавить путь, по которому WinDbg будет искать отладочные символы (та же команда без знака плюс затрет все ранее прописанные пути):
Sympath+ c:\pdbs
Перезагрузить символы:
Показать список модулей:
Ищем символы:
x *!Ololo::My::Namespace::*
Загрузить символы для модуля:
ld имя_модуля
Если WinDbg почему-то не находит.pdb файлы и в стектрейсах вместо имен.c/.cpp файлов с номерами строк вы видите что-то вроде module+0x19bc, попробуйте выполнить следующую последовательность команд — так вы получите больше информации о возможных причинах проблемы:
Sym noisy
.reload MyModule.dll
Указать путь к каталогу исходников:
Поставить точку останова:
bp kernel32!CreateProcessA
bp `mysorucefile.cpp:123`
bp `MyModule!mysorucefile.cpp:123`
bp @@(Full::Class:Name::method)
Поставить точку остановка, которая сработает только один раз:
Поставить точку останова, которая сработает на 5-ый раз, после 4-х проходов:
Можно автоматически выполнять команды каждый раз, когда срабатывает точка останова:
bp kernel32!LoadLibraryA ".echo \"Variables:\n\"; dv"
У аппаратных точек останова синтаксис такой:
ba
Где mode это e, r или w — выполнение, чтение, запись. При mode = e параметр size может быть только 1. Например:
ba e 1 kernel32!LoadLibraryA
Список точек останова:
Деактивировать точку останова:
Активировать точку останова:
Полное удаление точек останова:
bc номер
bc *
Показать команды, которые нужно ввести для восстановления текущих точек останова:
Писать лог в файл:
Logopen c:\1.txt
Перестать писать лог в файл:
Выполнить команды из файла:
Для сохранения точек останова в файл можно выполнить (обязательно в одну строку!) следующие команды:
Logopen c:\1.txt; .bpcmds; .logclose
Показать дизассемблерный листинг:
Показать значение регистров:
Показать стек вызовов:
То же самое с номерами фреймов:
Перемещение к фрейму:
Frame номер
Показать локальные переменные:
Показать структуру:
dt имя_переменной
Показать структуру рекурсивно:
dt -r имя_переменной
Дамп памяти по адресу:
Дамп памяти в виде word/dword/qword:
dw адрес
dd адрес
dq адрес
Дамп в виде битов:
Дамп ascii строки:
Дамп unicode строки:
Редактирование памяти.
Перевод статьи Аллана О’Доннелла Learning C with GDB .
Исходя из особенностей таких высокоуровневых языков, как Ruby, Scheme или Haskell, изучение C может быть сложной задачей. В придачу к преодолению таких низкоуровневых особенностей C, как ручное управление памятью и указатели, вы еще должны обходиться без REPL . Как только Вы привыкнете к исследовательскому программированию в REPL, иметь дело с циклом написал-скомпилировал-запустил будет для Вас небольшим разочарованием.
Недавно мне пришло в голову, что я мог бы использовать GDB как псевдо-REPL для C. Я поэкспериментировал, используя GDB как инструмент для изучения языка, а не просто для отладки, и оказалось, что это очень весело.
Цель этого поста – показать Вам, что GDB является отличным инструментом для изучения С. Я познакомлю Вас с несколькими моими самыми любимыми командами из GDB, и продемонстрирую каким образом Вы можете использовать GDB, чтобы понять одну из сложных частей языка С: разницу между массивами и указателями.
Введение в GDB
Начнем с создания следующей небольшой программы на С – minimal.c :Int main()
{
int i = 1337;
return 0;
}
Обратите внимание, что программа не делает абсолютно ничего, и даже не имеет ни одной команды printf
. Теперь окунемся в новый мир изучения С используя GBD.
Скомпилируем эту программу с флагом -g для генерирования отладочной информации, с которой будет работать GDB, и подкинем ему эту самую информацию:
$ gcc -g minimal.c -o minimal
$ gdb minimal
Теперь Вы должны молниеносно оказаться в командной строке GDB. Я обещал вам REPL, так получите:
(gdb) print 1 + 2
$1 = 3
Удивительно! print
– это встроенная команда GDB, которая вычисляет результат С-ного выражения. Если Вы не знаете, что именно делает какая-то команда GDB, просто воспользуйтесь помощью – наберите help name-of-the-command
в командной строке GDB.
Вот Вам более интересный пример:
(gbd) print (int) 2147483648
$2 = -2147483648
Я упущу разъяснение того, почему 2147483648 == -2147483648
. Главная суть здесь в том, что даже арифметика может быть коварная в С, а GDB отлично понимает арифметику С.
Теперь давайте поставим точку останова в функции main и запустим программу:
(gdb) break main
(gdb) run
Программа остановилась на третьей строчке, как раз там, где инициализируется переменная i
. Интересно то, что хотя переменная пока и не проинициализирована, но мы уже сейчас можем посмотреть ее значение, используя команду print
:
(gdb) print i
$3 = 32767
В С значение локальной неинициализированной переменной не определено, поэтому полученный Вами результат может отличаться.
Мы можем выполнить текущую строку кода, воспользовавшись командой next :
(gdb) next (gdb) print i $4 = 1337
Исследуем память используя команду X
Переменные в С – это непрерывные блоки памяти. При этом блок каждой переменной характеризуется двумя числами:1. Числовой адрес первого байта в блоке.
2. Размер блока в байтах. Этот размер определяется типом переменной.
Одна из отличительных особенностей языка С в том, что у Вас есть прямой доступ к блоку памяти переменной. Оператор & дает нам адрес переменной в памяти, а sizeof вычисляет размер, занимаемый переменной памяти.
Вы можете поиграть с обеими возможностями в GDB:
(gdb) print &i
$5 = (int *) 0x7fff5fbff584
(gdb) print sizeof(i)
$6 = 4
Говоря нормальным языком, это значит, что переменная i
размещается по адресу 0x7fff5fbff5b4
и занимает в памяти 4 байта.
Я уже упоминал выше, что размер переменной в памяти зависит от ее типа, да и вообще говоря, оператор sizeof может оперировать и самими типами данных:
(gdb) print sizeof(int)
$7 = 4
(gdb) print sizeof(double)
$8 = 8
Это означает, что по меньшей мере на моей машине, переменные типа int
занимают четыре байта, а типа double
– восемь байт.
В GDB есть мощный инструмент для непосредственного исследования памяти – команда x . Эта команда проверяет память, начиная с определенного адреса. Также она имеет ряд команд форматирования, которые обеспечиваю точный контроль над количеством байт, которые Вы захотите проверить, и над тем, в каком виде Вы захотите вывести их на экран. В случае каких либо трудностей, наберите help x в командной строке GDB.
Как Вы уже знаете, оператор & вычисляет адрес переменной, а это значит, что можно передать команде x значение &i и тем самым получить возможность взглянуть на отдельные байты, скрывающиеся за переменной i :
(gdb) x/4xb &i
0x7fff5fbff584: 0x39 0x05 0x00 0x00
Флаги форматирования указывают на то, что я хочу получить четыре (4
) значения, выведенные в шестнадцатеричном (hex
) виде по одному байту (b
yte). Я указал проверку только четырех байт, потому что именно столько занимает в памяти переменная i
. Вывод показывает побайтовое представление переменной в памяти.
Но с побайтовым выводом связана одна тонкость, которую нужно постоянно держать в голове – на машинах Intel байты хранятся в порядке “от младшего к старшему ” (справа налево), в отличии от более привычной для человека записи, где младший байт должен был бы находиться в конце (слева направо).
Один из способов прояснить этот вопрос – это присвоить переменной i более интересное значение и опять проверить этот участок памяти:
(gdb) set var i = 0x12345678 (gdb) x/4xb &i 0x7fff5fbff584: 0x78 0x56 0x34 0x12
Исследуем память с командой ptype
Команда ptype возможно одна из моих самых любимых. Она показывает тип С-го выражения: (gdb) ptype i
type = int
(gdb) ptype &i
type = int *
(gdb) ptype main
type = int (void)
Типы в С могут становиться сложными , но ptype
позволяет исследовать их в интерактивном режиме.
Указатели и массивы
Массивы являются на удивление тонким понятием в С. Суть этого пункта в том, чтобы написать простенькую программу, а затем прогонять ее через GDB, пока массивы не обретут какой-то смысл.Итак, нам нужен код программы с массивом array.c :
Int main()
{
int a = {1, 2, 3};
return 0;
}
Скомпилируйте ее с флагом -g
, запустите в GDB, и с помощь next
перейдите в строку инициализации:
$ gcc -g arrays.c -o arrays
$ gdb arrays
(gdb) break main
(gdb) run
(gdb) next
На этом этапе Вы сможете вывести содержимое переменной и выяснить ее тип:
(gdb) print a
$1 = {1, 2, 3}
(gdb) ptype a
type = int
Теперь, когда наша программа правильно настроена в GDB, первое, что стоит сделать – это использовать команду x
для того, чтобы увидеть, как выглядит переменная a
“под капотом”:
(gdb) x/12xb &a
0x7fff5fbff56c: 0x01 0x00 0x00 0x00 0x02 0x00 0x00 0x00
0x7fff5fbff574: 0x03 0x00 0x00 0x00
Это означает, что участок памяти для массива a
начинается по адресу 0x7fff5fbff56c
. Первые четыре байта содержат a
, следующие четыре – a
, и последние четыре хранят a
. Действительно, Вы можете проверить и убедится, что sizeof
знает, что a
занимает в памяти ровно двенадцать байт:
(gdb) print sizeof(a)
$2 = 12
До этого момента массивы выглядят такими, какими и должны быть. У них есть соответствующий массивам типы и они хранят все значения в смежных участках памяти. Однако, в определенных ситуациях, массивы ведут себя очень схоже с указателями! К примеру, мы можем применять арифметические операции к a
:
(gdb) print a + 1
$3 = (int *) 0x7fff5fbff570
Нормальными словами, это означает, что a + 1
– это указатель на int
, который имеет адрес 0x7fff5fbff570
. К этому моменту Вы должны уже рефлекторно передавать указатели в команду x
, итак посмотрим, что же получилось:
(gdb) x/4xb a + 1 0x7fff5fbff570: 0x02 0x00 0x00 0x00
Обратите внимание, что адрес 0x7fff5fbff570 ровно на четыре единицы больше, чем 0x7fff5fbff56c , то есть адрес первого байта массива a . Учитывая, что тип int занимает в памяти четыре байта, можно сделать вывод, что a + 1 указывает на a .
На самом деле, индексация массивов в С является синтаксическим сахаром для арифметики указателей: a[i] эквивалентно *(a + i) . Вы можете проверить это в GDB:
(gdb) print a
$4 = 1
(gdb) print *(a + 0)
$5 = 1
(gdb) print a
$6 = 2
(gdb) print *(a + 1)
$7 = 2
(gdb) print a
$8 = 3
(gdb) print *(a + 2)
$9 = 3
Итак, мы увидели, что в некоторых ситуациях a
ведет себя как массив, а в некоторых – как указатель на свой первый элемент. Что же происходит?
Ответ состоит в следующем, когда имя массива используется в выражении в С, то оно “распадается (decay)” на указатель на первый элемент. Есть только два исключения из этого правила: когда имя массива передается в sizeof и когда имя массива используется с оператором взятия адреса & .
Тот факт, что имя a не распадается на указатель на первый элемент при использовании оператора & , порождает интересный вопрос: в чем же разница между указателем, на который распадается a и &a ?
Численно они оба представляют один и тот же адрес:
(gdb) x/4xb a
0x7fff5fbff56c: 0x01 0x00 0x00 0x00
(gdb) x/4xb &a
0x7fff5fbff56c: 0x01 0x00 0x00 0x00
Тем не менее, типы их различны. Как мы уже видели, имя массива распадается на указатель на его первый элемент и значит должно иметь тип int *
. Что же касается типа &a
, то мы можем спросить об этом GDB:
(gdb) ptype &a
type = int (*)
Говоря проще, &a
– это указатель на массив из трех целых чисел. Это имеет смысл: a
не распадается при передаче оператору &
и a имеет тип int
.
Вы можете проследить различие между указателем, на который распадается a и операцией &a на примере того, как они ведут себя по отношению к арифметике указателей:
(gdb) print a + 1
$10 = (int *) 0x7fff5fbff570
(gdb) print &a + 1
$11 = (int (*)) 0x7fff5fbff578
Обратите внимание, что добавление 1 к a
увеличивает адрес на четыре единицы, в то время, как прибавление 1 к &a
добавляет к адресу двенадцать.
Указатель, на который на самом деле распадается a имеет вид &a :
(gdb) print &a $11 = (int *) 0x7fff5fbff56c
Заключение
Надеюсь, я убедил Вас, что GDB – это изящная исследовательская среда для изучения С. Она позволяет выводить значение выражений с помощью команды print , побайтово исследовать память командой x и работать с типами с помощью команды ptype .1. Используйте GDB для работы над The Ksplice Pointer Challenge .
2. Разберитесь, как структуры хранятся в памяти. Как они соотносятся с массивами?
3. Используйте дизассемблерные команды GDB, чтобы лучше разобраться с программированием на ассемблере. Особенно весело исследовать, как работает стек вызова функции.
4. Зацените “TUI” режим GDB, который обеспечивает графическую ncurses надстройку над привычным GDB. На OS X, Вам вероятно придется собрать GDB из исходников.
От переводчика: Традиционно для указания ошибок воспользуйтесь ЛС. Буду рад конструктивной критике.
GDB относится к «умным» программам-отладчикам, то есть таким, которые «понимают» код и умеют выполнять его построчно, менять значения переменных, устанавливать контрольные точки и условия остановки… Словом, делать всё для того, чтобы разработчик мог проверить правильность работы своей программы.
GDB встроен во многие UNIX -подобные системы и умеет производить отладку нескольких языков программирования. Си - в их числе.
Чтобы вызвать GDB введите в терминале команду
Gdb [ имя_программы_которую_вы_хотите_отладить]
Чтобы выйти из GDB : введите команду
Quit или С –d
Другие важные команды GDB
run [аргументы командной строки программы] Запустить программу на выполнение. break [ номер строки / имя функции] Установить точку остановки программы на определенной строке или функции. next Перейти на следующую строку, не заходя внутрь функций. step Перейти на следующую строку. Если на строке вызов функции - зайти внутрь нее. list Вывести фрагмент кода программы (несколько строк вокруг того места, где сейчас установлена точка) print [ переменная] Вывести значение переменной на экран. info locals Вывести текущие значения всех локальных переменных внутри цикла, функции и так далее. display [ переменная] Вывести значение переменной на каждом шаге отладки. help Показать список всех команд GDB.Давайте посмотрим, как работать с GDB на примере программы caesar.c, которую вы, скорее всего уже написали на прошлой неделе. Проверять будем на собственной версии, так что у вас результаты могут несколько отличаться в зависимости от реализации.
Итак, переходим в папку pset2 (думаем, вы уже помните, как это сделать) в «Виртуальной лаборатории cs50» или CS50 IDE. Вводим команду:
Gdb . /caesar
В программе caesar есть одна функция, main. Установим точку остановки программы на функции main:
break mainЗапустим программу caesar с аргументом «3»:
Run 13
Допустим, нам надо проверить значение argc:
Print argc
Вот как всё это должно выглядеть в окне терминала:
Теперь выполняем программу пошагово с помощью команды next . Выполним несколько раз.
Здесь переменной key присваивают значение. Проверим, какое значение она имеет этой строке:
При первом вызве next переменной key присваивается значение «0». ПОчему так, если мы ввели число 3? Дело в том, что команда ещё не была выполнена. Когда вы вводим next ещё несколько раз, программа предлагает ввести текст.
Выполнив команду next еще раз, мы зайдем внутрь цикла с условием.