GDB/MI 命令总结

迈不过友情╰ 2023-09-28 18:24 4阅读 0赞

**目录**

前言

功能和目的

进入 MI命令

退出MI命令

断点命令

1.-break-info breakpoint

2.-break-after命令\_

4. -break-commands number \[ command1 ... commandN \]

5. -break-condition \[ --force \] number \[ expr \]

6.-break-delete breakpoint

7.-break-disable ( breakpoint )+

8.-break-enable ( breakpoint )+

9.-break-insert \[ -t \] \[ -h \] \[ -f \] \[ -d \] \[ -a \] \[ --qualified \] \[ -c condition \] \[ --force-condition \] \[ -i ignore-count \] \[ -p thread-id \] \[ locspec \]

10.-dprintf-insert 命令

11.-breank-list

12. -break-passcount 命令

13. -break-watch 命令

程序环境

1.-exec-arguments 命令

2. -environment-cd 命令

3.-environment-directory命令\_

4.-environment-path

5.-environment-pwd

编辑

线程

1.-thread-info

2.-thread-list-ids

3. -thread-select

Ada任务命令

1. -ada-task-info

程序执行

1.-exec-continue命令

2.-exec-finish

3.-exec-interrupt命令

4.-exec-jump命令

5.-exec-next命令

6.-exec-next-instruction命令

7.-exec-return命令

8.-exec-run命令

9.-exec-step

10.-exec-step-instruction

11.-exec-until

堆栈操作命令

1. -enable-frame-filters命令

2.-stack-info-frame命令

3.-stack-info-depth命令

4.-stack-list-arguments命令

5.-stack-list-frames

6.-stack-list-locals

7.-stack-list-variables

8.-stack-select-frame

变量对象

1.-enable-pretty-printing

2.-var-create

3.-var-delete

4.-var-set-format

5.-var-show-format

6.-var-info-num-children

7.-var-list-children

8.-var-info-type

9.-var-info-expression

10.-var-info-path-expression

11.-var-show-attributes

12.-var-evaluate-expression

13.-var-assign

14.-var-update

15.-var-set-frozen

16.-var-set-update-range

17.-var-set-visualizer

数据操作

1.-data-disassemble命令

2.-data-evaluate-expression

3.-data-list-changed-registers

4.-data-list-register-names命令

5.-data-list-register-values

6.-data-read-memory命令

7.-data-read-memory-bytes命令

8.-data-write-memory-bytes

跟踪点命令

1.-trace-find

2.-trace-define-variable

3. -trace-frame-collected

4.-trace-list-variables

5.-trace-save

6.-trace-start

7.-trace-status

8.-trace-stop

符号命令

1. -symbol-info-functions

2.-symbol-info-module-functions命令

3.-symbol-info-module-variables命令

4. -symbol-info-modules

5. -symbol-info-types

6.-symbol-info-variables

7.-symbol-list-lines

文件命令

1.-file-exec-and-symbols Command

2.-file-exec-file Command

3.-file-list-exec-source-file

5. -file-list-exec-source-files

6. -file-list-shared-libraries

7.-file-symbol-file

目标操作命令

1.-target-attach

2.-target-detach

3.-target-disconnect

4.-target-download

5.-target-flash-erase

6.-target-select

文件传输命令

1.-target-file-put Command

2.-target-file-get Command

3. -target-file-delete

--------------------

### 前言 ###

最近在接触gdb相关知识，自然就了解下MI命令，网上资料太少，很多也不是特别明白。ps：我之前是做web开发的，转行做嵌入式开发，很多东西就很懵。此文就记录下我学习MI命令的过程。

### 功能和目的 ###

GDB/MI是 GDB 的基于行的面向机器的文本界面， 通过指定使用 --interpreter命令行选项，它专门用于支持将调试器用作较大系统的一个小组件的系统的开发。（我也不是很明白）

网上也有人说：主要目的是为一些目标系统如IDE等提供调试功能，如[eclipse][]下c/c++的cdt插件的底层就是调用的mi层命令，cdt的包里面有两个类RxThread,TxThread就是一个发送mi命令，一个接收返回数据的。

有一点我是明确的，MI命令一般与gdb的命令有一个映射关系，输出格式不如CLI输出直观。

### **进入 MI命令** ###

**gdb --interpreter mi 运行程序如：gdb --interpreter mi a.exe**

![2da8b9a92e7a46cf8b566f748d909a6a.png][]

也可以简写： gdb -i mi a.exe 或 gdb -i=mi a.exe

![95ea1cea6b954038baab691d67e1c50d.png][]

总是进入方式多多，与CLI命令指示指定参数 ，CLI默认的就是 -i=console，如图：

![c3a7cfce234642b98f61f2175b56bc64.png][]

### 退出MI命令 ###

和CLI命令一样，quit 或者 q 或者使用MI命令-gdb-exit都行。

![01bae68717be479793dbfcdac4429829.png][]

暂时感觉，很多CLI命令在MI命令中也能用，只是输出格式不一样。

### 断点命令 ###

我还是说说我的c文件内容吧

#include "stdio.h"
    
    // main() 是程序开始执行的地方
     
    int main()
    {
    	int count =0;
        //就是简单的循环打印
       for(int i =0;i<10;i++)
       {
    	   count++;
    	   printf("Hello: %d\n",count);
       }
       return 0;
    }

通过gcc -g hell.c 命令，得到的a.exe

#### **1.-break-info breakpoint** ####

单个断点信息

输出结果是个断点信息表，字段详情参考[断点信息表详情][Link 1]

![6b3a27edffd2439388c3a94dbe987491.png][]

#### **`2.-break-after`命令\_** ####

\-break-after 断点编号 计数

断点编号只有在被命中计数次数后才会生效

对应的GDB命令是 ignore

-break-after 3 3

标识断点3忽略三次，第四次才执行

![c2e898ed91c94a2f81be12f8bf6b8bd5.png][]

执行run，执行了三次hello然后被拦截

![d07a895e15914b23998f644afbc6f3e6.png][]

#### **4. -break-commands number \[ command1 ... commandN \]** ####

让GDB在每次到达某一断点时自动执行一组命令。

对应GDB命令 commands

\-break-commands 3 "print 66"

![f77cadf6488a4d9d859b2de5368c7b83.png][]

#### **5. -break-condition \[ --force \] number \[ expr \]** ####

只有当expr中的条件为真时，断点号才会停止程序

\-break-condition 3 count==5

![b026cffb05384b82840c4554714e99bf.png][]

#### **6.-break-delete breakpoint**  ####

删除断点

\--break-delete 3

只是多个断点同时删除，用空格隔开断点编号

\--break-delete 4 5

禁用和启用断点都支持

#### **`7.-break-disable`( breakpoint )+** ####

`禁用断点`

\-break-disable 2

(gdb)
    -break-disable 2
    ^done
    (gdb)
    -break-list
    ^done,BreakpointTable={nr_rows="1",nr_cols="6",
    hdr=[{width="3",alignment="-1",col_name="number",colhdr="Num"},
    {width="14",alignment="-1",col_name="type",colhdr="Type"},
    {width="4",alignment="-1",col_name="disp",colhdr="Disp"},
    {width="3",alignment="-1",col_name="enabled",colhdr="Enb"},
    {width="10",alignment="-1",col_name="addr",colhdr="Address"},
    {width="40",alignment="2",col_name="what",colhdr="What"}],
    body=[bkpt={number="2",type="breakpoint",disp="keep",enabled="n",
    addr="0x000100d0",func="main",file="hello.c",fullname="/home/foo/hello.c",
    line="5",thread-groups=["i1"],times="0"}]}
    (gdb)

#### **8.-break-enable ( breakpoint )+** ####

`启用断点`

\-break-enable 2

(gdb)
    -break-enable 2
    ^done
    (gdb)
    -break-list
    ^done,BreakpointTable={nr_rows="1",nr_cols="6",
    hdr=[{width="3",alignment="-1",col_name="number",colhdr="Num"},
    {width="14",alignment="-1",col_name="type",colhdr="Type"},
    {width="4",alignment="-1",col_name="disp",colhdr="Disp"},
    {width="3",alignment="-1",col_name="enabled",colhdr="Enb"},
    {width="10",alignment="-1",col_name="addr",colhdr="Address"},
    {width="40",alignment="2",col_name="what",colhdr="What"}],
    body=[bkpt={number="2",type="breakpoint",disp="keep",enabled="y",
    addr="0x000100d0",func="main",file="hello.c",fullname="/home/foo/hello.c",
    line="5",thread-groups=["i1"],times="0"}]}
    (gdb)

#### **9.-break-insert \[ -t \] \[ -h \] \[ -f \] \[ -d \] \[ -a \] \[ --qualified \]   \[ -c condition \] \[ --force-condition \] \[ -i ignore-count \]   \[ -p thread-id \] \[ locspec \]** ####

指定locspec类型：

**线路规格位置：**

*linespec*是由冒号分隔的源位置参数列表，例如文件名、函数名等。以下是指定 linespec 的所有不同方式 ：

`linenum`

指定当前源文件的行号linenum。

`-offset`

`+offset`

指定*当前*行之前或之后的行偏移线。对于命令，当前行是打印的最后一行；对于断点命令，这是在当前选定的*堆栈帧*中停止执行的行 （有关堆栈帧的描述，请参阅[Frames][]。）当用作命令中两个 linespecs 中的第二个时，它指定行偏移线从第一个 linespec 向上或向下。 `list``list`

`filename:linenum`

指定源文件filename中的linenum行。如果filename是一个相对文件名，那么它将匹配任何具有相同尾随组件的源文件名。例如，如果 文件名是 'gcc/expr.c'，那么它将匹配源文件名/build/trunk/gcc/expr.c， 但不是 /build/trunk/libcpp/expr.c或者/build/trunk/gcc/x-expr.c.

`function`

指定开始函数函数体的行。例如，在 C 语言中，这是带有左大括号的行。

默认情况下，在 C ++和 Ada 中，function被解释为在所有范围内指定名为function的所有函数。对于 C ++，这意味着在所有命名空间和类中。对于 Ada，这意味着在所有包中。

例如，假设一个程序带有名为 and的 C ++符号，这两个命令都在两个符号上都设置了断点。 `A::B::func``B::func`break funcbreak B::func

接受 linespec 的命令允许您使用 `-qualified`选项覆盖它。例如，在名为忽略任何 C ++类方法和命名空间函数的自由函数上设置断点。 break -qualified func`func``func`

请参阅[显式位置][Link 2]。

`function:label`

指定label在function中出现的行。

`filename:function`

指定 文件filename中开始函数函数体的行。当不同源文件中存在同名函数时，您只需要文件名和函数名即可避免歧义。

`label`

指定名为label的标签出现在与当前选定的堆栈帧相对应的函数中的行。如果没有当前选择的堆栈帧（例如，如果下级没有运行），那么GDB将不会搜索标签。

`-pstap|-probe-stap [objfile:[provider:]]name`

GNU /Linux 工具`SystemTap`为应用程序提供了一种嵌入静态探针的方法。有关查找和使用静态探针的更多信息，请参阅[静态探针点。][Link 3]这种形式的 linespec 指定了这种静态探针的位置。

如果给出了objfile，则只考虑来自该共享库的探测器或匹配objfile作为正则表达式的可执行文件。如果提供了提供者，则仅考虑来自该提供者的探测。如果多个探针与规范匹配，GDB将在每个探针处插入一个断点。

**明确的位置：**

‘--source filename’

位置的源文件名。需要结合--function’ 或者 ‘--line’参数

‘--function function’

函数或方法的名称。

‘--label label’

标签的名称。

‘--line lineoffset’

从位置开始的绝对或相对线偏移。

该命令可能的可选参数是：

‘-t’

临时断点。

‘-h’

硬件断点。

‘-f’

如果locspec无法解析（例如，如果它引用未知文件或函数），请创建一个挂起的断点。如果没有这个标志，GDB会报错，并且不会创建断点，如果locspec 无法解析。

‘-d’

禁用的断点。

‘-a’

当此参数与 ' 一起使用时-H'，创建一个快速跟踪点。

‘-c condition’

使断点以 condition 为条件。

‘--force-condition’

即使条件在所有断点位置都无效，也强制定义断点。

‘-i ignore-count’

初始化忽略计数。

‘-p thread-id’

将断点限制为具有指定全局 thread-id的线程。

‘--qualified’

使GDB将指定的函数名称解释为完整的完全限定名称。

例子：

//main函数创建断点

-break-insert main

//foo函数创建一个临时断点

-break-insert -t foo

(gdb)
    -break-insert main
    ^done,bkpt={number="1",addr="0x0001072c",file="recursive2.c",
    fullname="/home/foo/recursive2.c,line="4",thread-groups=["i1"],
    times="0"}
    (gdb)
    -break-insert -t foo
    ^done,bkpt={number="2",addr="0x00010774",file="recursive2.c",
    fullname="/home/foo/recursive2.c,line="11",thread-groups=["i1"],
    times="0"}
    (gdb)
    -break-list
    ^done,BreakpointTable={nr_rows="2",nr_cols="6",
    hdr=[{width="3",alignment="-1",col_name="number",colhdr="Num"},
    {width="14",alignment="-1",col_name="type",colhdr="Type"},
    {width="4",alignment="-1",col_name="disp",colhdr="Disp"},
    {width="3",alignment="-1",col_name="enabled",colhdr="Enb"},
    {width="10",alignment="-1",col_name="addr",colhdr="Address"},
    {width="40",alignment="2",col_name="what",colhdr="What"}],
    body=[bkpt={number="1",type="breakpoint",disp="keep",enabled="y",
    addr="0x0001072c", func="main",file="recursive2.c",
    fullname="/home/foo/recursive2.c,"line="4",thread-groups=["i1"],
    times="0"},
    bkpt={number="2",type="breakpoint",disp="del",enabled="y",
    addr="0x00010774",func="foo",file="recursive2.c",
    fullname="/home/foo/recursive2.c",line="11",thread-groups=["i1"],
    times="0"}]}
    (gdb)

#### **10.`-dprintf-insert 命令`** ####

**`动态打印`**

-dprintf-insert [ -t ] [ -f ] [ -d ] [ --qualified ]
        [ -c condition ] [--force-condition] [ -i ignore-count ]
        [ -p thread-id ] [ locspec ] [ format ]
        [ argument ]

可选参数含义和-break-insert 命令一样。

对应gdb命令'dprintf'。

//在foo函数打印"At foo entry\\n"

\-dprintf-insert foo "At foo entry\\n"

(gdb)
    4-dprintf-insert foo "At foo entry\n"
    4^done,bkpt={number="1",type="dprintf",disp="keep",enabled="y",
    addr="0x000000000040061b",func="foo",file="mi-dprintf.c",
    fullname="mi-dprintf.c",line="25",thread-groups=["i1"],
    times="0",script={"printf \"At foo entry\\n\"","continue"},
    original-location="foo"}
    (gdb)
    5-dprintf-insert 26 "arg=%d, g=%d\n" arg g
    5^done,bkpt={number="2",type="dprintf",disp="keep",enabled="y",
    addr="0x000000000040062a",func="foo",file="mi-dprintf.c",
    fullname="mi-dprintf.c",line="26",thread-groups=["i1"],
    times="0",script={"printf \"arg=%d, g=%d\\n\", arg, g","continue"},
    original-location="mi-dprintf.c:26"}
    (gdb)

#### 11.-breank-list ####

显示断点信息。

#### **12. `-break-passcount` 命令** ####

-break-passcount tracepoint-number passcount

对应gdb命令‘passcount’。

#### **13. `-break-watch` 命令** ####

-break-watch [ -a | -r ]

创建一个观察点 -a 它将创建一个 *访问*观察点，即在读取或写入内存位置时触发的观察点。-r创建的观察点是*读取*观察点，只有在访问内存位置进行读取时才会触发，如果没有这两个选项，则创建的观察点是常规观察点，即在访问内存位置进行写入时将触发

对应gdb命令‘watch’, ‘awatch’, and ‘rwatch’。

(gdb)
    -break-watch x
    ^done,wpt={number="2",exp="x"}
    (gdb)
    -exec-continue
    ^running
    (gdb)
    *stopped,reason="watchpoint-trigger",wpt={number="2",exp="x"},
    value={old="-268439212",new="55"},
    frame={func="main",args=[],file="recursive2.c",
    fullname="/home/foo/bar/recursive2.c",line="5",arch="i386:x86_64"}
    (gdb)

(gdb)
    -break-watch C
    ^done,wpt={number="5",exp="C"}
    (gdb)
    -exec-continue
    ^running
    (gdb)
    *stopped,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",
    fullname="/home/foo/bar/devo/gdb/testsuite/gdb.mi/basics.c",line="13",
    arch="i386:x86_64"}
    (gdb)
    -exec-continue
    ^running
    (gdb)
    *stopped,reason="watchpoint-scope",wpnum="5",
    frame={func="callee3",args=[{name="strarg",
    value="0x11940 \"A string argument.\""}],
    file="../../../devo/gdb/testsuite/gdb.mi/basics.c",
    fullname="/home/foo/bar/devo/gdb/testsuite/gdb.mi/basics.c",line="18",
    arch="i386:x86_64"}
    (gdb)

### 程序环境 ###

#### **1.`-exec-arguments 命令`** ####

-exec-arguments args
    
    设置参数，在下次程序执行时使用
    对应gdb命令‘set args’

(gdb)
    -exec-arguments -v word
    ^done
    (gdb)

#### **2. `-environment-cd 命令`** ####

-environment-cd pathdir

设置GDB的工作目录。

对应的GDB命令是‘cd’

(gdb)
    -environment-cd /kwikemart/marge/ezannoni/flathead-dev/devo/gdb
    ^done
    (gdb)

#### **3.`-environment-directory`命令\_** ####

-environment-directory [ -r ] [ pathdir ]+

将目录pathdir添加到源文件的搜索路径的开头。如果'-r' 选项时，搜索路径被重置为默认搜索路径。如果除了 ' 之外还提供了目录pathdir-r' 选项，首先重置搜索路径，然后正常添加。可以指定多个目录，以空格分隔。在单个命令中指定多个目录会导致将目录添加到搜索路径的开头，其顺序与它们在命令中出现的顺序相同。如果需要空格作为目录名称的一部分，则应在名称周围使用双引号。在命令输出中，路径将显示为由系统目录分隔符分隔。不得在任何目录名称中使用目录分隔符。如果未指定目录，则显示当前搜索路径。

对应的GDB命令是‘dir’

(gdb)
    -environment-directory /kwikemart/marge/ezannoni/flathead-dev/devo/gdb
    ^done,source-path="/kwikemart/marge/ezannoni/flathead-dev/devo/gdb:$cdir:$cwd"
    (gdb)
    -environment-directory ""
    ^done,source-path="/kwikemart/marge/ezannoni/flathead-dev/devo/gdb:$cdir:$cwd"
    (gdb)
    -environment-directory -r /home/jjohnstn/src/gdb /usr/src
    ^done,source-path="/home/jjohnstn/src/gdb:/usr/src:$cdir:$cwd"
    (gdb)
    -environment-directory -r
    ^done,source-path="$cdir:$cwd"
    (gdb)

#### **4.`-environment-path`** ####

-environment-path [ -r ] [ pathdir ]+

将目录pathdir添加到目标文件的搜索路径的开头。如果'-r' 选项时，搜索路径将重置为 gdb 启动时存在的原始搜索路径。如果除了 ' 之外还提供了目录pathdir-r' 选项，首先重置搜索路径，然后正常添加。可以指定多个目录，以空格分隔。在单个命令中指定多个目录会导致将目录添加到搜索路径的开头，其顺序与它们在命令中出现的顺序相同。如果需要空格作为目录名称的一部分，则应在名称周围使用双引号。在命令输出中，路径将显示为由系统目录分隔符分隔。不得在任何目录名称中使用目录分隔符。如果未指定目录，则显示当前路径。

对应的GDB命令是‘path’

(gdb)
    -environment-path
    ^done,path="/usr/bin"
    (gdb)
    -environment-path /kwikemart/marge/ezannoni/flathead-dev/ppc-eabi/gdb /bin
    ^done,path="/kwikemart/marge/ezannoni/flathead-dev/ppc-eabi/gdb:/bin:/usr/bin"
    (gdb)
    -environment-path -r /usr/local/bin
    ^done,path="/usr/local/bin:/usr/bin"
    (gdb)

#### **5.`-environment-pwd`** ####

当前目录

对应的GDB命令是‘`pwd` ’

### ![51da6a06d6524eeabf25f631ab5857b0.png][] ###

### 线程 ###

#### **`1.-thread-info`** ####

-thread-info [ thread-id ]

线程信息

对应的GDB命令是‘info thread’

输出结果字段解释：

由GDB分配给线程的全局数字 id 。

target-id

标识线程的特定于目标的字符串。

details

关于目标提供的线程的附加信息。它应该是人类可读的，而不是由前端解释的。此字段是可选的。

name

线程的名称。如果用户使用 `thread name`命令指定了名称，则给出该名称。否则，如果 GDB可以从目标中提取线程名称，则给出该名称。如果GDB找不到线程名称，则省略该字段。

state

线程的执行状态

frame

当前在线程中执行的堆栈帧。该字段仅在线程停止时才存在。

core

该字段的值是最后一次看到线程的处理器内核的整数。此字段是可选的。

-thread-info
    ^done,threads=[
    {id="2",target-id="Thread 0xb7e14b90 (LWP 21257)",
       frame={level="0",addr="0xffffe410",func="__kernel_vsyscall",
               args=[]},state="running"},
    {id="1",target-id="Thread 0xb7e156b0 (LWP 21254)",
       frame={level="0",addr="0x0804891f",func="foo",
               args=[{name="i",value="10"}],
               file="/tmp/a.c",fullname="/tmp/a.c",line="158",arch="i386:x86_64"},
               state="running"}],
    current-thread-id="1"
    (gdb)

#### **2.`-thread-list-ids`** ####

生成当前已知的全局GDB线程 ID 的列表。在列表的末尾，它还会打印此类线程的总数。

对应的GDB命令是‘info threads’

(gdb)
    -thread-list-ids
    ^done,thread-ids={thread-id="3",thread-id="2",thread-id="1"},
    current-thread-id="1",number-of-threads="3"
    (gdb)

#### **3. `-thread-select`** ####

-thread-select thread-id

使具有全局线程号thread-id的线程成为当前线程。它打印新的当前线程的编号，以及该线程的最顶层帧。

对应的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",arch="i386:x86_64"}
    (gdb)

### **Ada任务命令** ###

#### **1. `-ada-task-info`** ####

-ada-task-info [ task-id ]

报告有关特定 Ada 任务（如果存在 task-id参数）或所有 Ada 任务的信息。

对应的GDB命令是info tasks’

结果：

‘current’

该字段仅针对当前线程存在。它的价值是'\*’

‘id’

GDB用来引用 Ada 任务 的标识符。

‘task-id’

目标用于引用 Ada 任务的标识符。

‘thread-id’

Ada 任务对应的线程的全局线程标识符。

该字段应始终存在，因为 Ada 任务始终在线程之上实现。但是如果GDB由于任何原因找不到这个对应的线程，则省略该字段。

‘parent-id’

仅当任务由另一个任务创建时，此字段才存在。在这种情况下，它提供了父任务的 ID。

‘priority’

任务的基本优先级。

‘state’

任务的当前状态。

‘name’

任务的名称。

-ada-task-info
    ^done,tasks={nr_rows="3",nr_cols="8",
    hdr=[{width="1",alignment="-1",col_name="current",colhdr=""},
    {width="3",alignment="1",col_name="id",colhdr="ID"},
    {width="9",alignment="1",col_name="task-id",colhdr="TID"},
    {width="4",alignment="1",col_name="thread-id",colhdr=""},
    {width="4",alignment="1",col_name="parent-id",colhdr="P-ID"},
    {width="3",alignment="1",col_name="priority",colhdr="Pri"},
    {width="22",alignment="-1",col_name="state",colhdr="State"},
    {width="1",alignment="2",col_name="name",colhdr="Name"}],
    body=[{current="*",id="1",task-id="   644010",thread-id="1",priority="48",
    state="Child Termination Wait",name="main_task"}]}
    (gdb)

### 程序执行 ###

#### **1.`-exec-continue`命令** ####

-exec-continue [--reverse] [--all|--thread-group N]

恢复下级程序的执行，该程序将继续执行，直到遇到调试器停止事件。如果'- reverse' 选项被指定，执行反向恢复，直到它到达一个停止事件。停止事件可能包括

*  断点或观察点
 *  信号或异常
 *  进程的结束（或其在 ' 下的开始- 撤销’)
 *  重播日志的结束或开始（如果正在使用）。

在全停模式下，可能只恢复一个线程或所有线程，具体取决于 ' scheduler-locking' 多变的。如果 '- all' 被指定，所有线程（在所有低级）将被恢复。这 '- all' 选项在全停模式下被忽略。如果'----thread-group' 指定选项，然后恢复该线程组中的所有线程

相当于gdb命令‘continue’。

-exec-continue
    ^running
    (gdb)
    @Hello world
    *stopped,reason="breakpoint-hit",disp="keep",bkptno="2",frame={
    func="foo",args=[],file="hello.c",fullname="/home/foo/bar/hello.c",
    line="13",arch="i386:x86_64"}
    (gdb)

#### **2.`-exec-finish`** ####

-exec-finish [--reverse]

继续执行下级程序，直到退出当前函数。显示函数返回的结果。如果'- reverse' 选项被指定，恢复下级程序的反向执行，直到当前函数被调用。

相当于gdb命令‘finish’。

-exec-finish
    ^running
    (gdb)
    @hello from foo
    *stopped,reason="function-finished",frame={func="main",args=[],
    file="hello.c",fullname="/home/foo/bar/hello.c",line="7",arch="i386:x86_64"}
    (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",fullname="/home/foo/bar/recursive2.c",line="14",
    arch="i386:x86_64"},
    gdb-result-var="$1",return-value="0"
    (gdb)

#### **3.`-exec-interrupt`命令** ####

中断目标的后台执行。请注意与停止消息相关联的令牌是如何用于已被中断的执行命令的令牌。中断本身的标记仅出现在 '^完成' 输出。如果用户试图中断一个未运行的程序，则会打印一条错误消息。

请注意，当启用异步执行时，该命令与其他执行命令一样是异步的。也就是说，首先'^完成' 将打印响应，然后使用 ' 报告目标停止\*停止' 通知。

在不间断模式下，默认情况下只中断上下文线程。如果'- -all' 选项已指定。如果'\--thread-group' 选项被指定，该组中的所有线程都将被中断。

对应的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",
    fullname="/home/foo/bar/try.c",line="13",arch="i386:x86_64"}
    (gdb)
    
    (gdb)
    -exec-interrupt
    ^error,msg="mi_cmd_exec_interrupt: Inferior not executing."
    (gdb)

#### **4.`-exec-jump`命令** ####

-exec-jump locspec

跳到哪里执行

对应的GDB命令是 'jump’.

-exec-jump foo.c:10
    *running,thread-id="all"
    ^running

#### **5.`-exec-next`命令** ####

继续执行下级程序，在到达下一个源代码行的开头时停止。

\-exec-next \[--reverse\]

如果'- reverse' 选项被指定，继续反向执行下级程序，在前一个源代码行的开头停止。如果您在函数的第一行发出此命令，它将带您回到该函数的调用者，回到调用该函数的源代码行。

对应的GDB命令是 ‘**`next`**’

-exec-next
    ^running
    (gdb)
    *stopped,reason="end-stepping-range",line="8",file="hello.c"
    (gdb)

#### **6.`-exec-next-instruction`命令** ####

-exec-next-instruction [--reverse]

执行一条机器指令。如果指令是函数调用，则继续执行直到函数返回。如果程序在源代码行中间的指令处停止，地址也会被打印出来。

对应的GDB命令是 '**`nexti`**’

(gdb)
    -exec-next-instruction
    ^running
    
    (gdb)
    *stopped,reason="end-stepping-range",
    addr="0x000100d4",line="5",file="hello.c"
    (gdb)

#### **7.`-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",disp="keep",bkptno="1",
    frame={func="callee4",args=[],
    file="../../../devo/gdb/testsuite/gdb.mi/basics.c",
    fullname="/home/foo/bar/devo/gdb/testsuite/gdb.mi/basics.c",line="8",
    arch="i386:x86_64"}
    (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",
    fullname="/home/foo/bar/devo/gdb/testsuite/gdb.mi/basics.c",line="18",
    arch="i386:x86_64"}
    (gdb)

#### **8.`-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",disp="keep",bkptno="1",
    frame={func="main",args=[],file="recursive2.c",
    fullname="/home/foo/bar/recursive2.c",line="4",arch="i386:x86_64"}
    (gdb)

#### **9.`-exec-step`** ####

-exec-step [--reverse]

继续执行下级程序，如果下一个源代码行不是函数调用，则在到达下一个源代码行的开头时停止。如果是，则在被调用函数的第一条指令处停止。如果'--reverse' 选项被指定，恢复下级程序的反向执行，在先前执行的源代码行的开头停止。

对应的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",
    fullname="/home/foo/bar/recursive2.c",line="11",arch="i386:x86_64"}
    (gdb)

#### **10.`-exec-step-instruction`** ####

-exec-step-instruction [--reverse]

恢复执行一条机器指令的下级。如果'--reverse' 选项被指定，恢复劣质程序的反向执行，在先前执行的指令处停止。一旦GDB停止，输出将根据我们是否在源代码行的中间停止而有所不同。在前一种情况下，程序停止的地址也会被打印出来。

对应的GDB命令是 ‘stepi’

(gdb)
    -exec-step-instruction
    ^running
    
    (gdb)
    *stopped,reason="end-stepping-range",
    frame={func="foo",args=[],file="try.c",
    fullname="/home/foo/bar/try.c",line="10",arch="i386:x86_64"}
    (gdb)
    -exec-step-instruction
    ^running
    
    (gdb)
    *stopped,reason="end-stepping-range",
    frame={addr="0x000100f4",func="foo",args=[],file="try.c",
    fullname="/home/foo/bar/try.c",line="10",arch="i386:x86_64"}
    (gdb)

#### **11.`-exec-until`** ####

\-exec-until \[ locspec \]

执行下级直到它到达 locspec解析的地址。如果没有参数，则下级执行，直到它到达大于当前行的源行。在这种情况下停止的原因将是'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",fullname="/home/foo/bar/recursive2.c",line="6",
    arch="i386:x86_64"}
    (gdb)

### 堆栈操作命令 ###

#### **1. `-enable-frame-filters命令`** ####

`-enable-frame-filters`

GDB允许基于 Python 的帧过滤器影响与堆栈跟踪相关的 MI 命令的输出。由于无法以完全向后兼容的方式实现此功能，因此前端必须请求启用此功能。

一旦启用，此功能将无法禁用。

请注意，如果 Python 支持尚未编译到GDB中，此命令仍然会成功（并且什么也不做）。

#### **2.`-stack-info-frame`命令** ####

`-stack-info-frame`

获取有关所选框架的信息。

对应的GDB命令是 info frame’ or ‘frame’ 不带参数

(gdb)
    -stack-info-frame
    ^done,frame={level="1",addr="0x0001076c",func="callee3",
    file="../../../devo/gdb/testsuite/gdb.mi/basics.c",
    fullname="/home/foo/bar/devo/gdb/testsuite/gdb.mi/basics.c",line="17",
    arch="i386:x86_64"}
    (gdb)

#### **3.`-stack-info-depth`命令** ####

-stack-info-depth [ max-depth ]

返回堆栈的深度。如果指定了整数参数max-depth ，则不要计算超出max-depth帧数。

没有等效的GDB命令。

(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)

#### **4.`-stack-list-arguments`命令** ####

-stack-list-arguments [ --no-frame-filters ] [ --skip-unavailable ] print-values
        [ low-frame high-frame ]

显示低帧 和高帧（包括）之间的帧的参数列表。如果未提供低帧和 高帧，请列出整个调用堆栈的参数。如果两个参数相等，则在相应级别显示单个帧。如果低帧大于实际帧数，则为错误。另一方面， 高帧可能大于实际帧数，在这种情况下，只会返回现有帧。

如果print-values为 0 或`--no-values`，则仅打印变量的名称；如果是 1 或`--all-values`，也打印它们的值；如果是 2 or `--simple-values`，则打印简单数据类型的名称、类型和值，以及数组、结构和联合的名称和类型。如果`--no-frame-filters`提供了该选项，则不会执行 Python 帧过滤器。

如果`--skip-unavailable`指定了该选项，则不列出不可用的参数。但是，仍然显示部分可用的参数。

不推荐使用此命令在单个帧中获取参数，而赞成使用 '-stack-list-variables' 命令。

没有等效的GDB命令。

(gdb)
    -stack-list-frames
    ^done,
    stack=[
    frame={level="0",addr="0x00010734",func="callee4",
    file="../../../devo/gdb/testsuite/gdb.mi/basics.c",
    fullname="/home/foo/bar/devo/gdb/testsuite/gdb.mi/basics.c",line="8",
    arch="i386:x86_64"},
    frame={level="1",addr="0x0001076c",func="callee3",
    file="../../../devo/gdb/testsuite/gdb.mi/basics.c",
    fullname="/home/foo/bar/devo/gdb/testsuite/gdb.mi/basics.c",line="17",
    arch="i386:x86_64"},
    frame={level="2",addr="0x0001078c",func="callee2",
    file="../../../devo/gdb/testsuite/gdb.mi/basics.c",
    fullname="/home/foo/bar/devo/gdb/testsuite/gdb.mi/basics.c",line="22",
    arch="i386:x86_64"},
    frame={level="3",addr="0x000107b4",func="callee1",
    file="../../../devo/gdb/testsuite/gdb.mi/basics.c",
    fullname="/home/foo/bar/devo/gdb/testsuite/gdb.mi/basics.c",line="27",
    arch="i386:x86_64"},
    frame={level="4",addr="0x000107e0",func="main",
    file="../../../devo/gdb/testsuite/gdb.mi/basics.c",
    fullname="/home/foo/bar/devo/gdb/testsuite/gdb.mi/basics.c",line="32",
    arch="i386:x86_64"}]
    (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 \"A string argument.\""}]},
    frame={level="2",args=[
    {name="intarg",value="2"},
    {name="strarg",value="0x11940 \"A string argument.\""}]},
    {frame={level="3",args=[
    {name="intarg",value="2"},
    {name="strarg",value="0x11940 \"A string argument.\""},
    {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 \"A string argument.\""}]}]
    (gdb)

#### **5.`-stack-list-frames`** ####

-stack-list-frames [ --no-frame-filters low-frame high-frame ]

列出当前在堆栈中的帧。对于每一帧，它显示以下信息：

‘level’

帧号，0 为最顶层帧，即最里面的函数。

‘addr’

该`$pc`帧的值。

‘func’

函数名称。

‘file’

函数所在的源文件的文件名。

‘fullname’

函数所在的源文件的完整文件名。

‘line’

对应的行号`$pc`。

‘from’

定义此函数的共享库。仅当框架的功能未知时才给出。

‘arch’

框架的架构。

如果不带参数调用，此命令将打印整个堆栈的回溯。如果给定两个整数参数，则显示其级别介于两个参数（包括）之间的帧。如果两个参数相等，则显示相应级别的单帧。如果低帧大于实际帧数，则为错误。另一方面，高帧可能大于实际帧数，在这种情况下，只会返回现有帧。如果`--no-frame-filters`提供了该选项，则不会执行 Python 帧过滤器。

对应的GDB命令是 'backtrace' 和 'where’.

(gdb)
    -stack-list-frames
    ^done,stack=
    [frame={level="0",addr="0x0001076c",func="foo",
      file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="11",
      arch="i386:x86_64"},
    frame={level="1",addr="0x000107a4",func="foo",
      file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="14",
      arch="i386:x86_64"},
    frame={level="2",addr="0x000107a4",func="foo",
      file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="14",
      arch="i386:x86_64"},
    frame={level="3",addr="0x000107a4",func="foo",
      file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="14",
      arch="i386:x86_64"},
    frame={level="4",addr="0x000107a4",func="foo",
      file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="14",
      arch="i386:x86_64"},
    frame={level="5",addr="0x000107a4",func="foo",
      file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="14",
      arch="i386:x86_64"},
    frame={level="6",addr="0x000107a4",func="foo",
      file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="14",
      arch="i386:x86_64"},
    frame={level="7",addr="0x000107a4",func="foo",
      file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="14",
      arch="i386:x86_64"},
    frame={level="8",addr="0x000107a4",func="foo",
      file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="14",
      arch="i386:x86_64"},
    frame={level="9",addr="0x000107a4",func="foo",
      file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="14",
      arch="i386:x86_64"},
    frame={level="10",addr="0x000107a4",func="foo",
      file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="14",
      arch="i386:x86_64"},
    frame={level="11",addr="0x00010738",func="main",
      file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="4",
      arch="i386:x86_64"}]
    (gdb)

(gdb)
    -stack-list-frames 3 5
    ^done,stack=
    [frame={level="3",addr="0x000107a4",func="foo",
      file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="14",
      arch="i386:x86_64"},
    frame={level="4",addr="0x000107a4",func="foo",
      file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="14",
      arch="i386:x86_64"},
    frame={level="5",addr="0x000107a4",func="foo",
      file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="14",
      arch="i386:x86_64"}]
    (gdb)

#### **6.`-stack-list-locals`** ####

-stack-list-locals [ --no-frame-filters ] [ --skip-unavailable ] print-values

此命令已弃用，取而代之的是 '\-stack-list-variables' 命令。

(gdb)
    -stack-list-locals 0
    ^done,locals=[name="A",name="B",name="C"]
    (gdb)
    -stack-list-locals --all-values
    ^done,locals=[{name="A",value="1"},{name="B",value="2"},
      {name="C",value="{1, 2, 3}"}]
    -stack-list-locals --simple-values
    ^done,locals=[{name="A",type="int",value="1"},
      {name="B",type="int",value="2"},{name="C",type="int [3]"}]
    (gdb)

#### **7.-stack-list-variables** ####

-stack-list-variables [ --no-frame-filters ] [ --skip-unavailable ] print-values

显示所选框架的局部变量和函数参数的名称。如果 print-values为 0 或`--no-values`，则仅打印变量的名称；如果是 1 或`--all-values`，也打印它们的值；如果是 2 or `--simple-values`，则打印简单数据类型的名称、类型和值，以及数组、结构和联合的名称和类型。如果`--no-frame-filters`提供了该选项，则不会执行 Python 帧过滤器。

如果`--skip-unavailable`指定了该选项，则不列出不可用的局部变量和参数。但是，仍然会显示部分可用的参数和局部变量。

对应的GDB命令是‘frame’, ‘up’, ‘down’, ‘select-frame’, ‘up-silent’, and ‘down-silent’.

例子

(gdb)
    -stack-list-variables --thread 1 --frame 0 --all-values
    ^done,variables=[{name="x",value="11"},{name="s",value="{a = 1, b = 2}"}]
    (gdb)

#### `8.-stack-select-frame` ####

-stack-select-frame framenum

更改选定的框架。在堆栈上选择不同的帧framenum。

不推荐使用此命令以支持传递 '- 框架' 每个命令的选项。

对应的GDB命令是‘frame’, ‘up’, ‘down’, ‘select-frame’, ‘up-silent’, and ‘down-silent’.

(gdb)
    -stack-select-frame 2
    ^done
    (gdb)

### 变量对象 ###

变量对象简介：

变量对象是“面向对象”的 MI 接口，用于检查和更改表达式的值。与其他一些使用表达式的 MI 接口不同，变量对象是专门为在前端简单高效的呈现而设计的。变量对象由字符串名称标识。创建变量对象时，前端会指定该变量对象的表达式。表达式可以是简单的变量，也可以是任意复杂的表达式，甚至可以涉及 CPU 寄存器。创建变量对象后，前端可以调用其他变量对象操作——例如获取或改变变量对象的值，或者改变显示格式。

变量对象具有层次树结构。任何对应于复合类型的变量对象，例如 C 中的结构，都有许多子变量对象，例如对应于结构的每个元素。子变量对象本身可以递归地具有子变量。当我们到达叶变量对象时递归结束，叶变量对象总是具有内置类型。子变量对象仅通过显式请求创建，因此如果前端对特定变量对象的子对象不感兴趣，则不会创建子对象。

对于叶变量对象，可以将其值作为字符串获取，或者从字符串中设置值。非叶子变量对象也可以获取字符串值，但一般是字符串，只表示对象的类型，不列出其内容。不允许分配给非叶变量对象。

每次程序停止时，前端都不需要读取所有变量对象的值。相反，MI 提供了一个更新命令，该命令列出了自上次更新操作以来其值已更改的所有变量对象。这大大减少了必须传输到前端的数据量。如上所述，子变量对象是按需创建的，只有叶变量对象具有实际值。结果，gdb 将仅为前端创建的叶变量读取目标内存。

自动更新并不总是可取的。例如，前端可能希望保留某个表达式的值以供将来参考，并且永远不要更新它。再举一个例子，对于嵌入式目标，获取内存相对较慢，因此前端可能希望禁用对屏幕上不可见或“关闭”的变量的自动更新。这可以使用所谓的“冻结变量对象”来实现。这样的变量对象永远不会隐式更新。

可变对象可以是*固定*的或*浮动*的。对于固定变量对象，在创建变量对象时解析表达式，包括将标识符关联到特定变量。表达的意义永远不会改变。对于浮动变量对象，其名称出现在表达式中的变量的值每次都会在当前帧的上下文中重新计算。考虑这个例子：

void do_work(...)
    {
            struct work_state state;
    
            if (...)
               do_work(...);
    }

如果在这个函数中为该变量创建了一个固定的变量对象`state`，并且我们进入递归调用，该变量对象将`state`在顶层 `do_work`调用中报告 的值。另一方面，浮动变量对象将报告`state`当前帧中的值。

如果创建固定变量对象时指定的表达式引用局部变量，则变量对象将绑定到创建变量对象的线程和框架。当此类变量对象被更新时，GDB确保变量对象绑定到的线程/帧组合仍然存在，并在该线程/**帧的上下文中重新评估变量对象。**

#### **1.-enable-pretty-printing** ####

GDB允许基于 Python 的可视化工具影响 MI 变量对象命令的输出。但是，由于无法以完全向后兼容的方式实现此功能，因此前端必须请求启用此功能。

一旦启用，此功能将无法禁用。

请注意，如果 Python 支持尚未编译到GDB中，此命令仍然会成功（并且什么也不做）。

#### **2.-var-create** ####

-var-create {name | "-"}
        {frame-addr | "*" | "@"} expression

此操作创建一个变量对象，它允许监视变量、表达式的结果、存储单元或 CPU 寄存器。

name参数是可以引用对象的字符串。它必须是独一无二的。如果 '-' 时，varobj 系统会自动生成一个字符串“varNNNNNN”。如果没有指定该格式的名称，它将是唯一的。如果发现重复名称，该命令将失败。

可以通过frame-addr指定应在其下评估表达式的框架。一个 '\*' 表示应该使用当前帧。一个 '@' 表示必须创建一个浮动变量对象。

表达式是在当前语言集上有效的任何表达式（不能以'开头\*')，或以下之一：

*  ‘\*addr'，其中addr是存储单元的地址
 *  ‘\*addr-addr' — 内存地址范围 (TBD)
 *  ‘$regname' — CPU 寄存器名称

结果

此操作返回新创建的 varobj 的属性。这些是：

‘name’

varobj 的名称。

‘numchild’

varobj 的子对象数。对于动态 varobj，此数字不一定可靠。相反，您必须检查 '有更多' 属性。

‘value’

varobj 的标量值。对于类型是某种聚合（例如 a `struct`）的 varobj 或对于动态 varobj，此值将不有趣。

‘type’

varobj 的类型。这是类型的字符串表示，将由GDB CLI 打印。如果 '打印对象' （参见[set print object][]）设置为`on`，则显示对象的 *实际*（派生）类型而不是 *声明*的类型。

‘thread-id’

如果变量对象绑定到特定线程，那么这是线程的全局标识符。

‘has\_more’

对于动态 varobj，这表明是否有任何可用的子级。对于非动态 varobj，这将为 0。

‘dynamic’

此属性将存在并具有值 '1' 如果 varobj 是动态 varobj。如果 varobj 不是动态 varobj，则该属性将不存在。

‘displayhint’

动态 varobj 可以为前端提供显示提示。该值直接来自 Python 漂亮打印机对象的 `display_hint`方法。请参阅[漂亮的打印 API][API]。

#### **3.-var-delete** ####

\-var-delete \[ -c \] name

删除先前创建的变量对象及其所有子对象。随着'-C' 选项，只是删除孩子。

如果找不到 对象名称，则返回错误。

#### **4.-var-set-format** ####

-var-set-format name format-spec

将对象名称的值的输出格式设置为format -spec。

format-spec →
     {binary | decimal | hexadecimal | octal | natural | zero-hexadecimal}

自然格式是根据变量类型自动选择的默认格式（如十进制表示 a `int`，十六进制表示指针等）。

零十六进制格式的表示类似于十六进制，但在值的左侧填充零。例如，32 位十六进制值 0x1234 将以零十六进制格式表示为 0x00001234。

对于有子级的变量，格式只设置在变量本身上，子级不受影响。

#### **5.`-var-show-format`** ####

-var-show-format name

返回用于显示对象名称值的格式。

format →
     format-spec

#### **6.-var-info-num-children** ####

-var-info-num-children name

返回变量对象名称的子项数：

numchild=n

请注意，对于动态 varobj，此数字并不完全可靠。它将返回当前的子节点数，但可能有更多的子节点可用。

#### **7.-var-list-children** ####

-var-list-children [print-values] name [from to]

返回指定变量对象的子项列表，并为它们创建变量对象（如果它们尚不存在）。使用单个参数或者如果print-values的值为 0 或 `--no-values`，则仅打印变量的名称；如果 print-values是 1 或`--all-values`，也打印它们的值；如果是 2，或者`--simple-values`打印简单数据类型的名称和值，以及数组、结构和联合的名称。

from和to，如果指定，指示要报告的孩子的范围。如果from或to小于零，则重置范围并报告所有子项。否则，将报告 从（从零开始）到不包括to的孩子。

如果请求子范围，它只会影响对 的当前调用 `-var-list-children`，而不会影响对 的未来调用`-var-update`。为此，您必须改为使用`-var-set-update-range`. 这种方法的目的是使前端能够实现它喜欢的任何更新方法；例如，滚动视图可能会导致前端使用 请求更多子项`-var-list-children`，然后前端可以`-var-set-update-range`使用不同的范围进行调用，以确保将来的更新仅限于可见项。

对于每个孩子，将返回以下结果：

name

为此孩子创建的变量对象的名称。

exp

前端显示给用户的表示这个孩子的表达式。例如，这可能是结构成员的名称。

对于动态 varobj，此值不能用于形成表达式。使用动态 varobj 根本无法做到这一点。

对于 C/C ++结构，有几个伪子返回以指定访问限定符。对于这些伪孩子exp是 ‘public’, ‘private’, or ‘protected’。在这种情况下，类型和值不存在。

无论语言如何，动态 varobj 都不会报告访问限定伪子项。动态 varobj 根本不提供此信息。

numchild

这个孩子有几个孩子。对于动态 varobj，这将为 0。

type

孩子的类型。如果 '打印对象' （参见[set print object][]）设置为`on`，则显示对象的 *实际*（派生）类型而不是 *声明*的类型。

value

如果请求了值，这就是值。

thread-id

如果此变量对象与线程相关联，则这是线程的全局线程 ID。否则此结果不存在。

frozen

如果变量对象被冻结，则该变量的值为 1。

displayhint

动态 varobj 可以为前端提供显示提示。该值直接来自 Python 漂亮打印机对象的 `display_hint`方法。请参阅[漂亮的打印 API][API]。

dynamic

此属性将存在并具有值 '1' 如果 varobj 是动态 varobj。如果 varobj 不是动态 varobj，则该属性将不存在。

结果可能有自己的属性：

‘displayhint’

动态 varobj 可以为前端提供显示提示。该值直接来自 Python 漂亮打印机对象的 `display_hint`方法。请参阅[漂亮的打印 API][API]。

‘has\_more’

这是一个整数属性，如果在所选范围结束后还有剩余子项，则该属性为非零。

#### **8.-var-info-type** ####

-var-info-type name

返回指定变量名的类型。

#### **9.-var-info-expression** ####

-var-info-expression name

返回适合在用户界面中呈现此变量对象的字符串。该字符串通常不是当前语言中的有效表达式，并且无法计算。

例如，如果`a`是一个数组，并且 `A`为 创建了变量对象`a`，那么我们将得到以下输出：

(gdb) -var-info-expression A.1
    ^done,lang="C",exp="1"

这里， 的值`lang`是语言名称，可以在[Supported Languages][]中找到。

请注意，该`-var-list-children`命令的输出还包括这些表达式，因此该`-var-info-expression`命令的用途有限。

#### **10.-var-info-path-expression** ####

-var-info-path-expression name

返回一个可以在当前上下文中计算的表达式，并将产生与变量对象相同的值。将此与`-var-info-expression`命令进行比较，该命令的结果只能用于 UI 呈现。该命令的典型用途`-var-info-path-expression`是从变量对象创建观察点。

此命令当前对动态 varobj 的子级无效，并且在调用一个时会出错。

例如，假设`C`是一个从 class 派生的 C ++类 `Base`，并且`Base`该类有一个名为 的成员 `m_size`。假设一个变量`c`的类型是 并且为变量创建了 `C`一个变量对象。然后，我们将得到以下输出： `C``c`

(gdb) -var-info-path-expression C.Base.public.m_size
    ^done,path_expr=((Base)c).m_size)

#### **11.-var-show-attributes** ####

-var-show-attributes name

列出指定变量对象名称的属性：

status=attr [ ( ,attr )* ]

#### **12.-var-evaluate-expression** ####

-var-evaluate-expression [-f format-spec] name

计算由指定变量对象表示的表达式并将其值作为字符串返回。字符串的格式可以用'指定-F' 选项。此选项的可能值与 for 相同`-var-set-format` （请参阅[\-var-set-format][-var-set-format]）。如果'-F' 未指定选项，将使用当前显示格式。可以使用`-var-set-format`命令更改当前显示格式。

value=value

请注意，必须先调用`-var-list-children`变量，然后才能评估子变量的值。

#### **13.-var-assign** ####

-var-assign name expression

将表达式的值赋给由name指定的变量对象。对象必须是 '可编辑'。如果变量的值被赋值改变，该变量将显示在任何后续`-var-update`列表中。

#### **14.-var-update** ####

-var-update [print-values] {name | "*"}

重新计算变量对象名称及其所有直接和间接子对象对应的表达式 ，并返回值发生变化的变量对象列表；name必须是根变量对象。这里的“改变”是指 `-var-evaluate-expression`前后 的结果`-var-update`不同。如果 '\*' 用作变量对象名称，所有现有的变量对象都会更新，除了冻结的对象（参见[\-var-set-frozen][-var-set-frozen]）。选项 print-values确定是同时打印名称和值，还是只打印名称。此选项的可能值与 for 相同`-var-list-children`（请参阅[\-var-list-children][-var-list-children]）。建议使用'--所有值' 选项，以减少每次程序停止所需的 MI 命令数。

随着'\*' 参数，如果变量对象绑定到当前正在运行的线程，它不会被更新，没有任何诊断。

如果`-var-set-update-range`以前在 varobj 上使用过，则只会报告选定范围的子项。

`-var-update`在名为 ' 的元组中报告所有更改的 varobjs更改列表’.

更改列表中的每个项目本身就是一个元组：

‘name’

varobj 的名称。

‘value’

如果为此更新请求了值，则该字段将存在并保存 varobj 的值。

‘in\_scope’

该字段是一个字符串，可以采用以下三个值之一：

`"true"`

变量对象的当前值是有效的。

`"false"`

变量对象当前不包含有效值，但如果其关联的表达式回到范围内，它可能会在将来包含一个有效值。

`"invalid"`

变量对象不再包含有效值。当被调试的可执行文件通过重新编译或使用GDB `file` 命令发生更改时，可能会发生这种情况。前端通常应该选择删除这些变量对象。

将来可能会在此列表中添加新值，因此应为这种可能性做好准备。请参阅[GDB/MI开发和前端][GDB_MI]。

‘type\_changed’

仅当 varobj 仍然有效时才存在。如果类型改变了，那么这将是字符串 '真的'; 否则它将是'错误的’.

当 varobj 的类型发生变化时，它的子代也可能变得不正确。因此，当该属性为 ' 时，会自动删除 varobj 的子项真的'。此外，当使用`-var-set-update-range`命令设置时，varobj 的更新范围是未设置的。

‘new\_type’

如果 varobj 的类型发生变化，则该字段将出现并保存新类型。

‘new\_num\_children’

对于动态 varobj，如果子项的数量发生了变化，或者类型发生了变化，这将是新的子项数量。

这 'numchild' 其他 varobj 响应中的字段通常对动态 varobj 无效——它会显示 GDB知道的子代数，但由于动态 varobj 会延迟实例化其子代，这不会反映可用的子代数。

这 'new\_num\_children' 属性只报告GDB已知的子节点数量的变化。这是检测更新是否已删除子项的唯一方法（这必然只能在更新范围的末尾发生）。

‘displayhint’

显示提示（如果有）。

‘has\_more’

这是一个整数值，如果在 varobj 的更新范围之外还有更多可用的子级，则该值为 1。

‘dynamic’

此属性将存在并具有值 '1' 如果 varobj 是动态 varobj。如果 varobj 不是动态 varobj，则该属性将不存在。

‘new\_children’

如果在选定的更新范围内（由 设置）将新子代添加到动态 varobj `-var-set-update-range`，则它们将列在此属性中。

#### **15.-var-set-frozen** ####

-var-set-frozen name flag

在变量对象名称上设置冻结标志。标志参数应该是' 1' 使变量冻结或 '0' 让它解冻。如果变量对象被冻结，则其自身及其任何子对象都不会被`-var-update`父变量或`-var-update *`. 只有 `-var-update`变量本身会更新其值及其子项的值。变量对象解冻后，它会被所有后续`-var-update`操作隐式更新。解冻变量不会更新它，只有后续 `-var-update`才会更新。

(gdb)
    -var-set-frozen V 1
    ^done
    (gdb)

#### **16.-var-set-update-range** ####

-var-set-update-range name from to

设置将来调用 `-var-update`.

from和指示要报告的孩子的范围。如果 from或to小于零，则重置范围并报告所有子项。否则，将报告 从 （从零开始）到不包括to的孩子。

(gdb)
    -var-set-update-range V 1 2
    ^done

#### **17.`-var-set-visualizer`** ####

-var-set-visualizer name visualizer

为变量 object name设置可视化工具。

可视化器是要使用的可视化器。特殊值 'None' 表示禁用任何正在使用的可视化工具。

如果不 'None'，可视化工具必须是 Python 表达式。此表达式必须计算为接受单个参数的可调用对象。 GDB将使用 varobj名称的值作为参数调用此对象（这样做是为了 CLI 和 MI 都可以使用相同的 Python 漂亮打印代码）。调用时，此对象必须返回一个符合漂亮打印接口的对象（请参阅[漂亮打印 API][API]）。

预定义函数`gdb.default_visualizer`可用于按照内置过程选择可视化工具（请参阅[选择 Pretty-Printers][Pretty-Printers]）。这是在创建 varobj 时自动完成的，因此通常不需要。

此功能仅在启用 Python 支持时可用。MI 命令`-list-features`（参见[GDB/MI 支持命令][GDB_MI 1]）可用于检查这一点。

重置可视化工具：

(gdb)
    -var-set-visualizer V None
    ^done

重新选择默认（基于类型）的可视化工具：

(gdb)
    -var-set-visualizer V gdb.default_visualizer
    ^done

假设SomeClass是一个可视化类。可以使用 lambda 表达式为 varobj 实例化此类：
    (gdb)
    -var-set-visualizer V "lambda val: SomeClass()"
    ^done

### 数据操作 ###

操作数据的GDB/MI命令：检查内存和寄存器、计算表达式等。

#### **`1.-data-disassemble`命令** ####

-data-disassemble
        [ -s start-addr -e end-addr ]
      | [ -a addr ]
      | [ -f filename -l linenum [ -n lines ] ]
      -- mode

参数:

‘start-addr’

是起始地址（或`$pc`）

‘end-addr’

是结束地址

‘end-addr’

是要反汇编的函数中任何位置（或名称）的地址。如果指定了地址，则围绕该地址的整个函数将被反汇编。如果指定了名称，则具有该名称的整个函数将被反汇编。

‘filename’

是要反汇编的文件名

‘linenum’

是要反汇编的行号

‘lines’

是要生产的拆卸线的数量。如果为-1，则反汇编整个函数，以防未指定end-addr。如果end-addr指定为非零值，并且 lines小于 start-addr和end-addr之间的反汇编行数，则仅显示lines行；如果行数大于 start-addr和end-addr之间的行数，则仅显示直到end-addr的行 。

‘mode’

是其中之一：

*  0 只拆机
 *  1 混合源和反汇编（已弃用）
 *  2 使用原始操作码进行反汇编
 *  3 混合源代码和带有原始操作码的反汇编（已弃用）
 *  4 混源和反汇编
 *  5 混合源代码和带有原始操作码的反汇编

不推荐使用模式 1 和 3。输出是“以源为中心”的，这在实践中没有被证明是有用的。有关命令 之间的区别 和输出的讨论，请参阅[机器代码。][Link 4]`/m``/s``disassemble`

结果

该`-data-disassemble`命令的结果将是一个名为 'asm\_insns'，此列表的内容取决于命令 使用的模式`-data-disassemble`。

对于模式 0 和 2，'asm\_insns' 列表包含具有以下字段的元组：

`address`

该指令被反汇编的地址。

`func-name`

该指令所在函数的名称。

`offset`

从 ' 开始的十进制偏移量（以字节为单位）功能名称’.

`inst`

这个'的文本反汇编地址’.

`opcodes`

该字段仅在模式 2、3 和 5 中存在。它包含 ' 的原始操作码字节安装' 场地。字节被格式化为单个字节，十六进制，地址升序，每个字节之间有一个空格。

对于模式 1、3、4 和 5，'asm\_insns' 列表包含名为 ' 的元组src\_and\_asm\_line'，每个都有以下字段：

`line`

' 中的行号文件’.

`file`

来自编译单元的文件名。这可能是绝对文件名或相对文件名，具体取决于使用的编译命令。

`fullname`

'的绝对文件名文件'。它使用源文件搜索路径（请参阅[指定源目录][Link 5]）并在解析所有符号链接后转换为规范形式。

如果未找到源文件，此字段将包含调试信息中存在的路径。

`line_asm_insn`

这是一个包含反汇编的元组列表 '线' 在 '文件'。每个元组的字段与 模式0 和 2 中的相同，所以`-data-disassemble`'地址’, ‘功能名称’, ‘抵消’, ‘安装'，以及可选的'操作码’.

请注意，任何包含在 '安装' 字段，不直接由GDB/MI操作，即无法调整其格式。

对应的GDB命令是'disassemble'

从当前值反汇编`$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)

`main`在混合模式下 从头开始反汇编 3 条指令：

(gdb)
    -data-disassemble -f basics.c -l 32 -n 3 -- 1
    ^done,asm_insns=[
    src_and_asm_line={line="31",
    file="../../../src/gdb/testsuite/gdb.mi/basics.c",
    fullname="/absolute/path/to/src/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="../../../src/gdb/testsuite/gdb.mi/basics.c",
    fullname="/absolute/path/to/src/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)

#### **2.`-data-evaluate-expression`** ####

-data-evaluate-expression expr

将expr计算为表达式。表达式可能包含劣质函数调用。函数调用将同步执行。如果表达式包含空格，则必须用双引号括起来。

对应的GDB命令是 print’, ‘output’, and ‘call’。`gdbtk`只有，有一个对应的'gdb\_eval' 命令。

在以下示例中，命令前面的数字是 [GDB/MI][GDB_MI 2][ 命令语法][GDB_MI 2]中描述的*标记*。请注意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)

#### **3.`-data-list-changed-registers`** ####

-data-list-changed-registers

显示已更改的寄存器列表。

GDB没有这个命令的直接模拟；`gdbtk` 有对应的命令'gdb\_changed\_register\_list’.

(gdb)
    -exec-continue
    ^running
    
    (gdb)
    *stopped,reason="breakpoint-hit",disp="keep",bkptno="1",frame={
    func="main",args=[],file="try.c",fullname="/home/foo/bar/try.c",
    line="5",arch="powerpc"}
    (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)

#### **4.`-data-list-register-names`命令** ####

-data-list-register-names [ ( regno )+ ]

显示当前目标的寄存器名称列表。如果没有给出参数，它会显示所有寄存器的名称列表。如果给定整数作为参数，它将打印与参数对应的寄存器名称列表。为了确保寄存器名称与其编号之间的一致性，输出列表可能包含空寄存器名称。

GDB命令

GDB没有对应于 ' 的命令-data-list-register-names'。`gdbtk`里面有对应的命令'gdb\_regnames’.

(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)

#### **5.`-data-list-register-values`** ####

-data-list-register-values
        [--skip-unavailable] fmt [ ( regno )*]

显示寄存器的内容。返回寄存器内容的格式由fmt给出，后跟一个可选的数字列表，指定要显示的寄存器。缺少数字列表表示必须返回所有寄存器的内容。该`--skip-unavailable`选项表示只返回可用的寄存器。

fmt允许的格式为：

`x`

十六进制

`o`

八进制

`t`

二进制

`d`

十进制

`r`

生的

`N`

自然

对应的GDB命令是 '信息注册’, ‘信息全部注册'，和（在`gdbtk`）'gdb\_fetch\_registers’.

(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)

#### **6.`-data-read-memory`命令** ####

此命令已弃用，请`-data-read-memory-bytes`改用。

读取 6 个字节的内存，开始于`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)

从 开始读取 32 个字节的内存，`bytes+16`并将其格式化为 8 行，每列 4 列。使用 ' 包含字符串编码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)

#### **7.`-data-read-memory-bytes`命令** ####

-data-read-memory-bytes [ -o offset ]
       address count

在哪里：

‘address ’

一个表达式，指定要读取的第一个可寻址存储单元的地址。应使用 C 约定引用包含嵌入空格的复杂表达式。

‘count’

要读取的可寻址内存单元的数量。这应该是一个整数文字。

‘offset’

相对于开始读取的地址的偏移量。这应该是一个整数文字。提供此选项是为了不需要前端首先评估地址，然后自己执行地址算术。

此命令尝试读取指定范围内的所有可访问内存区域。首先，将跳过内存映射中标记为不可读的所有区域（如果已定义）。请参阅[内存区域属性][Link 6]。其次，GDB将尝试读取剩余的区域。对于每一个，如果读取整个区域导致错误， GDB将尝试读取该区域的子集。

通常，该区域中的每个内存单元都可能可读或不可读，读取每个可读单元的唯一方法是尝试读取每个地址，这是不切实际的。因此，GDB将尝试使用二进制划分方案在区域的开头或结尾读取所有可访问的内存单元。这种启发式方法适用于跨内存映射边界进行读取。请注意，如果一个区域的可读范围既不是开头也不是结尾， GDB不会读取它。

作为命令输出的结果记录（参见[GDB/MI Result Records][GDB_MI Result Records]）包括一个名为 '记忆' 其内容是一个元组列表。每个元组代表一个成功读取的内存块，并具有以下字段：

`begin`

内存块的起始地址，十六进制文字。

`end`

内存块的结束地址，十六进制文字。

`offset`

内存块的偏移量，作为十六进制文字，相对于传递给的起始地址`-data-read-memory-bytes`。

`contents`

内存块的内容，以十六进制表示。

GDB命令

对应的GDB命令是 'X’.

(gdb)
    -data-read-memory-bytes &a 10
    ^done,memory=[{begin="0xbffff154",offset="0x00000000",
                  end="0xbffff15e",
                  contents="01000000020000000300"}]
    (gdb)

#### **8.`-data-write-memory-bytes`** ####

-data-write-memory-bytes address contents
     -data-write-memory-bytes address contents [count]

‘address ’

一个表达式，指定要写入的第一个可寻址存储单元的地址。应使用 C 约定引用包含嵌入空格的复杂表达式。

‘contents ’

要写入的十六进制编码数据。如果内容不代表整数个可寻址存储单元，则会出现错误。

‘count’

可选参数，指示要写入的可寻址内存单元的数量。如果count大于contents的长度， GDB将重复写入内容，直到填满 count内存单元。

没有相应的GDB命令。

(gdb)
    -data-write-memory-bytes &a "aabbccdd"
    ^done
    (gdb)

(gdb)
    -data-write-memory-bytes &a "aabbccdd" 16e
    ^done
    (gdb)

### 跟踪点命令 ###

#### **`1.-trace-find`** ####

-trace-find mode [parameters…]

使用由mode和 parameters定义的标准查找跟踪框架。下表列出了允许的模式及其参数。有关操作的详细信息，请参阅[tfind][]。

‘none’

不需要任何参数。停止检查跟踪帧。

‘frame-number’

需要一个整数作为参数。选择具有该索引的跟踪点框架。

‘tracepoint-number’

需要一个整数作为参数。查找与具有指定编号的跟踪点相对应的下一个跟踪帧。

‘pc’

需要一个地址作为参数。查找与指定地址处的任何跟踪点相对应的下一个跟踪帧。

‘pc-inside-range’

需要两个地址作为参数。查找与指定范围内地址处的跟踪点相对应的下一个跟踪帧。两个边界都被认为在范围内。

‘pc-outside-range’

需要两个地址作为参数。查找与指定范围外地址处的跟踪点相对应的下一个跟踪帧。两个边界都被认为在范围内。

‘line’

需要指定位置作为参数。请参阅[位置规范][Link 7]。查找与指定位置的跟踪点对应的下一个跟踪帧。

如果 'none' 作为mode传递，响应没有字段。否则，响应可能包含以下字段：

‘found’

该字段具有 '0' 或者 '1' 作为值，具体取决于是否找到了匹配的跟踪点。

‘traceframe’

找到的跟踪帧的索引。如果 '成立' 字段的值为 '1’.

‘tracepoint’

找到的跟踪点的索引。如果 '成立' 字段的值为 '1’.

‘frame’

找到的跟踪帧对应的帧的信息。仅当找到跟踪帧时才存在此字段。有关此字段的说明， 请参阅[GDB/MI 帧信息。][GDB_MI 3]

对应的GDB命令是‘tfind’

#### **2.-trace-define-variable** ####

-trace-define-variable name [ value ]

如果不存在，则创建跟踪变量名称。如果 指定了value，则将指定跟踪变量的初始值设置为该值。请注意，名称应以'开头$' 特点。

对应的GDB命令是‘tvariable’.

#### **3. `-trace-frame-collected`** ####

-trace-frame-collected
        [--var-print-values var_pval]
        [--comp-print-values comp_pval]
        [--registers-format regformat]
        [--memory-contents]

此命令返回已在特定跟踪帧收集的收集对象、寄存器名称、跟踪状态变量名称、内存范围和计算表达式的集合。命令的可选参数以不同方式影响输出格式。有关详细信息，请参阅下面的输出描述表。

报告的名称可以以正常方式用于创建 varobjs 并检查对象本身。该命令返回的项目被分类，以便清楚哪些是变量，哪些是寄存器，哪些是跟踪状态变量，哪些是内存范围，哪些是计算表达式

(gdb)
    -trace-frame-collected
    ^done,
      explicit-variables=[{name="myVar",value="1"}],
      computed-expressions=[{name="myArray[myIndex]",value="0"},
                            {name="myObj.field",value="0"},
                            {name="myPtr->field",value="1"},
                            {name="myCount + 2",value="3"},
                            {name="$tvar1 + 1",value="43970027"}],
      registers=[{number="0",value="0x7fe2c6e79ec8"},
                 {number="1",value="0x0"},
                 {number="2",value="0x4"},
                 ...
                 {number="125",value="0x0"}],
      tvars=[{name="$tvar1",current="43970026"}],
      memory=[{address="0x0000000000602264",length="4"},
              {address="0x0000000000615bc0",length="4"}]
    (gdb)

`explicit-variables`

已完整收集的对象集（而不是仅收集数组的几个元素或几个结构成员）。对于每个对象，都会打印其名称和值。该`--var-print-values`选项影响值字段的输出方式或是否输出。如果var\_pval为 0，则只打印名称；如果是 1，也打印它们的值；如果是 2，则打印简单数据类型的名称、类型和值，以及数组、结构和联合的名称和类型。

`computed-expressions`

在当前跟踪帧收集的计算表达式集。该`--comp-print-values`选项影响该集合，就像该`--var-print-values`选项影响 该集合一样`explicit-variables`。看上面。

`registers`

在当前跟踪帧收集的寄存器。对于收集的每个寄存器，返回名称和当前值。该值根据`--registers-format` 选项进行格式化。`-data-list-register-values`有关允许的格式列表，请参见命令。默认为'X’.

`tvars`

在当前跟踪帧收集的跟踪状态变量。对于收集的每个跟踪状态变量，返回名称和当前值。

`memory`

在当前跟踪帧收集的内存范围集。它的内容是一个元组列表。每个元组代表一个收集的内存范围，并具有以下字段：

`address`

内存范围的起始地址，为十六进制文字。

`length`

内存范围的起始地址，为十六进制文字。

`contents`

内存块的内容，以十六进制表示。此字段仅在`--memory-contents`指定选项时出现。

没有对应的GDB命令。

#### **4.-trace-list-variables** ####

-trace-list-variables

返回所有已定义跟踪变量的表。表的每个元素都有以下字段：

‘name’

跟踪变量的名称。该字段始终存在。

initial’

初始值。这是一个 64 位有符号整数。该字段始终存在。

‘current’

跟踪变量当前的值。这是一个 64 位有符号整数。如果未定义当前值，则此字段不存在，例如，如果跟踪从未运行过，或者当前正在运行。

tvariables

(gdb)
    -trace-list-variables
    ^done,trace-variables={nr_rows="1",nr_cols="3",
    hdr=[{width="15",alignment="-1",col_name="name",colhdr="Name"},
         {width="11",alignment="-1",col_name="initial",colhdr="Initial"},
         {width="11",alignment="-1",col_name="current",colhdr="Current"}],
    body=[variable={name="$trace_timestamp",initial="0"}
          variable={name="$foo",initial="10",current="15"}]}
    (gdb)

#### **5.-trace-save** ####

-trace-save [ -r ] [ -ctf ] filename

将收集的跟踪数据保存到filename。没有'-r' 选项，数据从目标下载并保存在本地文件中。随着'-r' 选项要求目标执行保存。

默认情况下，此命令将以 tfile 格式保存跟踪。您可以提供可选的 '-ctf' 参数以将其保存为 CTF 格式。有关 CTF 的更多信息，请参阅 [跟踪文件][Link 8]。

对应的GDB命令‘tsave’

#### **6.-trace-start** ####

-trace-start

开始追踪实验。此命令的结果没有任何字段。

对应的GDB命令是‘tstart’

#### **7.-trace-status** ####

\-trace-status

获取跟踪实验的状态。结果可能包括以下字段：

‘supported’

值可能为 '0'，当不支持跟踪操作时，'1'，当支持所有跟踪操作时，或 '文件' 在检查跟踪文件时。在后一种情况下，可以检查跟踪帧，但不能开始新的跟踪实验。该字段始终存在。

‘supported’

值可能为 '0' 或者 '1' 取决于是否在目标上进行跟踪实验。如果 '支持的'字段不是'0’.

‘stop-reason’

报告上次停止跟踪的原因。如果跟踪从未在目标上停止，则该字段可能不存在。的价值 '要求' 表示由于该`-trace-stop`命令而停止了跟踪。的价值 '溢出' 表示跟踪缓冲区已满。的价值 '断开' 表示当GDB断开连接时自动停止跟踪。的价值 '通行证' 表示当跟踪点通过该跟踪点的最大次数时停止跟踪。如果 '支持的'字段不是'0’.

‘stopping-tracepoint

超过 passcount 的跟踪点数。如果 '停止原因' 字段的值为 ‘passcount’.

‘frames’

‘frames-created’

这 '框架' 字段是跟踪缓冲区中跟踪帧总数的计数，而 '框架创建' 是运行期间创建的总数，包括被丢弃的总数，例如当循环跟踪缓冲区填满时。这两个字段都是可选的。

‘buffer-size’

‘buffer-free’

这些字段告诉跟踪缓冲区的当前大小和剩余空间。这些字段是可选的。

‘circular’

循环跟踪缓冲区标志的值。 `1`意味着跟踪缓冲区是循环的，如果需要腾出空间，旧的跟踪帧将被丢弃，`0`意味着跟踪缓冲区是线性的并且可能会被填满。

‘disconnected’

断开跟踪标志的值。 `1`表示在GDB断开连接后跟踪将继续，`0`表示跟踪运行将停止。

‘trace-file’

正在检查的跟踪文件的文件名。该字段是可选的，并且仅在检查跟踪文件时出现。

GDB命令

对应的GDB命令是 'tstatus’.

#### **8.-trace-stop** ####

\-trace-stop

停止追踪实验。此命令的结果具有与 相同的字段`-trace-status`，除了supported’ and ‘running’ 字段不输出。

对应的GDB命令是 'stop’.

### 符号命令 ###

#### **1. `-symbol-info-functions`** ####

-symbol-info-functions [--include-nondebug]
                            [--type type_regexp]
                            [--name name_regexp]
                            [--max-results limit]

返回一个列表，其中包含从调试信息中获取的所有全局函数的名称和类型。这些函数按源文件分组，并以定义每个函数的行号显示。

该`--include-nondebug`选项使输出包含符号表中的代码符号。

选项`--type`和`--name`允许根据函数的名称或函数的类型签名过滤返回的符号。

该选项`--max-results`限制命令返回不超过限制的结果。如果返回确切的限制结果，那么如果使用更高的限制，则可能会有其他结果可用。

对应的GDB命令是info functions’.

(gdb)
    -symbol-info-functions
    ^done,symbols=
      {debug=
        [{filename="/project/gdb/testsuite/gdb.mi/mi-sym-info-1.c",
          fullname="/project/gdb/testsuite/gdb.mi/mi-sym-info-1.c",
          symbols=[{line="36", name="f4", type="void (int *)",
                    description="void f4(int *);"},
                   {line="42", name="main", type="int ()",
                    description="int main();"},
                   {line="30", name="f1", type="my_int_t (int, int)",
                    description="static my_int_t f1(int, int);"}]},
         {filename="/project/gdb/testsuite/gdb.mi/mi-sym-info-2.c",
          fullname="/project/gdb/testsuite/gdb.mi/mi-sym-info-2.c",
          symbols=[{line="33", name="f2", type="float (another_float_t)",
                    description="float f2(another_float_t);"},
                   {line="39", name="f3", type="int (another_int_t)",
                    description="int f3(another_int_t);"},
                   {line="27", name="f1", type="another_float_t (int)",
                    description="static another_float_t f1(int);"}]}]}

(gdb)
    -symbol-info-functions --name f1
    ^done,symbols=
      {debug=
        [{filename="/project/gdb/testsuite/gdb.mi/mi-sym-info-1.c",
          fullname="/project/gdb/testsuite/gdb.mi/mi-sym-info-1.c",
          symbols=[{line="30", name="f1", type="my_int_t (int, int)",
                    description="static my_int_t f1(int, int);"}]},
         {filename="/project/gdb/testsuite/gdb.mi/mi-sym-info-2.c",
          fullname="/project/gdb/testsuite/gdb.mi/mi-sym-info-2.c",
          symbols=[{line="27", name="f1", type="another_float_t (int)",
                    description="static another_float_t f1(int);"}]}]}

(gdb)
    -symbol-info-functions --type void
    ^done,symbols=
      {debug=
        [{filename="/project/gdb/testsuite/gdb.mi/mi-sym-info-1.c",
          fullname="/project/gdb/testsuite/gdb.mi/mi-sym-info-1.c",
          symbols=[{line="36", name="f4", type="void (int *)",
                    description="void f4(int *);"}]}]}

(gdb)
    -symbol-info-functions --include-nondebug
    ^done,symbols=
      {debug=
        [{filename="/project/gdb/testsuite/gdb.mi/mi-sym-info-1.c",
          fullname="/project/gdb/testsuite/gdb.mi/mi-sym-info-1.c",
          symbols=[{line="36", name="f4", type="void (int *)",
                    description="void f4(int *);"},
                   {line="42", name="main", type="int ()",
                    description="int main();"},
                   {line="30", name="f1", type="my_int_t (int, int)",
                    description="static my_int_t f1(int, int);"}]},
         {filename="/project/gdb/testsuite/gdb.mi/mi-sym-info-2.c",
          fullname="/project/gdb/testsuite/gdb.mi/mi-sym-info-2.c",
          symbols=[{line="33", name="f2", type="float (another_float_t)",
                    description="float f2(another_float_t);"},
                   {line="39", name="f3", type="int (another_int_t)",
                    description="int f3(another_int_t);"},
                   {line="27", name="f1", type="another_float_t (int)",
                    description="static another_float_t f1(int);"}]}],
       nondebug=
        [{address="0x0000000000400398",name="_init"},
         {address="0x00000000004003b0",name="_start"},
          ...
        ]}

#### **2.`-symbol-info-module-functions`命令** ####

-symbol-info-module-functions [--module module_regexp]
                                   [--name name_regexp]
                                   [--type type_regexp]

返回一个列表，其中包含所有已知 Fortran 模块中所有已知函数的名称。这些函数按源文件和包含的模块分组，并以定义每个函数的行号显示。

该选项仅返回与module\_regexp`--module`匹配的模块的结果 。该选项仅返回名称与name\_regexp匹配的函数，并且仅返回类型与type\_regexp匹配的函数。 `--name``--type`

对应的GDB命令是 ‘info module functions’.

(gdb)
    -symbol-info-module-functions
    ^done,symbols=
      [{module="mod1",
        files=[{filename="/project/gdb/testsuite/gdb.mi/mi-fortran-modules-2.f90",
                fullname="/project/gdb/testsuite/gdb.mi/mi-fortran-modules-2.f90",
                symbols=[{line="21",name="mod1::check_all",type="void (void)",
                          description="void mod1::check_all(void);"}]}]},
        {module="mod2",
         files=[{filename="/project/gdb/testsuite/gdb.mi/mi-fortran-modules-2.f90",
                 fullname="/project/gdb/testsuite/gdb.mi/mi-fortran-modules-2.f90",
                 symbols=[{line="30",name="mod2::check_var_i",type="void (void)",
                           description="void mod2::check_var_i(void);"}]}]},
        {module="mod3",
         files=[{filename="/projec/gdb/testsuite/gdb.mi/mi-fortran-modules.f90",
                 fullname="/projec/gdb/testsuite/gdb.mi/mi-fortran-modules.f90",
                 symbols=[{line="21",name="mod3::check_all",type="void (void)",
                           description="void mod3::check_all(void);"},
                          {line="27",name="mod3::check_mod2",type="void (void)",
                           description="void mod3::check_mod2(void);"}]}]},
        {module="modmany",
         files=[{filename="/project/gdb/testsuite/gdb.mi/mi-fortran-modules.f90",
                 fullname="/project/gdb/testsuite/gdb.mi/mi-fortran-modules.f90",
                 symbols=[{line="35",name="modmany::check_some",type="void (void)",
                           description="void modmany::check_some(void);"}]}]},
        {module="moduse",
         files=[{filename="/project/gdb/testsuite/gdb.mi/mi-fortran-modules.f90",
                 fullname="/project/gdb/testsuite/gdb.mi/mi-fortran-modules.f90",
                 symbols=[{line="44",name="moduse::check_all",type="void (void)",
                           description="void moduse::check_all(void);"},
                          {line="49",name="moduse::check_var_x",type="void (void)",
                           description="void moduse::check_var_x(void);"}]}]}]

#### **3.`-symbol-info-module-variables`命令** ####

-symbol-info-module-variables [--module module_regexp]
                                   [--name name_regexp]
                                   [--type type_regexp]

返回一个列表，其中包含所有已知 Fortran 模块中所有已知变量的名称。变量按源文件和包含的模块分组，并以定义每个变量的行号显示。

该选项仅返回与module\_regexp`--module`匹配的模块的结果 。该选项仅返回名称与name\_regexp匹配的变量，并且仅返回类型与type\_regexp匹配的变量。 `--name``--type`

对应的GDB命令是 ‘info module variables’.

#### **4. `-symbol-info-modules`** ####

-symbol-info-modules [--name name_regexp]
                          [--max-results limit]

返回一个包含所有已知 Fortran 模块名称的列表。模块按源文件分组，并以定义每个模块的行号显示。

该选项`--name`允许根据模块名称过滤返回的模块。

该选项`--max-results`限制命令返回不超过限制的结果。如果返回确切的限制结果，那么如果使用更高的限制，则可能会有其他结果可用。

对应的GDB命令是 ‘info modules’.

(gdb)
    -symbol-info-modules
    ^done,symbols=
      {debug=
        [{filename="/project/gdb/testsuite/gdb.mi/mi-fortran-modules-2.f90",
          fullname="/project/gdb/testsuite/gdb.mi/mi-fortran-modules-2.f90",
          symbols=[{line="16",name="mod1"},
                   {line="22",name="mod2"}]},
         {filename="/project/gdb/testsuite/gdb.mi/mi-fortran-modules.f90",
          fullname="/project/gdb/testsuite/gdb.mi/mi-fortran-modules.f90",
          symbols=[{line="16",name="mod3"},
                   {line="22",name="modmany"},
                   {line="26",name="moduse"}]}]}

(gdb)
    -symbol-info-modules --name mod[123]
    ^done,symbols=
      {debug=
        [{filename="/project/gdb/testsuite/gdb.mi/mi-fortran-modules-2.f90",
          fullname="/project/gdb/testsuite/gdb.mi/mi-fortran-modules-2.f90",
          symbols=[{line="16",name="mod1"},
                   {line="22",name="mod2"}]},
         {filename="/project/gdb/testsuite/gdb.mi/mi-fortran-modules.f90",
          fullname="/project/gdb/testsuite/gdb.mi/mi-fortran-modules.f90",
          symbols=[{line="16",name="mod3"}]}]}

#### 5. `-symbol-info-types` ####

-symbol-info-types [--name name_regexp]
                        [--max-results limit]

返回所有已定义类型的列表。这些类型按源文件分组，并与定义每个用户定义类型的行号一起显示。有些基类型在源代码中没有定义，而是由编译器添加到调试信息中的，例如 `int`，`float`等；这些类型没有关联的行号。

该选项`--name`允许按名称过滤返回的类型列表。

该选项`--max-results`限制命令返回不超过限制的结果。如果返回确切的限制结果，那么如果使用更高的限制，则可能会有其他结果可用。

对应的GDB命令是info types

(gdb)
    -symbol-info-types
    ^done,symbols=
      {debug=
         [{filename="gdb.mi/mi-sym-info-1.c",
           fullname="/project/gdb/testsuite/gdb.mi/mi-sym-info-1.c",
           symbols=[{name="float"},
                    {name="int"},
                    {line="27",name="typedef int my_int_t;"}]},
          {filename="gdb.mi/mi-sym-info-2.c",
           fullname="/project/gdb.mi/mi-sym-info-2.c",
           symbols=[{line="24",name="typedef float another_float_t;"},
                    {line="23",name="typedef int another_int_t;"},
                    {name="float"},
                    {name="int"}]}]}

(gdb)
    -symbol-info-types --name _int_
    ^done,symbols=
      {debug=
         [{filename="gdb.mi/mi-sym-info-1.c",
           fullname="/project/gdb/testsuite/gdb.mi/mi-sym-info-1.c",
           symbols=[{line="27",name="typedef int my_int_t;"}]},
          {filename="gdb.mi/mi-sym-info-2.c",
           fullname="/project/gdb.mi/mi-sym-info-2.c",
           symbols=[{line="23",name="typedef int another_int_t;"}]}]}

#### 6.`-symbol-info-variables` ####

-symbol-info-variables [--include-nondebug]
                            [--type type_regexp]
                            [--name name_regexp]
                            [--max-results limit]

返回一个列表，其中包含从调试信息中获取的所有全局变量的名称和类型。变量按源文件分组，并以定义每个变量的行号显示。

该`--include-nondebug`选项使输出包含符号表中的数据符号。

选项`--type`和`--name`允许根据变量名称或变量类型过滤返回的符号。

该选项`--max-results`限制命令返回不超过限制的结果。如果返回确切的限制结果，那么如果使用更高的限制，则可能会有其他结果可用。

对应的GDB命令是 info variables’.

(gdb)
    -symbol-info-variables
    ^done,symbols=
      {debug=
        [{filename="/project/gdb/testsuite/gdb.mi/mi-sym-info-1.c",
          fullname="/project/gdb/testsuite/gdb.mi/mi-sym-info-1.c",
          symbols=[{line="25",name="global_f1",type="float",
                    description="static float global_f1;"},
                   {line="24",name="global_i1",type="int",
                    description="static int global_i1;"}]},
         {filename="/project/gdb/testsuite/gdb.mi/mi-sym-info-2.c",
          fullname="/project/gdb/testsuite/gdb.mi/mi-sym-info-2.c",
          symbols=[{line="21",name="global_f2",type="int",
                    description="int global_f2;"},
                   {line="20",name="global_i2",type="int",
                    description="int global_i2;"},
                   {line="19",name="global_f1",type="float",
                    description="static float global_f1;"},
                   {line="18",name="global_i1",type="int",
                    description="static int global_i1;"}]}]}

(gdb)
    -symbol-info-variables --name f1
    ^done,symbols=
      {debug=
        [{filename="/project/gdb/testsuite/gdb.mi/mi-sym-info-1.c",
          fullname="/project/gdb/testsuite/gdb.mi/mi-sym-info-1.c",
          symbols=[{line="25",name="global_f1",type="float",
                    description="static float global_f1;"}]},
         {filename="/project/gdb/testsuite/gdb.mi/mi-sym-info-2.c",
          fullname="/project/gdb/testsuite/gdb.mi/mi-sym-info-2.c",
          symbols=[{line="19",name="global_f1",type="float",
                    description="static float global_f1;"}]}]}

(gdb)
    -symbol-info-variables --type float
    ^done,symbols=
      {debug=
        [{filename="/project/gdb/testsuite/gdb.mi/mi-sym-info-1.c",
          fullname="/project/gdb/testsuite/gdb.mi/mi-sym-info-1.c",
          symbols=[{line="25",name="global_f1",type="float",
                    description="static float global_f1;"}]},
         {filename="/project/gdb/testsuite/gdb.mi/mi-sym-info-2.c",
          fullname="/project/gdb/testsuite/gdb.mi/mi-sym-info-2.c",
          symbols=[{line="19",name="global_f1",type="float",
                    description="static float global_f1;"}]}]}

(gdb)
    -symbol-info-variables --include-nondebug
    ^done,symbols=
      {debug=
        [{filename="/project/gdb/testsuite/gdb.mi/mi-sym-info-1.c",
          fullname="/project/gdb/testsuite/gdb.mi/mi-sym-info-1.c",
          symbols=[{line="25",name="global_f1",type="float",
                    description="static float global_f1;"},
                   {line="24",name="global_i1",type="int",
                    description="static int global_i1;"}]},
         {filename="/project/gdb/testsuite/gdb.mi/mi-sym-info-2.c",
          fullname="/project/gdb/testsuite/gdb.mi/mi-sym-info-2.c",
          symbols=[{line="21",name="global_f2",type="int",
                    description="int global_f2;"},
                   {line="20",name="global_i2",type="int",
                    description="int global_i2;"},
                   {line="19",name="global_f1",type="float",
                    description="static float global_f1;"},
                   {line="18",name="global_i1",type="int",
                    description="static int global_i1;"}]}],
       nondebug=
        [{address="0x00000000004005d0",name="_IO_stdin_used"},
         {address="0x00000000004005d8",name="__dso_handle"}
          ...
        ]}

#### 7.`-symbol-list-lines` ####

-symbol-list-lines filename

打印包含给定源文件名的代码及其关联程序地址的行列表。条目按 PC 升序排序。

没有对应的GDB命令。

(gdb)
    -symbol-list-lines basics.c
    ^done,lines=[{pc="0x08048554",line="7"},{pc="0x0804855a",line="8"}]
    (gdb)

### 文件命令 ###

#### 1.`-file-exec-and-symbols` Command ####

-file-exec-and-symbols file

指定要调试的可执行文件。该文件也是从中读取符号表的文件。如果未指定文件，该命令将清除可执行文件和符号信息。如果在不带参数的情况下使用此命令时设置了断点，GDB将产生错误消息。否则，除了完成通知外，不会产生任何输出。

GDB Command

对应的GDB命令是 ‘file’.

Example

(gdb)
    -file-exec-and-symbols /kwikemart/marge/ezannoni/TRUNK/mbx/hello.mbx
    ^done
    (gdb)

#### 2.`-file-exec-file` Command ####

-file-exec-file file

指定要调试的可执行文件。不像'-file-exec-and-symbols'，则*不会*从此文件中读取符号表。如果不带参数使用，GDB会清除有关可执行文件的信息。除了完成通知外，不会产生任何输出。

对应的GDB命令是 ‘exec-file’.

Example

(gdb)
    -file-exec-file /kwikemart/marge/ezannoni/TRUNK/mbx/hello.mbx
    ^done
    (gdb)

#### 3.`-file-list-exec-source-file` ####

-file-list-exec-source-file

列出当前可执行文件的行号、当前源文件和当前源文件的绝对路径。宏信息字段的值为 '1' 或者 '0' 取决于文件是否包含预处理器宏信息。

GDB等价物是 ‘info source’

Example

(gdb)
    123-file-list-exec-source-file
    123^done,line="1",file="foo.c",fullname="/home/bar/foo.c,macro-info="1"
    (gdb)

#### 5. `-file-list-exec-source-files` ####

-file-list-exec-source-files [ --group-by-objfile ]
                                  [ --dirname | --basename ]
                                  [ -- ]
                                  [ regexp ]

此命令返回有关GDB 知道的源文件的信息，它将输出源文件的文件名和全名（绝对文件名），但如果GDB不知道此信息，则可以省略全名。

此命令不带参数返回源文件列表。每个源文件都由一个带有字段的元组表示；file、 fullname和debug-fully-read。file是文件的显示名称，而fullname是文件的绝对名称。如果无法计算源文件的绝对名称，则可以省略全名字段。字段 debug-fully-read将是一个字符串，要么是`true`要么 `false`。何时`true`，这表示已读入描述该文件的编译单元的完整调试信息。`false`，完整的调试信息还没有被读入。在读入完整的调试信息时，GDB可能会知道其他源文件。

可选的正则表达式可用于过滤返回的源文件列表。正则表达式将与完整的源文件名匹配。匹配区分大小写，但具有不区分大小写文件系统的操作系统（例如 MS-Windows）除外。'--' 可以在regexp之前使用，以防止 GDB将regexp解释为命令选项（例如，如果 regexp以 ' 开头-’).

如果`--dirname`提供，则regexp仅与每个源文件的目录名称匹配。如果`--basename` 提供，则正则表达式与每个源文件的基本名称匹配。只能给出`--dirname`或之一`--basename`，如果给出任何一个，则需要正则表达式。

如果`--group-by-objfile`使用，则结果的格式会改变。结果现在将是一个元组列表，每个元组代表一个加载到 GDB中的目标文件（可执行文件或共享库） 。这些元组的字段是；文件名、 调试信息和来源。文件名是目标文件的绝对名称，调试信息是具有以下值之一的字符串：

`none`

此目标文件没有调试信息。

`partially-read`

此目标文件具有调试信息，但尚未完全读入。稍后读入时，GDB 可能会意识到其他源文件。

`fully-read`

这个目标文件有调试信息，这个信息被完全读入 GDB。源文件列表已完成。

源是一个列表或元组，每个元组描述一个具有与前面描述的相同字段的源文件。对于 没有调试信息的目标文件， 源列表可以为空。

对应GDB 命令 ‘info sources’. `gdbtk` 有一个类似的命令 ‘gdb\_listfiles’.

Example

(gdb)
    -file-list-exec-source-files
    ^done,files=[{file="foo.c",fullname="/home/foo.c",debug-fully-read="true"},
                 {file="/home/bar.c",fullname="/home/bar.c",debug-fully-read="true"},
                 {file="gdb_could_not_find_fullpath.c",debug-fully-read="true"}]
    (gdb)
    -file-list-exec-source-files
    ^done,files=[{file="test.c",
                  fullname="/tmp/info-sources/test.c",
                  debug-fully-read="true"},
                 {file="/usr/include/stdc-predef.h",
                  fullname="/usr/include/stdc-predef.h",
                  debug-fully-read="true"},
                 {file="header.h",
                  fullname="/tmp/info-sources/header.h",
                  debug-fully-read="true"},
                 {file="helper.c",
                  fullname="/tmp/info-sources/helper.c",
                  debug-fully-read="true"}]
    (gdb)
    -file-list-exec-source-files -- \\.c
    ^done,files=[{file="test.c",
                  fullname="/tmp/info-sources/test.c",
                  debug-fully-read="true"},
                 {file="helper.c",
                  fullname="/tmp/info-sources/helper.c",
                  debug-fully-read="true"}]
    (gdb)
    -file-list-exec-source-files --group-by-objfile
    ^done,files=[{filename="/tmp/info-sources/test.x",
                  debug-info="fully-read",
                  sources=[{file="test.c",
                            fullname="/tmp/info-sources/test.c",
                            debug-fully-read="true"},
                           {file="/usr/include/stdc-predef.h",
                            fullname="/usr/include/stdc-predef.h",
                            debug-fully-read="true"},
                           {file="header.h",
                            fullname="/tmp/info-sources/header.h",
                            debug-fully-read="true"}]},
                 {filename="/lib64/ld-linux-x86-64.so.2",
                  debug-info="none",
                  sources=[]},
                 {filename="system-supplied DSO at 0x7ffff7fcf000",
                  debug-info="none",
                  sources=[]},
                 {filename="/tmp/info-sources/libhelper.so",
                  debug-info="fully-read",
                  sources=[{file="helper.c",
                            fullname="/tmp/info-sources/helper.c",
                            debug-fully-read="true"},
                           {file="/usr/include/stdc-predef.h",
                            fullname="/usr/include/stdc-predef.h",
                            debug-fully-read="true"},
                           {file="header.h",
                            fullname="/tmp/info-sources/header.h",
                            debug-fully-read="true"}]},
                 {filename="/lib64/libc.so.6",
                  debug-info="none",
                  sources=[]}]

#### 6. `-file-list-shared-libraries` ####

Synopsis

-file-list-shared-libraries [ regexp ]

列出程序中的共享库。使用正则表达式regexp时，只会列出 名称与regexp匹配的那些库。

GDB Command

对应的GDB命令是‘info shared’. `=library-loaded`这些字段与通知具有相似的含义。该`ranges`字段指定属于该库的多个段。每个范围都有以下字段：

‘from’

定义段的包含下限的地址。

‘to’

定义段的独占上限的地址。

Example

(gdb)
    -file-list-exec-source-files
    ^done,shared-libraries=[
    {id="/lib/libfoo.so",target-name="/lib/libfoo.so",host-name="/lib/libfoo.so",symbols-loaded="1",thread-group="i1",ranges=[{from="0x72815989",to="0x728162c0"}]},
    {id="/lib/libbar.so",target-name="/lib/libbar.so",host-name="/lib/libbar.so",symbols-loaded="1",thread-group="i1",ranges=[{from="0x76ee48c0",to="0x76ee9160"}]}]
    (gdb)

#### 7.`-file-symbol-file` ####

-file-symbol-file file

从指定的文件参数中读取符号表信息。不带参数使用时，清除GDB的符号表信息。除了完成通知外，不会产生任何输出。

对应的GDB命令是 ‘symbol-file’.

Example

(gdb)
    -file-symbol-file /kwikemart/marge/ezannoni/TRUNK/mbx/hello.mbx
    ^done
    (gdb)

### 目标操作命令 ###

#### 1.`-target-attach` ####

-target-attach pid | gid | file

附加到GDB之外的 进程pid或文件文件，或线程组gid。如果附加到线程组，则先前由 ' 返回的 id-list-thread-groups -- 可用' 必须使用。

对应的GDB命令是‘attach’.

Example

(gdb)
    -target-attach 34
    =thread-created,id="1"
    *stopped,thread-id="1",frame={addr="0xb7f7e410",func="bar",args=[]}
    ^done
    (gdb)

#### 2.`-target-detach` ####

-target-detach [ pid | gid ]

从通常恢复执行的远程目标中分离。如果指定了pid或gid，则从指定的进程或指定的线程组中分离。没有输出。

对应的GDB命令是 ‘detach’.

Example

(gdb)
    -target-detach
    ^done
    (gdb)

#### 3.`-target-disconnect` ####

-target-disconnect

断开与远程目标的连接。没有输出，目标一般不会恢复。

对应的GDB命令是 ‘disconnect’.

Example

(gdb)
    -target-disconnect
    ^done
    (gdb)

#### 4.`-target-download` ####

-target-download

将可执行文件加载到远程目标上。它每半秒打印一条更新消息，其中包括以下字段：

‘section’

部分的名称。

‘section-sent’

到目前为止为该部分发送的内容的大小。

‘section-size’

部分的大小

‘total-sent’

到目前为止发送的内容的总大小（当前和之前的部分）。

‘total-size’

要下载的整体可执行文件的大小。

Each message is sent as status record (see [GDB/MI Output Syntax][GDB_MI Output Syntax]).

此外，它会在下载部分时打印部分的名称和大小。这些消息包括以下字段：

‘section’

部分的名称。

‘section-size’

部分的大小。

‘total-size’

要下载的整体可执行文件的大小。

对应的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)

#### `5.-target-flash-erase` ####

-target-flash-erase

擦除目标上所有已知的闪存区域。

对应的GDB命令是‘flash-erase’.

输出是已擦除的闪存区域列表，包括起始地址和内存区域大小。

(gdb)
    -target-flash-erase
    ^done,erased-regions={address="0x0",size="0x40000"}
    (gdb)

#### 6.`-target-select` ####

-target-select type parameters …

将GDB连接到远程目标。该命令需要两个参数：

‘类型’

目标的类型，例如 ‘remote’, etc.

‘参数’

设备名称、主机名称等。有关更多详细信息， 请参阅[管理目标的命令。][Link 9]

输出是一个连接通知，后跟目标程序所在的地址，格式如下：

^connected,addr="address",func="function name",
      args=[arg list]

对应的GDB命令是 ‘target’.

(gdb)
    -target-select remote /dev/ttya
    ^connected,addr="0xfe00a300",func="??",args=[]
    (gdb)

### 文件传输命令 ###

#### 1.`-target-file-put` Command ####

-target-file-put hostfile targetfile

将文件hostfile从主机系统（运行 GDB的机器）复制到目标系统上的 targetfile 。

对应的GDB命令是‘remote put’.

(gdb)
    -target-file-put localfile remotefile
    ^done
    (gdb)

#### 2.`-target-file-get` Command ####

-target-file-get targetfile hostfile

将文件targetfile从目标系统复制到主机系统上的hostfile 。

对应的GDB命令是 ‘remote get’.

(gdb)
    -target-file-get remotefile localfile
    ^done
    (gdb)

#### 3. `-target-file-delete` ####

Synopsis

-target-file-delete targetfile

从目标系统中 删除目标文件。

对应的GDB命令是‘remote delete’.

(gdb)
    -target-file-delete remotefile
    ^done
    (gdb)

[eclipse]: https://so.csdn.net/so/search?q=eclipse&spm=1001.2101.3001.7020
[2da8b9a92e7a46cf8b566f748d909a6a.png]: https://img-blog.csdnimg.cn/2da8b9a92e7a46cf8b566f748d909a6a.png
[95ea1cea6b954038baab691d67e1c50d.png]: https://img-blog.csdnimg.cn/95ea1cea6b954038baab691d67e1c50d.png
[c3a7cfce234642b98f61f2175b56bc64.png]: https://img-blog.csdnimg.cn/c3a7cfce234642b98f61f2175b56bc64.png
[01bae68717be479793dbfcdac4429829.png]: https://img-blog.csdnimg.cn/01bae68717be479793dbfcdac4429829.png
[Link 1]: https://blog.csdn.net/jg_csdn/article/details/126146124?spm=1001.2014.3001.5502
[6b3a27edffd2439388c3a94dbe987491.png]: https://img-blog.csdnimg.cn/6b3a27edffd2439388c3a94dbe987491.png
[c2e898ed91c94a2f81be12f8bf6b8bd5.png]: https://img-blog.csdnimg.cn/c2e898ed91c94a2f81be12f8bf6b8bd5.png
[d07a895e15914b23998f644afbc6f3e6.png]: https://img-blog.csdnimg.cn/d07a895e15914b23998f644afbc6f3e6.png
[f77cadf6488a4d9d859b2de5368c7b83.png]: https://img-blog.csdnimg.cn/f77cadf6488a4d9d859b2de5368c7b83.png
[b026cffb05384b82840c4554714e99bf.png]: https://img-blog.csdnimg.cn/b026cffb05384b82840c4554714e99bf.png
[Frames]: https://sourceware.org/gdb/current/onlinedocs/gdb/Frames.html#Frames
[Link 2]: https://sourceware.org/gdb/current/onlinedocs/gdb/Explicit-Locations.html#Explicit-Locations
[Link 3]: https://sourceware.org/gdb/current/onlinedocs/gdb/Static-Probe-Points.html#Static-Probe-Points
[51da6a06d6524eeabf25f631ab5857b0.png]: https://img-blog.csdnimg.cn/51da6a06d6524eeabf25f631ab5857b0.png
[set print object]: https://sourceware.org/gdb/current/onlinedocs/gdb/Print-Settings.html#Print-Settings
[API]: https://sourceware.org/gdb/current/onlinedocs/gdb/Pretty-Printing-API.html#Pretty-Printing-API
[Supported Languages]: https://sourceware.org/gdb/current/onlinedocs/gdb/Supported-Languages.html#Supported-Languages
[-var-set-format]: https://sourceware.org/gdb/current/onlinedocs/gdb/GDB_002fMI-Variable-Objects.html#g_t_002dvar_002dset_002dformat
[-var-set-frozen]: https://sourceware.org/gdb/current/onlinedocs/gdb/GDB_002fMI-Variable-Objects.html#g_t_002dvar_002dset_002dfrozen
[-var-list-children]: https://sourceware.org/gdb/current/onlinedocs/gdb/GDB_002fMI-Variable-Objects.html#g_t_002dvar_002dlist_002dchildren
[GDB_MI]: https://sourceware.org/gdb/current/onlinedocs/gdb/GDB_002fMI-Development-and-Front-Ends.html#GDB_002fMI-Development-and-Front-Ends
[Pretty-Printers]: https://sourceware.org/gdb/current/onlinedocs/gdb/Selecting-Pretty_002dPrinters.html#Selecting-Pretty_002dPrinters
[GDB_MI 1]: https://sourceware.org/gdb/current/onlinedocs/gdb/GDB_002fMI-Support-Commands.html#GDB_002fMI-Support-Commands
[Link 4]: https://sourceware.org/gdb/current/onlinedocs/gdb/Machine-Code.html#Machine-Code
[Link 5]: https://sourceware.org/gdb/current/onlinedocs/gdb/Source-Path.html#Source-Path
[GDB_MI 2]: https://sourceware.org/gdb/current/onlinedocs/gdb/GDB_002fMI-Command-Syntax.html#GDB_002fMI-Command-Syntax
[Link 6]: https://sourceware.org/gdb/current/onlinedocs/gdb/Memory-Region-Attributes.html#Memory-Region-Attributes
[GDB_MI Result Records]: https://sourceware.org/gdb/current/onlinedocs/gdb/GDB_002fMI-Result-Records.html#GDB_002fMI-Result-Records
[tfind]: https://sourceware.org/gdb/current/onlinedocs/gdb/tfind.html#tfind
[Link 7]: https://sourceware.org/gdb/current/onlinedocs/gdb/Location-Specifications.html#Location-Specifications
[GDB_MI 3]: https://sourceware.org/gdb/current/onlinedocs/gdb/GDB_002fMI-Frame-Information.html#GDB_002fMI-Frame-Information
[Link 8]: https://sourceware.org/gdb/current/onlinedocs/gdb/Trace-Files.html#Trace-Files
[GDB_MI Output Syntax]: https://sourceware.org/gdb/current/onlinedocs/gdb/GDB_002fMI-Output-Syntax.html#GDB_002fMI-Output-Syntax
[Link 9]: https://sourceware.org/gdb/current/onlinedocs/gdb/Target-Commands.html#Target-Commands