GDB/MI является построчным, машинно-ориентированным текстовым интерфейсом к GDB. Он предназначен специально для поддержки разработки систем, которые используют отладчик лишь как одну маленькую компоненту большой системы.
Эта глава является спецификацией интерфейса GDB/MI. Она написана в форме справочного руководства.
Заметьте, что GDB/MI все еще находится в стадии разработки, так что некоторые описанные ниже возможности являются неполными и могут быть изменены.
Эта глава использует следующую систему обозначений:
| разделяет две альтернативы.
[ нечто ] указывает, что нечто является
необязательным: оно может быть задано, а может и нет.
( группа )* означает, что группа в скобках может
повторяться ноль и более раз.
( группа )+ означает, что группа в скобках может
повторяться один и более раз.
"строка" обозначает текст строка.
В алфавитном порядке: Елена Заннони, Эндрю Кагни, Фернандо Нассер и Стан Шебс.
команда ==>
команда-cli | команда-mi
команда-cli ==>
[ лексема ] команда-cli nl, где
команда-cli есть любая существующая команда GDB CLI.
команда-mi ==>
[ лексема ] "-" действие ( " " ключ )*
[ " --" ] ( " " параметр )* nl
лексема ==>
ключ ==>
"-" параметр [ " " параметр ]
параметр ==>
непустая-последовательность | строка-си
действие ==>
непустая-последовательность ==>
строка-си ==>
""" содержимое-семибитной-строки-iso-си """
nl ==>
CR | CR-LF
Замечания:
Лексема, если присутствует, передается назад, когда
выполнение команды завершается.
Прагматические соображения:
Вывод GDB/MI состоит из нуля или более внеочередных записей, за которыми может следовать одна результирующая запись. Эта запись относится к самой последней команде. Последовательность выводимых записей завершается `(gdb)'.
Если входная команда начиналась с префикса лексема, то
соответствующий вывод для этой команды также будет начинаться с того же
префикса лексема.
вывод ==>
( внеочередная-запись )* [ результирующая-запись ] "(gdb)" nl
результирующая-запись ==>
[ лексема ] "^" результирующий-класс ( "," результат )* nl
внеочередная-запись ==>
асинхр-запись | поточн-запись
асинхр-запись ==>
асинхр-вывод-выполн | асинхр-вывод-статуса | асинхр-вывод-уведомл
асинхр-вывод-выполн ==>
[ лексема ] "*" асинхр-вывод
асинхр-вывод-статуса ==>
[ лексема ] "+" асинхр-вывод
асинхр-вывод-уведомл ==>
[ лексема ] "=" асинхр-вывод
асинхр-вывод ==>
асинхр-класс ( "," результат )* nl
результ-класс ==>
"done" | "running" | "connected" | "error" | "exit"
асинхр-класс ==>
"stopped" | другое (где другое будет добавлено
по необходимости---это все еще находится в стадии разработки).
результат ==>
[ строка "=" ] значение
значение ==>
константа | "{" результат ( "," результат )* "}"
константа ==>
строка-си
поточн-запись ==>
консольн-поточн-вывод | целев-поточн-вывод | журн-поточн-вывод
консольн-поточн-вывод ==>
"~" строка-си
целев-поточн-вывод ==>
"@" строка-си
журн-поточн-вывод ==>
"&" строка-си
nl ==>
CR | CR-LF
лексема ==>
Кроме того, следующее все еще находится в стадии разработки:
запрос
Замечания:
Лексема берется из соответствующего запроса. Если
выполнение команды прерывается командой `-exec-interrupt',
лексема, ассоциированная с сообщением `*stopped', является
лексемой исходной выполняемой команды, а не лексемой
команды прерывания.
See section Поточные записи GDB/MI, для более подробной информации о различных выводимых записях.
See section Черновик изменений к выходному синтаксису GDB/MI, для предлагаемых изменений к выходному синтаксису.
Этот подраздел представляет несколько простых примеров взаимодействия с использованием интерфейса GDB/MI. В этих примерах, `->' означает, что следующая строка передается GDB/MI в качестве ввода, а `<-' означает вывод, полученный от GDB/MI.
Вот пример останова подчиненного процесса:
-> -stop
<- (gdb)
и затем:
<- *stop,reason="stop",address="0x123",source="a.c:123"
<- (gdb)
Вот пример простой команды CLI, передаваемой ему через GDB/MI.
-> print 1+2
<- ~3\n
<- (gdb)
-> -symbol-file xyz.exe
<- *breakpoint,nr="3",address="0x123",source="a.c:123"
<- (gdb)
Вот что происходит, если вы передаете несуществующую команду:
-> -rubbish
<- error,"Rubbish not found"
<- (gdb)
Чтобы помочь пользователям, знакомым с существующим в GDB интерфейсом CLI, GDB/MI принимает существующие команды CLI. Как определено синтаксисом, такие команды могут быть непосредственно введены в интерфейс GDB/MI, и GDB будет отвечать.
Этот механизм предоставляется для помощи разработчикам клиентов GDB/MI, а не как надежный интерфейс к CLI. Так как команда интерпретируется в среде, которая подразумевает поведение GDB/MI, точные результаты таких команд в конечном итоге скорее всего станут неудобоваримой смесью вывода GDB/MI и CLI.
В дополнение к множеству внеочередных уведомлений, ответ на команду GDB/MI включает один из следующих указателей результата:
"^done" [ "," результаты ]
результаты.
"^running"
"^error" "," строка-си
Строка-си содержит
соответствующее сообщение об ошибке.
GDB хранит число выходных потоков: консоль, цель и журнал. Вывод, предназначенный для этих потоков, пропускается через интерфейс GDB/MI при помощи поточных записей.
Каждая поточная запись начинается с уникального префиксного
символа, который идентифицирует свой поток (see section Выходной синтаксис GDB/MI). Помимо префикса, каждая
поточная запись содержит строку-вывод. Это либо простой
текст (с подразумеваемым знаком новой строки), или Си-строка в кавычках
(которая не содержит подразумеваемого знака новой строки).
"~" строка-вывод
"@" строка-вывод
"&" строка-вывод
Внеочередные записи используются для уведомления клиента GDB/MI о произошедших дополнительных изменениях. Эти изменения могут либо исходить от GDB/MI (например, измененная точка останова), либо быть результатом действий цели (например, цель остановилась).
Ниже приведен предварительный список возможных внеочередных записей.
"*" "stop"
Оставшиеся разделы описывают блоки команд. Каждый блок команд схематично аналогичен этому разделу.
Заметьте, что разбиения строк в примерах присутствуют только для удобства чтения. Они не появляются в реальном выводе. Учтите также, что команды с недоступными примерами (Н.П.) еще не реализованы.
Мотивация для этого набора команд.
Краткое введение в этот набор команд в целом.
Для каждой команды в блоке, описано следующее:
-command арг...
Соответствующая команда CLI GDB.
Этот раздел описывает команды GDB/MI для управления точками останова.
-break-after
-break-after номер число
Точка останова с номером номер не срабатывает, пока она не будет достигнута число раз. Чтобы увидеть, как это отражается на выводе команды `-break-list', смотрите ниже описание команды `-break-list'.
Соответствующей командой GDB является `ignore'.
(gdb)
-break-insert main
^done,bkpt={number="1",addr="0x000100d0",file="hello.c",line="5"}
(gdb)
-break-after 1 3
~
^done
(gdb)
-break-list
^done,BreakpointTable={hdr={"Num","Type","Disp","Enb","Address","What"},
bkpt={number="1",type="breakpoint",disp="keep",enabled="y",
addr="0x000100d0",func="main",file="hello.c",line="5",times="0",
ignore="3"}}
(gdb)
-break-condition
-break-condition номер выраж
Точка останова номер остановит программу, только если условие выраж истино. Условие становится частью вывода `-break-list' (смотрите ниже описание команды `-break-list').
Соответствующей командой GDB является `condition'.
(gdb)
-break-condition 1 1
^done
(gdb)
-break-list
^done,BreakpointTable={hdr={"Num","Type","Disp","Enb","Address","What"},
bkpt={number="1",type="breakpoint",disp="keep",enabled="y",
addr="0x000100d0",func="main",file="hello.c",line="5",cond="1",
times="0",ignore="3"}}
(gdb)
-break-delete
-break-delete ( точка-останова )+
Удалить точки останова, чьи номера указаны в списке аргументов. Это, очевидно, отражается на списке точек останова.
Соответствующей командой GDB является `delete'.
(gdb)
-break-delete 1
^done
(gdb)
-break-list
^done,BreakpointTable={}
(gdb)
-break-disable
-break-disable ( точка-останова )+
Отключить упомянутые точки-останова. Для указанных точек-останова поле `enabled' в списке точек останова теперь установлено в `n'.
Соответствующей командой GDB является `disable'.
(gdb)
-break-disable 2
^done
(gdb)
-break-list
^done,BreakpointTable={hdr={"Num","Type","Disp","Enb","Address","What"},
bkpt={number="2",type="breakpoint",disp="keep",enabled="n",
addr="0x000100d0",func="main",file="hello.c",line="5",times="0"}}
(gdb)
-break-enable
-break-enable ( точка-останова )+
Включить (ранее отключенные) точки-останова.
Соответствующей командой GDB является `enable'.
(gdb)
-break-enable 2
^done
(gdb)
-break-list
^done,BreakpointTable={hdr={"Num","Type","Disp","Enb","Address","What"},
bkpt={number="2",type="breakpoint",disp="keep",enabled="y",
addr="0x000100d0",func="main",file="hello.c",line="5",times="0"}}
(gdb)
-break-info
-break-info точка-останова
Получить информацию об одной точке останова.
Соответствующей командой GDB является `info break точка-останова'.
Н.П.
-break-insert
-break-insert [ -t ] [ -h ] [ -r ]
[ -c условие ] [ -i счетчик-игнорирований ]
[ -p нить ] [ строка | адрес ]
Строка, если указана, может быть одной из:
Вот возможные необязательные параметры этой команды:
Результат имеет форму:
^done,bkptno="номер",func="имя-функции",
file="имя-файла",line="ном-строки"
где номер является номером этой точки останова в GDB, имя-функции---имя функции, в которой была вставлена точка останова, имя-файла---имя исходного файла, в котором находится эта функция, а ном-строки является номером строки исходного текста в этом файле.
Замечание: этот формат может изменяться.
Соответстующими командами GDB являются `break', `tbreak', `hbreak', `thbreak' и `rbreak'.
(gdb)
-break-insert main
^done,bkpt={number="1",addr="0x0001072c",file="recursive2.c",line="4"}
(gdb)
-break-insert -t foo
^done,bkpt={number="2",addr="0x00010774",file="recursive2.c",line="11"}
(gdb)
-break-list
^done,BreakpointTable={hdr={"Num","Type","Disp","Enb","Address","What"},
bkpt={number="1",type="breakpoint",disp="keep",enabled="y",
addr="0x0001072c", func="main",file="recursive2.c",line="4",times="0"},
bkpt={number="2",type="breakpoint",disp="del",enabled="y",
addr="0x00010774",func="foo",file="recursive2.c",line="11",times="0"}}
(gdb)
-break-insert -r foo.*
~int foo(int, int);
^done,bkpt={number="3",addr="0x00010774",file="recursive2.c",line="11"}
(gdb)
-break-list
-break-list
Отображает список установленных точек останова, показывая следующие поля:
Если точек останова или наблюдения нет, поле BreakpointTable является
пустым списком.
Соответствующей командой GDB является `info break'.
(gdb)
-break-list
^done,BreakpointTable={hdr={"Num","Type","Disp","Enb","Address","What"},
bkpt={number="1",type="breakpoint",disp="keep",enabled="y",
addr="0x000100d0",func="main",file="hello.c",line="5",times="0"},
bkpt={number="2",type="breakpoint",disp="keep",enabled="y",
addr="0x00010114",func="foo",file="hello.c",line="13",times="0"}}
(gdb)
Вот пример результата, когда точек останова нет:
(gdb)
-break-list
^done,BreakpointTable={}
(gdb)
-break-watch
-break-watch [ -a | -r ]
Создать точку наблюдения. С ключем `-a' будет создана точка наблюдения за доступом, то есть такая точка наблюдения, которая срабатывает либо при чтении, либо при записи в определенное местоположение в памяти. С ключем `-r' созданная точка наблюдения будет точкой наблюдения за чтением, то есть она будет срабатывать только когда к определенному местоположению в памяти осуществляется доступ на чтение. Без этих ключей будет создана обычная точка наблюдения, то есть она будет срабатывать, когда к местоположению в памяти осуществляется доступ для записи. See section Установка точек наблюдения.
Заметьте, что `-break-list' выдаст единый список установленных точек наблюдения и останова.
Соответствующими командами GDB являются `watch', `awatch' и `rwatch'.
Установка точки наблюдения за переменной в функции main:
(gdb)
-break-watch x
^done,wpt={number="2",exp="x"}
(gdb)
-exec-continue
^running
^done,reason="watchpoint-trigger",wpt={number="2",exp="x"},
value={old="-268439212",new="55"},
frame={func="main",args={},file="recursive2.c",line="5"}
(gdb)
Установка точки наблюдения за локальной переменной функции.
GDB дважды остановит выполнение программы: сначала при
изменении значения переменной, затем при выходе точки наблюдения из
области видимости.
(gdb)
-break-watch C
^done,wpt={number="5",exp="C"}
(gdb)
-exec-continue
^running
^done,reason="watchpoint-trigger",
wpt={number="5",exp="C"},value={old="-276895068",new="3"},
frame={func="callee4",args={},
file="../../../devo/gdb/testsuite/gdb.mi/basics.c",line="13"}
(gdb)
-exec-continue
^running
^done,reason="watchpoint-scope",wpnum="5",
frame={func="callee3",args={{name="strarg",
value="0x11940 \"A string argument.\""}},
file="../../../devo/gdb/testsuite/gdb.mi/basics.c",line="18"}
(gdb)
Список точек останова и наблюдения, в разных местах выполнения
программы. Заметьте, что как только точка наблюдения выходит из области
видимости, она удаляется.
(gdb)
-break-watch C
^done,wpt={number="2",exp="C"}
(gdb)
-break-list
^done,BreakpointTable={hdr={"Num","Type","Disp","Enb","Address","What"},
bkpt={number="1",type="breakpoint",disp="keep",enabled="y",
addr="0x00010734",func="callee4",
file="../../../devo/gdb/testsuite/gdb.mi/basics.c",line="8",times="1"},
bkpt={number="2",type="watchpoint",disp="keep",
enabled="y",addr="",what="C",times="0"}}
(gdb)
-exec-continue
^running
^done,reason="watchpoint-trigger",wpt={number="2",exp="C"},
value={old="-276895068",new="3"},
frame={func="callee4",args={},
file="../../../devo/gdb/testsuite/gdb.mi/basics.c",line="13"}
(gdb)
-break-list
^done,BreakpointTable={hdr={"Num","Type","Disp","Enb","Address","What"},
bkpt={number="1",type="breakpoint",disp="keep",enabled="y",
addr="0x00010734",func="callee4",
file="../../../devo/gdb/testsuite/gdb.mi/basics.c",line="8",times="1"},
bkpt={number="2",type="watchpoint",disp="keep",
enabled="y",addr="",what="C",times="-5"}}
(gdb)
-exec-continue
^running
^done,reason="watchpoint-scope",wpnum="2",
frame={func="callee3",args={{name="strarg",
value="0x11940 \"A string argument.\""}},
file="../../../devo/gdb/testsuite/gdb.mi/basics.c",line="18"}
(gdb)
-break-list
^done,BreakpointTable={hdr={"Num","Type","Disp","Enb","Address","What"},
bkpt={number="1",type="breakpoint",disp="keep",enabled="y",
addr="0x00010734",func="callee4",
file="../../../devo/gdb/testsuite/gdb.mi/basics.c",line="8",times="1"}}
(gdb)
Этот раздел описывает команды GDB/MI для управления данными: исследование памяти и регистров, вычисление выражений, и так далее.
-data-disassemble
-data-disassemble
[ -s нач-адр -e кон-адр ]
| [ -f имя-файла -l ном-строки [ -n ст ] ]
-- режим
Где:
$pc)
Вывод для каждой инструкции состоит из четырех полей:
Заметьте, что то, что включено в поле инструкции, не обрабатывается непосредственно GDB/MI, то есть изменить его формат невозможно.
Непосредственного отображения этой команды в CLI нет.
Дисассемблирование от текущего значения $pc до $pc + 20:
(gdb)
-data-disassemble -s $pc -e "$pc + 20" -- 0
^done,
asm_insns={
{address="0x000107c0",func-name="main",offset="4",
inst="mov 2, %o0"},
{address="0x000107c4",func-name="main",offset="8",
inst="sethi %hi(0x11800), %o2"},
{address="0x000107c8",func-name="main",offset="12",
inst="or %o2, 0x140, %o1\t! 0x11940 <_lib_version+8>"},
{address="0x000107cc",func-name="main",offset="16",
inst="sethi %hi(0x11800), %o2"},
{address="0x000107d0",func-name="main",offset="20",
inst="or %o2, 0x168, %o4\t! 0x11968 <_lib_version+48>"}}
(gdb)
Дисассемблирование всей функции main. Строка 32 является частью
main.
-data-disassemble -f basics.c -l 32 -- 0
^done,asm_insns={
{address="0x000107bc",func-name="main",offset="0",
inst="save %sp, -112, %sp"},
{address="0x000107c0",func-name="main",offset="4",
inst="mov 2, %o0"},
{address="0x000107c4",func-name="main",offset="8",
inst="sethi %hi(0x11800), %o2"},
[...]
{address="0x0001081c",func-name="main",offset="96",inst="ret "},
{address="0x00010820",func-name="main",offset="100",inst="restore "}}
(gdb)
Дисассемблирование 3 инструкций от начала main:
(gdb)
-data-disassemble -f basics.c -l 32 -n 3 -- 0
^done,asm_insns={
{address="0x000107bc",func-name="main",offset="0",
inst="save %sp, -112, %sp"},
{address="0x000107c0",func-name="main",offset="4",
inst="mov 2, %o0"},
{address="0x000107c4",func-name="main",offset="8",
inst="sethi %hi(0x11800), %o2"}}
(gdb)
Дисассемблирование 3 инструкций от начала main в смешаном режиме:
(gdb)
-data-disassemble -f basics.c -l 32 -n 3 -- 1
^done,asm_insns={
src_and_asm_line={line="31",
file="/kwikemart/marge/ezannoni/flathead-dev/devo/gdb/ \
testsuite/gdb.mi/basics.c",line_asm_insn={
{address="0x000107bc",func-name="main",offset="0",
inst="save %sp, -112, %sp"}}},
src_and_asm_line={line="32",
file="/kwikemart/marge/ezannoni/flathead-dev/devo/gdb/ \
testsuite/gdb.mi/basics.c",line_asm_insn={
{address="0x000107c0",func-name="main",offset="4",
inst="mov 2, %o0"},
{address="0x000107c4",func-name="main",offset="8",
inst="sethi %hi(0x11800), %o2"}}}}
(gdb)
-data-evaluate-expression
-data-evaluate-expression выраж
Вычислить выражение выраж. Выражение может содержать подчиненный вызов функции. Вызов функции быдет выполнен синхронно. Если выражение содержит пробелы, оно должно быть заключено в двойные кавычки.
Соответствующими командами GDB являются `print',
`output' и `call'. В gdbtk есть
соответствующая команда `gdb_eval'.
В следующем примере числа, предшествующие командам, суть лексемы.
Для их описания, см. section Синтаксис команд GDB/MI. Обратите внимание на то, как GDB/MI возвращает
те же лексемы в своем выводе.
211-data-evaluate-expression A
211^done,value="1"
(gdb)
311-data-evaluate-expression &A
311^done,value="0xefffeb7c"
(gdb)
411-data-evaluate-expression A+3
411^done,value="4"
(gdb)
511-data-evaluate-expression "A + 3"
511^done,value="4"
(gdb)
-data-list-changed-registers
-data-list-changed-registers
Выводит список регистров, которые изменились.
GDB не имеет прямого аналога этой команды; соответствующей
командой gdbtk является `gdb_changed_register_list'.
На плате PPC MBX:
(gdb)
-exec-continue
^running
(gdb)
*stopped,reason="breakpoint-hit",bkptno="1",frame={func="main",
args={},file="try.c",line="5"}
(gdb)
-data-list-changed-registers
^done,changed-registers={"0","1","2","4","5","6","7","8","9",
"10","11","13","14","15","16","17","18","19","20","21","22","23",
"24","25","26","27","28","30","31","64","65","66","67","69"}
(gdb)
-data-list-register-names
-data-list-register-names [ ( ном-рег )+ ]
Показать список имен регистров текущей цели. Если аргументы не заданы, показывается список имен всех регистров. Если в качестве аргументов заданы целые числа, команда напечатает список имен регистров, соответствующих аргументам.
В GDB нет команды, которая соответствует
`-data-list-register-names'. В gdbtk соответствующей
командой является `gdb_regnames'.
Для платы PPC MBX:
(gdb)
-data-list-register-names
^done,register-names={"r0","r1","r2","r3","r4","r5","r6","r7",
"r8","r9","r10","r11","r12","r13","r14","r15","r16","r17","r18",
"r19","r20","r21","r22","r23","r24","r25","r26","r27","r28","r29",
"r30","r31","f0","f1","f2","f3","f4","f5","f6","f7","f8","f9",
"f10","f11","f12","f13","f14","f15","f16","f17","f18","f19","f20",
"f21","f22","f23","f24","f25","f26","f27","f28","f29","f30","f31",
"pc","ps","cr","lr","ctr","xer"}
(gdb)
-data-list-register-names 1 2 3
^done,register-names={"r1","r2","r3"}
(gdb)
-data-list-register-values
-data-list-register-values фмт [ ( ном-рег )*]
Отобразить содержимое регистров. Фмт является форматом, в соответствии с которым должно быть возвращено содержимое регистров, за которым следует необязательный список чисел, указывающих регистры, подлежащие отображению. Отсутствие списка чисел означает, что должно быть возвращено содержимое всех регистров.
Вот допустимые форматы для фмт:
x
o
t
d
r
N
Соответствующими командами GDB являются `info reg',
`info all-reg' и (в gdbtk) `gdb_fetch_registers'.
Для платы PPC MBX (имейте ввиду: переносы строк даны только для удобства
чтения, они не появляются в реальном выводе):
(gdb)
-data-list-register-values r 64 65
^done,register-values={{number="64",value="0xfe00a300"},
{number="65",value="0x00029002"}}
(gdb)
-data-list-register-values x
^done,register-values={{number="0",value="0xfe0043c8"},
{number="1",value="0x3fff88"},{number="2",value="0xfffffffe"},
{number="3",value="0x0"},{number="4",value="0xa"},
{number="5",value="0x3fff68"},{number="6",value="0x3fff58"},
{number="7",value="0xfe011e98"},{number="8",value="0x2"},
{number="9",value="0xfa202820"},{number="10",value="0xfa202808"},
{number="11",value="0x1"},{number="12",value="0x0"},
{number="13",value="0x4544"},{number="14",value="0xffdfffff"},
{number="15",value="0xffffffff"},{number="16",value="0xfffffeff"},
{number="17",value="0xefffffed"},{number="18",value="0xfffffffe"},
{number="19",value="0xffffffff"},{number="20",value="0xffffffff"},
{number="21",value="0xffffffff"},{number="22",value="0xfffffff7"},
{number="23",value="0xffffffff"},{number="24",value="0xffffffff"},
{number="25",value="0xffffffff"},{number="26",value="0xfffffffb"},
{number="27",value="0xffffffff"},{number="28",value="0xf7bfffff"},
{number="29",value="0x0"},{number="30",value="0xfe010000"},
{number="31",value="0x0"},{number="32",value="0x0"},
{number="33",value="0x0"},{number="34",value="0x0"},
{number="35",value="0x0"},{number="36",value="0x0"},
{number="37",value="0x0"},{number="38",value="0x0"},
{number="39",value="0x0"},{number="40",value="0x0"},
{number="41",value="0x0"},{number="42",value="0x0"},
{number="43",value="0x0"},{number="44",value="0x0"},
{number="45",value="0x0"},{number="46",value="0x0"},
{number="47",value="0x0"},{number="48",value="0x0"},
{number="49",value="0x0"},{number="50",value="0x0"},
{number="51",value="0x0"},{number="52",value="0x0"},
{number="53",value="0x0"},{number="54",value="0x0"},
{number="55",value="0x0"},{number="56",value="0x0"},
{number="57",value="0x0"},{number="58",value="0x0"},
{number="59",value="0x0"},{number="60",value="0x0"},
{number="61",value="0x0"},{number="62",value="0x0"},
{number="63",value="0x0"},{number="64",value="0xfe00a300"},
{number="65",value="0x29002"},{number="66",value="0x202f04b5"},
{number="67",value="0xfe0043b0"},{number="68",value="0xfe00b3e4"},
{number="69",value="0x20002b03"}}
(gdb)
-data-read-memory
-data-read-memory [ -o смещение ]
адрес формат-слова размер-слова
число-строк число-колонок [ asсимв ]
где:
print
(see section Форматы вывода).
Эта команда отображает содержимое памяти в виде таблицы из
число-строк на число-колонок слов, причем каждое слово
занимает размер-слова байт. В общей сложности считывается
число-строк * число-колонок * размер-слова
байт (возвращается как `total-bytes'). Если цель должна возвратить
меньше запрошенного числа байт, отсутствующие слова идентифицируются при
помощи `N/A'. Число байт, прочитанное с цели, возвращается в
`nr-bytes', а начальный адрес, использованный для чтении памяти, в
`addr'.
Адрес следующей/предыдущей строки или страницы доступен в `next-row' и `prev-row', `next-page' и `prev-page'.
Соответствующей командой GDB является `x'. gdbtk
имеет команду чтения памяти `gdb_get_mem'.
Прочитать шесть байт памяти, начиная с bytes+6, но сместиться на
-6 байт. Форматировать в три ряда по две колонки. Один байт на
слово. Отображать каждое слово в шестнадцатеричном виде.
(gdb)
9-data-read-memory -o -6 -- bytes+6 x 1 3 2
9^done,addr="0x00001390",nr-bytes="6",total-bytes="6",
next-row="0x00001396",prev-row="0x0000138e",next-page="0x00001396",
prev-page="0x0000138a",memory={
{addr="0x00001390",data={"0x00","0x01"}},
{addr="0x00001392",data={"0x02","0x03"}},
{addr="0x00001394",data={"0x04","0x05"}}}
(gdb)
Прочитать два байта памяти, начиная с адреса shorts + 64 и
отобразить в виде одного слова в десятичном виде.
(gdb)
5-data-read-memory shorts+64 d 2 1 1
5^done,addr="0x00001510",nr-bytes="2",total-bytes="2",
next-row="0x00001512",prev-row="0x0000150e",
next-page="0x00001512",prev-page="0x0000150e",memory={
{addr="0x00001510",data={"128"}}}
(gdb)
Прочитать тридцать два байта памяти, начиная с bytes+16, и
форматировать на восемь рядов по четыре колонки. Включить строку,
закодированную с использованием `x' в качестве непечатного символа.
(gdb)
4-data-read-memory bytes+16 x 1 8 4 x
4^done,addr="0x000013a0",nr-bytes="32",total-bytes="32",
next-row="0x000013c0",prev-row="0x0000139c",
next-page="0x000013c0",prev-page="0x00001380",memory={
{addr="0x000013a0",data={"0x10","0x11","0x12","0x13"},ascii="xxxx"},
{addr="0x000013a4",data={"0x14","0x15","0x16","0x17"},ascii="xxxx"},
{addr="0x000013a8",data={"0x18","0x19","0x1a","0x1b"},ascii="xxxx"},
{addr="0x000013ac",data={"0x1c","0x1d","0x1e","0x1f"},ascii="xxxx"},
{addr="0x000013b0",data={"0x20","0x21","0x22","0x23"},ascii=" !\"#"},
{addr="0x000013b4",data={"0x24","0x25","0x26","0x27"},ascii="$%&'"},
{addr="0x000013b8",data={"0x28","0x29","0x2a","0x2b"},ascii="()*+"},
{addr="0x000013bc",data={"0x2c","0x2d","0x2e","0x2f"},ascii=",-./"}}
(gdb)
-display-delete
-display-delete число
Удалить элемент номер из списка выражений, подлежащих отображению.
Соответствующей командой GDB является `delete display'.
Н.П.
-display-disable
-display-disable номер
Отключить элемент номер списка выражений, подлежащих отображению.
Соответствующей командой GDB является `disable display'.
Н.П.
-display-enable
-display-enable номер
Включить элемент номер списка выражений, подлежащих отображению.
Соответствующей командой GDB является `enable display'.
Н.П.
-display-insert
-display-insert выражение
Отображать выражение всякий раз, когда программа останавливается.
Соответствующей командой GDB является `display'.
Н.П.
-display-list
-display-list
Перечислить элементы списка выражений, подлежащих автоматическому отображению. Текущие значения не показывать.
Соответствующей командой GDB является `info display'.
Н.П.
-environment-cd
-environment-cd кат
Установить рабочий каталог GDB.
Соответствующей командой GDB является `cd'.
(gdb)
-environment-cd /kwikemart/marge/ezannoni/flathead-dev/devo/gdb
^done
(gdb)
-environment-directory
-environment-directory кат
Добавить каталог кат в начало пути поиска исходных файлов.
Соответствующей командой GDB является `dir'.
(gdb)
-environment-directory /kwikemart/marge/ezannoni/flathead-dev/devo/gdb
^done
(gdb)
-environment-path
-environment-path ( кат )+
Добавить каталоги кат в начало пути поиска объектных файлов.
Соответствующей командой GDB является `path'.
(gdb)
-environment-path /kwikemart/marge/ezannoni/flathead-dev/ppc-eabi/gdb
^done
(gdb)
-environment-pwd
-environment-pwd
Показать текущий рабочий каталог.
Соответствующей командой GDB является `pwd'.
(gdb)
-environment-pwd
~Working directory /kwikemart/marge/ezannoni/flathead-dev/devo/gdb.
^done
(gdb)
В процессе выполнения, подчиненная программа может достигнуть конца, если она не встретит ни одной точки останова. В этом случае вывод будет включать код завершения, если программа завершилась ненормально.
Программа завершилась нормально:
(gdb)
-exec-run
^running
(gdb)
x = 55
*stopped,reason="exited-normally"
(gdb)
Программа завершилась ненормально:
(gdb)
-exec-run
^running
(gdb)
x = 55
*stopped,reason="exited",exit-code="01"
(gdb)
Кроме того, программа может завершиться так, как если бы она получила
сигнал, например SIGINT. В этом случае, GDB/MI отображает
следующее:
(gdb)
*stopped,reason="exited-signalled",signal-name="SIGINT",
signal-meaning="Interrupt"
-exec-abort
-exec-abort
Убить выполняющуюся подчиненную программу.
Соответствующей командой GDB является `kill'.
Н.П.
-exec-arguments
-exec-arguments арг
Установить аргументы подчиненной программы, которые должны быть использованы при следующем `-exec-run'.
Соответствующей командой GDB является `set args'.
Пока нет.
-exec-continue
-exec-continue
Асинхронная команда. Возобновляет выполнение подчиненной программы до тех пор, пока не будет встречена точка останова, или пока подчиненная программа не завершится.
Соответствующей командой GDB является `continue'.
-exec-continue
^running
(gdb)
@Hello world
*stopped,reason="breakpoint-hit",bkptno="2",frame={func="foo",args={},
file="hello.c",line="13"}
(gdb)
-exec-finish
-exec-finish
Асинхронная команда. Возобновляет выполнение подчиненной программы до тех пор, пока не завершится текущая функция. Отображает результаты, возвращенные функцией.
Соответствующей командой GDB является `finish'.
Функция, возвращающая void.
-exec-finish
^running
(gdb)
@hello from foo
*stopped,reason="function-finished",frame={func="main",args={},
file="hello.c",line="7"}
(gdb)
Функция, возвращающая что-либо отличное от void. Печатается имя
внутренней переменной GDB, хранящей результат, а также и сам
результат.
-exec-finish
^running
(gdb)
*stopped,reason="function-finished",frame={addr="0x000107b0",func="foo",
args={{name="a",value="1"},{name="b",value="9"}},
file="recursive2.c",line="14"},
gdb-result-var="$1",return-value="0"
(gdb)
-exec-interrupt
-exec-interrupt
Асинхронная команда. Прерывает фоновое исполнение цели. Заметьте, что лексема, ассоциированная с сообщением об останове, совпадает с лексемой для выполнения команды, которая была прервана. Лексема для самого прерывания появляется только в выводе `^done'. Если пользователь пытается прервать невыполняющуюся программу, будет выведено сообщение об ошибке.
Соответствующей командой GDB является `interrupt'.
(gdb)
111-exec-continue
111^running
(gdb)
222-exec-interrupt
222^done
(gdb)
111*stopped,signal-name="SIGINT",signal-meaning="Interrupt",
frame={addr="0x00010140",func="foo",args={},file="try.c",line="13"}
(gdb)
(gdb)
-exec-interrupt
^error,msg="mi_cmd_exec_interrupt: Inferior not executing."
(gdb)
-exec-next
-exec-next
Асинхронная команда. Возобновляет выполнение подчиненной программы, останавливая ее, когда достигается начало следующей строки исходного текста.
Соответствующей командой GDB является `next'.
-exec-next
^running
(gdb)
*stopped,reason="end-stepping-range",line="8",file="hello.c"
(gdb)
-exec-next-instruction
-exec-next-instruction
Асинхронная команда. Выполняет одну машинную инструкцию. Если инструкция является вызовом функции, выполнение продолжается до возврата из функции. Если программа останавливается на инструкции в середине строки исходного текста, печатается также адрес.
Соответствующей командой GDB является `nexti'.
(gdb)
-exec-next-instruction
^running
(gdb)
*stopped,reason="end-stepping-range",
addr="0x000100d4",line="5",file="hello.c"
(gdb)
-exec-return
-exec-return
Велит текущей функции немедленно вернуться. Не выполняет подчиненную программу. Отображает новый текущий кадр.
Соответствующей командой GDB является `return'.
(gdb)
200-break-insert callee4
200^done,bkpt={number="1",addr="0x00010734",
file="../../../devo/gdb/testsuite/gdb.mi/basics.c",line="8"}
(gdb)
000-exec-run
000^running
(gdb)
000*stopped,reason="breakpoint-hit",bkptno="1",
frame={func="callee4",args={},
file="../../../devo/gdb/testsuite/gdb.mi/basics.c",line="8"}
(gdb)
205-break-delete
205^done
(gdb)
111-exec-return
111^done,frame={level="0 ",func="callee3",
args={{name="strarg",
value="0x11940 \"A string argument.\""}},
file="../../../devo/gdb/testsuite/gdb.mi/basics.c",line="18"}
(gdb)
-exec-run
-exec-run
Асинхронная команда. Начинает выполнение подчиненной программы с начала. Она выполняется до тех пор, пока либо не встретится точка останова, либо программа не завершится.
Соответствующей командой GDB является `run'.
(gdb)
-break-insert main
^done,bkpt={number="1",addr="0x0001072c",file="recursive2.c",line="4"}
(gdb)
-exec-run
^running
(gdb)
*stopped,reason="breakpoint-hit",bkptno="1",
frame={func="main",args={},file="recursive2.c",line="4"}
(gdb)
-exec-show-arguments
-exec-show-arguments
Печатает аргументы программы.
Соответствующей командой GDB является `show args'.
Н.П.
-exec-step
-exec-step
Асинхронная команда. Возобновляет выполнение подчиненной программы, останавливая ее, когда будет достигнуто начало следующей строки исходного файла, при условии, что она не является вызовом функции. Если же следующая строка является вызовом функции, программа останавливается на первой инструкции этой функции.
Соответствующей командой GDB является `step'.
Пошаговый вход в функцию:
-exec-step
^running
(gdb)
*stopped,reason="end-stepping-range",
frame={func="foo",args={{name="a",value="10"},
{name="b",value="0"}},file="recursive2.c",line="11"}
(gdb)
Обычное пошаговое выполнение:
-exec-step
^running
(gdb)
*stopped,reason="end-stepping-range",line="14",file="recursive2.c"
(gdb)
-exec-step-instruction
-exec-step-instruction
Асинхронная команда. Возобновляет выполнение подчиненной программы, выполняя одну машинную инструкцию. Вывод, когда GDB остановится, будет различаться в зависимости от того, остановились мы в середине исходной строки или нет. В первом случае, адрес, по которому программа остановлена, также будет напечатан.
Соответствующей командой GDB является `stepi'.
(gdb)
-exec-step-instruction
^running
(gdb)
*stopped,reason="end-stepping-range",
frame={func="foo",args={},file="try.c",line="10"}
(gdb)
-exec-step-instruction
^running
(gdb)
*stopped,reason="end-stepping-range",
frame={addr="0x000100f4",func="foo",args={},file="try.c",line="10"}
(gdb)
-exec-until
-exec-until [ местоположение ]
Асинхронная команда. Выполняет подчиненную программу до тех пор, пока не будет достигнуто указанное в аргументе местоположение. Если аргумента нет, подчиненная программа выполняется, пока не будет достигнута строка исходного текста, превышающая текущую. В этом случае, причиной остановки будет `location-reached'.
Соответствующей командой GDB является `until'.
(gdb)
-exec-until recursive2.c:6
^running
(gdb)
x = 55
*stopped,reason="location-reached",frame={func="main",args={},
file="recursive2.c",line="6"}
(gdb)
-file-exec-and-symbols
-file-exec-and-symbols файл
Указать выполняемый файл для отладки. Это тот файл, из которого также читается таблица символов. Если файл не указан, команда очищает информацию о выполняемом файле и символах. Если при использовании этой команды без аргументов установлены точки останова, GDB выдаст сообщение об ошибке. В противном случае, никакого вывода не будет, за исключением уведомления о завершении.
Соответствующей командой GDB является `file'.
(gdb)
-file-exec-file /kwikemart/marge/ezannoni/TRUNK/mbx/hello.mbx
^done
(gdb)
-file-exec-file
-file-exec-file файл
Указать выполняемый файл для отладки. В отличие от `-file-exec-and-symbols', таблица символов не считывается из этого файла. При использовании без аргумента, GDB очищает информацию о выполняемом файле. Никакого вывода не производится, за исключением уведомления о завершении.
Соответствующей командой GDB является `exec-file'.
(gdb)
-file-exec-file /kwikemart/marge/ezannoni/TRUNK/mbx/hello.mbx
^done
(gdb)
-file-list-exec-sections
-file-list-exec-sections
Перечисляет разделы текущего выполняемого файла.
Команда GDB `info file' показывает, помимо всего прочего,
ту же информацию, что и эта команда. gdbtk имеет соответствующую
команду `gdb_load_info'.
Н.П.
-file-list-exec-source-files
-file-list-exec-source-files
Перечисляет исходные файлы для текущего выполняемого файла.
В GDB нет команды, непосредственно соответсвующей этой.
gdbtk имеет аналогичную команду `gdb_listfiles'.
Н.П.
-file-list-shared-libraries
-file-list-shared-libraries
Перечисляет используемые программой разделяемые библиотеки.
Соответствующей командой GDB является `info shared'.
Н.П.
-file-list-symbol-files
-file-list-symbol-files
Перечисляет файлы символов.
Соответствующей командой GDB является `info file' (ее часть).
Н.П.
-file-symbol-file
-file-symbol-file файл
Прочитать информацию символьной таблицы из указанного в аргументе файла. Будучи использованной без аргументов, очищиет таблицу символьной информации GDB. Никакого вывода не производится, кроме уведомления о завершении.
Соответствующей командой GDB является `symbol-file'.
(gdb)
-file-symbol-file /kwikemart/marge/ezannoni/TRUNK/mbx/hello.mbx
^done
(gdb)
-gdb-exit
-gdb-exit
Немедленно выйти из GDB.
Примерно соответствует команде `quit'.
(gdb)
-gdb-exit
-gdb-set
-gdb-set
Установить внутреннюю переменную GDB.
Соответствующей командой GDB является `set'.
(gdb)
-gdb-set $foo=3
^done
(gdb)
-gdb-show
-gdb-show
Показать текущее значение переменной GDB.
Соответствующей командой GDB является `show'.
(gdb)
-gdb-show annotate
^done,value="0"
(gdb)
-gdb-version
-gdb-version
Вывести информацию о версии GDB. Используется преимущественно при тестировании.
Эквивалентной команды GDB нет. По умолчанию, GDB показывает эту информацию, когда вы вызываете интерактивный сеанс.
(gdb)
-gdb-version
~GNU gdb 5.2.1
~Copyright 2000 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
"--host=sparc-sun-solaris2.5.1 --target=ppc-eabi".
^done
(gdb)
-stack-info-frame
-stack-info-frame
Получить информацию о текущем кадре.
Соответствующей командой GDB является `info frame' или `frame' (без аргументов).
Н.П.
-stack-info-depth
-stack-info-depth [ макс-глуб ]
Возвращает глубину стека. Если указан целочисленный аргумент макс-глуб, не считать более макс-глуб кадров.
Эквивалентной команды GDB нет.
Для стека с уровнями кадров от 0 до 11:
(gdb)
-stack-info-depth
^done,depth="12"
(gdb)
-stack-info-depth 4
^done,depth="4"
(gdb)
-stack-info-depth 12
^done,depth="12"
(gdb)
-stack-info-depth 11
^done,depth="11"
(gdb)
-stack-info-depth 13
^done,depth="12"
(gdb)
-stack-list-arguments
-stack-list-arguments показ-знач
[ нижн-кадр верхн-кадр ]
Отобразить список аргументов для кадров от нижн-кадр до верхн-кадр (включительно). Если нижн-кадр и верхн-кадр не указаны, перечислить аргументы для всего стека вызовов.
Аргумент показ-знач должен иметь значение 0 или 1. Значение 0 означает, что выводятся только имена аргументов, а 1,---что печатаются как имена, так и значения аргументов.
GDB не имеет эквивалентной команды. В gdbtk есть
команда `gdb_get_args', которая частично перекрывается с действием
`-stack-list-arguments'.
(gdb)
-stack-list-frames
^done,
stack={
frame={level="0 ",addr="0x00010734",func="callee4",
file="../../../devo/gdb/testsuite/gdb.mi/basics.c",line="8"},
frame={level="1 ",addr="0x0001076c",func="callee3",
file="../../../devo/gdb/testsuite/gdb.mi/basics.c",line="17"},
frame={level="2 ",addr="0x0001078c",func="callee2",
file="../../../devo/gdb/testsuite/gdb.mi/basics.c",line="22"},
frame={level="3 ",addr="0x000107b4",func="callee1",
file="../../../devo/gdb/testsuite/gdb.mi/basics.c",line="27"},
frame={level="4 ",addr="0x000107e0",func="main",
file="../../../devo/gdb/testsuite/gdb.mi/basics.c",line="32"}}
(gdb)
-stack-list-arguments 0
^done,
stack-args={
frame={level="0",args={}},
frame={level="1",args={name="strarg"}},
frame={level="2",args={name="intarg",name="strarg"}},
frame={level="3",args={name="intarg",name="strarg",name="fltarg"}},
frame={level="4",args={}}}
(gdb)
-stack-list-arguments 1
^done,
stack-args={
frame={level="0",args={}},
frame={level="1",
args={{name="strarg",value="0x11940 \"Строковый аргумент.\""}}},
frame={level="2",args={
{name="intarg",value="2"},
{name="strarg",value="0x11940 \"Строковый аргумент.\""}}},
{frame={level="3",args={
{name="intarg",value="2"},
{name="strarg",value="0x11940 \"Строковый аргумент.\""},
{name="fltarg",value="3.5"}}},
frame={level="4",args={}}}
(gdb)
-stack-list-arguments 0 2 2
^done,stack-args={frame={level="2",args={name="intarg",name="strarg"}}}
(gdb)
-stack-list-arguments 1 2 2
^done,stack-args={frame={level="2",
args={{name="intarg",value="2"},
{name="strarg",value="0x11940 \"Строковый аргумент.\""}}}}
(gdb)
-stack-list-frames
-stack-list-frames [ нижн-кадр верхн-кадр ]
Перечисляет кадры, находящиеся в данный момент в стеке. Для каждого кадра, команда отображает следующую информацию:
$pc для этого кадра.
$pc.
Будучи вызванной без аргументов, эта команда печатает цепочку вызовов для всего стека. Если задано два целочисленных аргумента, она показывает кадры с уровнями между этими аргументами (включительно). Если аргументы равны, она показывает один единственный кадр соответствующего уровня.
Соответствующими командами GDB являются `backtrace' и `where'.
Цепочка вызовов стека целиком:
(gdb)
-stack-list-frames
^done,stack=
{frame={level="0 ",addr="0x0001076c",func="foo",
file="recursive2.c",line="11"},
frame={level="1 ",addr="0x000107a4",func="foo",
file="recursive2.c",line="14"},
frame={level="2 ",addr="0x000107a4",func="foo",
file="recursive2.c",line="14"},
frame={level="3 ",addr="0x000107a4",func="foo",
file="recursive2.c",line="14"},
frame={level="4 ",addr="0x000107a4",func="foo",
file="recursive2.c",line="14"},
frame={level="5 ",addr="0x000107a4",func="foo",
file="recursive2.c",line="14"},
frame={level="6 ",addr="0x000107a4",func="foo",
file="recursive2.c",line="14"},
frame={level="7 ",addr="0x000107a4",func="foo",
file="recursive2.c",line="14"},
frame={level="8 ",addr="0x000107a4",func="foo",
file="recursive2.c",line="14"},
frame={level="9 ",addr="0x000107a4",func="foo",
file="recursive2.c",line="14"},
frame={level="10",addr="0x000107a4",func="foo",
file="recursive2.c",line="14"},
frame={level="11",addr="0x00010738",func="main",
file="recursive2.c",line="4"}}
(gdb)
Показать кадры между нижн-кадр и верхн-кадр:
(gdb)
-stack-list-frames 3 5
^done,stack=
{frame={level="3 ",addr="0x000107a4",func="foo",
file="recursive2.c",line="14"},
frame={level="4 ",addr="0x000107a4",func="foo",
file="recursive2.c",line="14"},
frame={level="5 ",addr="0x000107a4",func="foo",
file="recursive2.c",line="14"}}
(gdb)
Показать один кадр:
(gdb)
-stack-list-frames 3 3
^done,stack=
{frame={level="3 ",addr="0x000107a4",func="foo",
file="recursive2.c",line="14"}}
(gdb)
-stack-list-locals
-stack-list-locals печатать-значения
Вывести имена локальных переменных для текущего кадра. С параметром 0 выводит только имена переменных, с параметром 1 выводит также их значения.
`info locals' в GDB, `gdb_get_locals' в gdbtk.
(gdb)
-stack-list-locals 0
^done,locals={name="A",name="B",name="C"}
(gdb)
-stack-list-locals 1
^done,locals={{name="A",value="1"},{name="B",value="2"},
{name="C",value="3"}}
(gdb)
-stack-select-frame
-stack-select-frame ном-кадра
Изменить текущий кадр. Выбрать другой кадр ном-кадра в стеке.
Соответствующими командами GDB являются `frame', `up', `down', `select-frame', `up-silent' и `down-silent'.
(gdb)
-stack-select-frame 2
^done
(gdb)
-symbol-info-address
-symbol-info-address символ
Описать, где хранится символ.
Соответствующей командой GDB является `info address'.
Н.П.
-symbol-info-file
-symbol-info-file
Показать файл для символа.
Эквивалентной команды GDB нет. В gdbtk есть команда
`gdb_find_file'.
Н.П.
-symbol-info-function
-symbol-info-function
Показать, в какой функции находится символ.
`gdb_get_function' в gdbtk.
Н.П.
-symbol-info-line
-symbol-info-line
Показать адреса памяти кода для текущей строки.
Соответствующей командой GDB является `info line'. В
gdbtk есть команды `gdb_get_line' и `gdb_get_file'.
Н.П.
-symbol-info-symbol
-symbol-info-symbol адрес
Описать, какой символ находится в местоположении адрес.
Соответствующей командой GDB является `info symbol'.
Н.П.
-symbol-list-functions
-symbol-list-functions
Перечислить функции, находящиеся в выполняемом файле.
`info functions' в GDB, `gdb_listfunc' и
`gdb_search' в gdbtk.
Н.П.
-symbol-list-types
-symbol-list-types
Перечислить все имена типов.
Соответствующими командами являются `info types' в GDB и
`gdb_search' в gdbtk.
Н.П.
-symbol-list-variables
-symbol-list-variables
Перечислить имена всех глобальных и статических переменных.
`info variables' в GDB, `gdb_search' в gdbtk.
Н.П.
-symbol-locate
-symbol-locate
`gdb_loc' в gdbtk.
Н.П.
-symbol-type
-symbol-type переменная
Показать тип переменной.
Соответствующей командой GDB является `ptype', в
gdbtk есть команда `gdb_obj_variable'.
Н.П.
-target-attach
-target-attach ид-проц | файл
Присоединиться к процессу ид-проц или файлу файл вне GDB.
Соответствующей командой GDB является `attach'.
Н.П.
-target-compare-sections
-target-compare-sections [ раздел ]
Сравнить данные раздела раздел на цели с выполняемым файлом. Без аргумента сравниваются все разделы.
Эквивалентной командой в GDB является `compare-sections'.
Н.П.
-target-detach
-target-detach
Отсоединиться от удаленной цели. Никакого вывода не производится.
Соответствующей командой GDB является `detach'.
(gdb)
-target-detach
^done
(gdb)
-target-download
-target-download
Загружает выполняемый файл на удаленную цель. Команда два раза в секунду обновляет сообщение, которое включает поля:
Каждое сообщение посылается в виде сообщения статуса (see section Выходной синтаксис GDB/MI).
Кроме того, команда печатает имена и размеры разделов, по мере их загрузки. Эти сообщения включают следующие поля:
В конце печатается суммарная информация.
Соответствующей командой GDB является `load'.
Замечание: каждое сообщение статуса появляется на одной строке. Здесь
сообщения были разбиты на несколько строк, чтобы они могли влезть на страницу.
(gdb)
-target-download
+download,{section=".text",section-size="6668",total-size="9880"}
+download,{section=".text",section-sent="512",section-size="6668",
total-sent="512",total-size="9880"}
+download,{section=".text",section-sent="1024",section-size="6668",
total-sent="1024",total-size="9880"}
+download,{section=".text",section-sent="1536",section-size="6668",
total-sent="1536",total-size="9880"}
+download,{section=".text",section-sent="2048",section-size="6668",
total-sent="2048",total-size="9880"}
+download,{section=".text",section-sent="2560",section-size="6668",
total-sent="2560",total-size="9880"}
+download,{section=".text",section-sent="3072",section-size="6668",
total-sent="3072",total-size="9880"}
+download,{section=".text",section-sent="3584",section-size="6668",
total-sent="3584",total-size="9880"}
+download,{section=".text",section-sent="4096",section-size="6668",
total-sent="4096",total-size="9880"}
+download,{section=".text",section-sent="4608",section-size="6668",
total-sent="4608",total-size="9880"}
+download,{section=".text",section-sent="5120",section-size="6668",
total-sent="5120",total-size="9880"}
+download,{section=".text",section-sent="5632",section-size="6668",
total-sent="5632",total-size="9880"}
+download,{section=".text",section-sent="6144",section-size="6668",
total-sent="6144",total-size="9880"}
+download,{section=".text",section-sent="6656",section-size="6668",
total-sent="6656",total-size="9880"}
+download,{section=".init",section-size="28",total-size="9880"}
+download,{section=".fini",section-size="28",total-size="9880"}
+download,{section=".data",section-size="3156",total-size="9880"}
+download,{section=".data",section-sent="512",section-size="3156",
total-sent="7236",total-size="9880"}
+download,{section=".data",section-sent="1024",section-size="3156",
total-sent="7748",total-size="9880"}
+download,{section=".data",section-sent="1536",section-size="3156",
total-sent="8260",total-size="9880"}
+download,{section=".data",section-sent="2048",section-size="3156",
total-sent="8772",total-size="9880"}
+download,{section=".data",section-sent="2560",section-size="3156",
total-sent="9284",total-size="9880"}
+download,{section=".data",section-sent="3072",section-size="3156",
total-sent="9796",total-size="9880"}
^done,address="0x10004",load-size="9880",transfer-rate="6586",
write-rate="429"
(gdb)
-target-exec-status
-target-exec-status
Предоставить информацию о состоянии цели (например, выполняется она или нет).
Эквивалентной команды GDB нет.
Н.П.
-target-list-available-targets
-target-list-available-targets
Перечислить цели, к которым можно установить соединение.
Соответствующей командой GDB является `help target'.
Н.П.
-target-list-current-targets
-target-list-current-targets
Описать текущую цель.
Соответствующая информация (вместе с другой) печатается командой `info file'.
Н.П.
-target-list-parameters
-target-list-parameters
Эквивалента нет.
Н.П.
-target-select
-target-select тип параметры ...
Соединить GDB с удаленной целью. Эта команда допускает два аргумента:
Результатом является уведомление о соединении, за которым следует адрес,
по которому находится целевая программа, в следующей форме:
^connected,addr="адрес",func="имя функции",
args={список аргументов}
Соответствующей командой GDB является `target'.
(gdb)
-target-select async /dev/ttya
^connected,addr="0xfe00a300",func="??",args={}
(gdb)
-thread-info
-thread-info
Эквивалента нет.
Н.П.
-thread-list-all-threads
-thread-list-all-threads
Эквивалентной командой GDB является `info threads'.
Н.П.
-thread-list-ids
-thread-list-ids
Выводит список известных GDB в данный момент идентификаторов нитей. В конце списка также выводится общее число таких нитей.
Часть `info threads' предоставляет ту же информацию.
Кроме основного процесса нет ни одной нити:
(gdb)
-thread-list-ids
^done,thread-ids={},number-of-threads="0"
(gdb)
Несколько нитей:
(gdb)
-thread-list-ids
^done,thread-ids={thread-id="3",thread-id="2",thread-id="1"},
number-of-threads="3"
(gdb)
-thread-select
-thread-select номер-нити
Сделать нить номер-нити текущей. Команда выводит номер новой текущей нити и самый верхний кадр для нее.
Соответствующей командой GDB является `thread'.
(gdb)
-exec-next
^running
(gdb)
*stopped,reason="end-stepping-range",thread-id="2",line="187",
file="../../../devo/gdb/testsuite/gdb.threads/linux-dp.c"
(gdb)
-thread-list-ids
^done,
thread-ids={thread-id="3",thread-id="2",thread-id="1"},
number-of-threads="3"
(gdb)
-thread-select 3
^done,new-thread-id="3",
frame={level="0 ",func="vprintf",
args={{name="format",value="0x8048e9c \"%*s%c %d %c\\n\""},
{name="arg",value="0x2"}},file="vprintf.c",line="31"}
(gdb)
Команды для точек трассировки еще не реализованы.
Для реализации изменяемого отладочного окна (локальные переменные,
наблюдаемые выражения, и т.д.), мы предлагаем модификацию существующего
кода, используемого в Insight.
Вот две основные причины для этого:
Первоначальный интерейс был разработан для использование кодом Tcl, так что он был немного изменен, чтобы его можно было использовать через GDB/MI. Этот раздел описывает операции GDB/MI, которые будут доступны, и дает некоторые советы по их использованию.
Замечание: В дополнение к описанному здесь набору операций, мы ожидаем, что GUI-реализация изменяемого окна будет требовать, как минимум, следующие операции:
-gdb-show output-radix
-stack-list-arguments
-stack-list-locals
-stack-select-frame
Основной идеей изменяемых объектов является создание именованного объекта для представления переменной, выражения, местоположения в памяти или даже регистра ЦП. Для каждого созданного объекта существует набор операций для изучения или изменения его свойств.
Более того, сложные типы данных, такие как структуры Си, представлены в
древовидном формате. Например, переменная типа struct является
корнем, а потомки будут представлять элементы этой структуры. Если
потомок сам является сложным типом, он также будет иметь своих потомков.
Соответствующие различия языков учитываются для Си, Си++ и Java.
При возврате реальных значений объектов, эта возможность позволяет
отдельно выбирать формат отображения, используемый при создании
результата. Он может быть выбран из: двоичный, десятичный,
шестнадцатеричный, восьмеричный и обычный. Обычный ссылается на формат
по умолчанию, выбираемый автоматически в зависимости от типа переменной
(например, десятичный для int, шестнадцатеричный для указателей,
и т.д.).
Далее следует полный набор операций GDB/MI, определенный для доступа к этим возможностям:
| Операция | Описание |
-var-create |
создать изменяемый объект |
-var-delete |
удалить изменяемый объект и его потомков |
-var-set-format |
установить формат отображения для этой переменной |
-var-show-format |
показать формат отображения для этой переменной |
-var-info-num-children |
сообщает, сколько потомков имеет данный объект |
-var-list-children |
возвращает список потомков объекта |
-var-info-type |
показать тип этого изменяемого объекта |
-var-info-expression |
напечатать, что представляет этот изменяемый объект |
-var-show-attributes |
является ли эта переменная редактируемой? она здесь существует? |
-var-evaluate-expression |
получить значение этой переменной |
-var-assign |
установить значение этой переменной |
-var-update |
скорректировать переменную и ее потомков |
В следующем подразделе мы подробно описываем каждую операцию и предлагаем возможный способ ее использования.
-var-create
-var-create {имя | "-"}
{адрес-кадра | "*"} выражение
Данная операция создает изменяемый объект. Это позволяет наблюдать за переменной, результатом выражения, ячейкой памяти или регистром ЦП.
Параметр имя является строкой, по которой можно ссылаться на объект. Она должен быть уникальной. Если указан `-', система изменяемых объектов автоматически сгенерирует строку "varNNNNNN". Она будет уникальной, при условии, что имя не будет указано в этом формате. Команда завершается ошибкой, если найдено повторяющееся имя.
В адресе-кадра может быть задан кадр, в котором должно быть вычислено выражение. `*' указывает, что должен использоваться текущий кадр.
Выражение---это произвольное выражение, правильное в текущем наборе языков (не должно начинаться со `*'), или одно из следующего:
Эта операция возвращает имя, число потомков и тип созданного объекта.
Тип возвращается как строка, как будто она создана GDB CLI:
name="имя",numchild="N",type="тип"
-var-delete
-var-delete имя
Удаляет созданный ранее изменяемый объект и всех его потомков.
Возвращает ошибку, если объект с именем имя не найден.
-var-set-format
-var-set-format имя специф-формата
Устанавливает формат вывода в специф-формата для значения объекта имя.
Синтаксис специф-формата следующий:
специф-формата ==>
{binary | decimal | hexadecimal | octal | natural}
-var-show-format
-var-show-format имя
Возвращает формат, используемый для отображения значений объекта имя.
формат ==>
специф-формата
-var-info-num-children
-var-info-num-children имя
Возвращает число потомков изменяемого объекта с именем имя:
numchild=n
-var-list-children
-var-list-children имя
Возвращает список потомков указанного изменяемого объекта:
numchild=n,children={{name=имя,
numchild=n,type=тип},(повторяется N раз)}
-var-info-type
-var-info-type имя
Возвращает тип указанного изменяемого объекта имя. Тип
возвращается как строка в том же формате, в котором она выдается
GDB CLI:
type=имя-типа
-var-info-expression
-var-info-expression имя
Возвращает то, что представляет изменяемый объект с именем имя:
lang=специф-языка,exp=выражение
где специф-языка есть {"C" | "C++" | "Java"}.
-var-show-attributes
-var-show-attributes имя
Перечисляет атрибуты заданного изменяемого объекта имя:
status=атр [ ( ,атр )* ]
где атр есть { { editable | noneditable } | TBD }.
-var-evaluate-expression
-var-evaluate-expression имя
Вычисляет выражение, которое представлено указанным изменяемым объектом
и возвращает его значение в виде строки в текущем формате, определенном
для объекта:
value=значение
-var-assign
-var-assign имя выражение
Присваивает значение выражения изменяемому объекту, заданному именем. Объект должен быть в состоянии `editable'.
-var-update
-var-update {имя | "*"}
Обновить значение изменяемого объекта с именем имя путем вычисления его выражения, после получения всех новых значений из памяти или регистров. `*' приводит к обновлению всех существующих изменяемых объектов.
Одной проблемой, обнаруженной в существующем синтаксисе вывода
GDB/MI, была трудность в нахождении отличий между наборами вроде
этого:
{number="1",type="breakpoint",disp="keep",enabled="y"}
где каждое значение имеет уникальную метку, и таким списком:
{"1","2","4"}
{bp="1",bp="2",bp="4"}
где значения не имеют меток, или метки повторяются.
Далее представлен черновик изменений к спецификации вывода, который решает эту проблему.
Вывод GDB/MI состоит из нуля или более внеочередных записей, за которыми может следовать одна результирующая запись, причем она относится к самой последней введенной команде. Последовательность завершается `gdb'.
Асинхронный вывод GDB/MI такой же.
Каждая выходная запись, непосредственно связанная с входной командой,
начинается с префикса лексема входной команды.
вывод ==>
[ рез-запись ] "(gdb)" nl
рез-запись ==>
[ лексема ] "^" рез-класс { "," результат } nl
внеочередная-запись ==>
| поточн-запись
асинхр-запись ==>
| асинхр-вывод-статуса | асинхр-вывод-уведомл
асинхр-вывод-выполн ==>
[ лексема ] "*" асинхр-вывод
асинхр-вывод-статуса ==>
[ лексема ] "+" асинхр-вывод
асинхр-вывод-уведомл ==>
[ лексема ] "=" асинхр-вывод
асинхр-вывод ==>
результ-класс ==>
| "running" | "connected" | "error" | "exit"
асинхр-класс ==>
| другое по необходимости, т.к. находится в
стадии разработки
результат ==>
значение ==>
| набор | список
набор ==>
| "{" результат { "," результат } "}"
список ==>
[]" | "[" значение { "," значение } "]"
строка ==>
строка-си ==>
поточн-запись ==>
| целев-поточн-вывод | журн-поточн-вывод
консольн-поточн-вывод ==>
целев-поточн-вывод ==>
журн-поточн-вывод ==>
nl ==>
| CR-LF
лексема ==>
Кроме того, следующее находится в стадии разработки.
запрос
Замечания:
Лексема берется из соответствующего запроса. Если
выполняющаяся команда прерывается командой -exec-interrupt,
лексема, ассоциированная с сообщением `*stopped', берется из исходной
выполнявшейся команды, а не из команды прерывания.
Go to the first, previous, next, last section, table of contents.