基于gdb和miisaline的面向企业的文本界面通过使用‘--interpreter’命令行选项激活（参见第2.1.2节[模式选项]，第13页）。该界面特别旨在支持将调试器作为更大系统中一个小组件的开发。
本章是thegdb/mi接口的规范，以参考手册的形式编写。
请注意，gdb/mi仍在建设中，因此下面描述的一些功能是不完整的，可能会发生变化（请参见第27.6节[gdb/mi开发和前端结束]，第294页 ).
27.2 符号和术语
本章使用以下符号：
•|分开两种选择。
•[某物]表示某物是可选的：它可以被给出，也可以不被给出。
•（group）*表示括号内的组可以重复零次或多次。
•（group）+表示括号内的组可以重复一次或多次。
“字符串”是指字面字符串。
27.3 gdb/ mi一般设计
aGDB/MI前端与gdb的交互涉及三个部分——发送给gdb的命令、对这些命令的响应以及通知。每个命令都会产生一个确切的响应，表明命令是否成功完成或出现错误。对于不恢复目标的命令，响应包含请求的信息。对于恢复目标的命令，响应仅指示目标是否成功恢复。通知是报告目标状态或gdb状态变化的机制，这些变化无法方便地与命令关联并作为该命令响应的一部分报告。
通知的重要示例包括：
执行通知。这些用于报告目标状态的变化——当目标被恢复或停止时。将此信息包含在恢复命令响应中是不可行的，因为一个恢复命令可能会导致不同线程中的多个事件。此外，在目标中发生任何事件之前可能需要相当长的时间，而前端需要知道恢复命令本身是否已成功执行。
控制台输出和状态通知。控制台输出通知用于报告CLI命令的输出，以及其他命令的诊断信息。状态通知用于报告正在进行的操作进度。当然，如果在命令响应中包含这些信息，则意味着直到命令完成之前不会有任何输出，这是不希望看到的。
一般通知。命令可能对gdb或目标状态产生超出其官方目的的各种副作用。例如，命令可能改变所选线程。虽然此类更改可以包含在命令响应中，但使用通知允许更正交的前端设计。
没有保证每当MI命令报告错误时，gdb或目标处于任何特定状态，特别是状态不会恢复到MI命令处理前的状态。因此，每当MI命令导致错误时，我们建议前端刷新用户界面上显示的所有信息。
27.3.1上下文管理
在大多数情况下，当gdb访问目标时，这种访问是在特定线程和帧的上下文中进行的（见第8.1节[帧]，第77页）。通常，即使访问全局数据，目标也需要指定一个线程。命令行界面维护选定的线程和帧，并在每次命令执行时提供给目标。这非常方便，因为命令行用户不会希望在每次命令执行时显式指定这些信息，而且用户通过单个终端与gdb交互，因此不会对当前的线程和帧产生混淆。
在MI的情况下，选择线程和帧的概念不太有用。首先，前端可以轻松记住这些信息。其次，图形前端可以有多个窗口，每个窗口用于调试不同的线程，前端可能需要访问其他线程以进行内部操作。这增加了依赖隐式选择线程的风险，即前端可能会操作错误的线程。因此，每个MI命令都应明确指定要操作的线程和帧。为了实现这一点，每个MI命令接受‘--thread’和‘--frame’选项，其值是用于操作的线程和帧的gdb标识符。
通常情况下，前端的每个顶级窗口允许用户选择一个线程和一个框架，并记住用户的选中以供后续操作。然而，在某些情况下，gdb可能会建议更改当前线程。例如，在停在断点时，切换到触发断点的线程是合理的。另一个例子是，如果用户通过前端发出CLI‘thread’命令，最好将前端选择的线程更改为用户指定的线程。gdb使用‘=thread-selected’通知来传达更改当前线程的建议。但目前没有这样的通知适用于选定的框架。
请注意，历史上MI与CLI共享选定的线程，因此前端使用-thread-select命令在正确的上下文中执行命令。然而，要让这一点正确工作是繁琐的。最简单的方法是在每个命令之前发出-thread-select命令。这会使需要发送的命令数量翻倍。另一种方法是如果gdb中选定的线程与前端希望操作的线程相同，则忽略-thread-select。然而，实现这一优化可能很棘手。特别是，如果前端向gdb发送多个命令，其中一个命令改变了选定的线程，那么后续命令的行为将会改变。因此，前端要么等待这些有问题的命令的响应，要么显式地为所有后续命令添加-thread-select。没有已知的前端能完全正确地做到这一点，所以建议始终传递--thread和--frame选项。
在某些目标上，gdb能够在目标运行时处理MI命令。这被称为异步命令执行（见第68页第5.4.3[背景执行]节）。前端可以使用-gdb-settarget-as ync 1命令指定异步执行的偏好，该命令应在运行可执行文件或连接到目标之前发出。前端启动可执行文件或连接到目标后，可以使用-list-target-features命令检查是否启用了异步执行。
即使在目标运行时，gdb仍能接受命令，但许多访问目标的命令在目标运行时无法执行。因此，异步命令执行最有效的方式是与非停止模式结合使用（见第67页第5.4.2节[非停止模式]）。这样，在其他线程运行的同时，可以检查一个线程的状态。
当某个线程运行时，试图在该线程上下文中访问目标的MI命令可能无法工作，或者仅在某些目标上有效。特别是，试图操作线程堆栈的命令在任何目标上都不会起作用。读取内存或修改断点的命令可能有效也可能无效，这取决于目标。请注意，即使是对全局状态进行操作的命令，如打印、设置和断点命令，在特定线程的上下文中仍然会访问目标，因此前端应尝试找到一个已停止的线程，并在该线程上执行操作（使用‘--thread’选项）。
在运行中的线程的上下文中哪些命令是有效的，高度依赖于目标。但是，两个命令-exec-interrupt，用于停止线程，和-thread-in fo，用于查找线程的状态，总是有效的。
gdb可以同时调试多个进程。在某些平台上，gdb可以支持调试多个硬件系统，每个硬件系统都有多个核心，每个核心上运行着多个不同的进程。本节介绍支持此类调试场景的MI机制。
关键观察是，无论目标的结构如何，MI都可以有一个全局的线程列表，因为大多数接受‘--thread’选项的命令不需要知道该线程属于哪个进程。因此，无需引入额外的‘--process’选项，也不需要在MI接口中引入当前进程的概念。唯一严格的新功能是能够找到线程如何被分组到进程中的能力。
为了使用户能够发现这样的分组，并支持任意层次的机器/核心/进程，MI引入了线程组的概念。线程组是一组线程和其他线程组的集合。线程组始终具有一个字符串标识符、类型，以及可能特定于该类型的其他属性。新命令-list-thread-groups返回顶级线程组的列表，这些线程组对应于进程。
gdb正在调试。通过将线程组标识符传递给-list-thread-groups命令，可以获取特定线程组的成员。
为了方便用户发现进程和其他对象，他希望调试，因此引入了可用线程组的概念。可用线程组是指gdb未对其进行调试，但可以通过使用-target-attach命令连接到的线程组。可以通过‘-list-thread-groups--available’获取可用顶级线程组的列表。通常情况下，只有在连接到该线程组后才能检索到线程组的内容。
27.4.1 gdb/ mi输入语法
commandI→
cli-command| mi-command
cli-命令I→
[ token]cli-command nl，其中cli-comm和是任何现有的gdbCLI命令。
mi-command I→
[token]“-”操作（“”选项）*[“--”]（“”参数）*nl
令牌I→“任意数字序列”选项I→
“-”参数[“”参数]
参数I→
非空白序列|c-字符串
operationI→
本章所述的任何操作
非空白序列I→
任何东西，只要它不包含特殊字符，如“-”、nl、“”“和当然”“
c-stringI→
“”“七位-iso-c-string-content”“”
nlI→ CR|CR-LF
记下
CLI命令仍然由mi interpreter处理；其输出描述如下。
当存在令牌时，命令完成时会将其返回。
某些mi命令接受可选参数作为参数列表的一部分。每个选项由前导的“-”（破折号）标识，并且可以跟上一个可选参数。选项首先出现在参数列表中，并且可以与正常参数分开
参数使用“--”（当某些参数以破折号开头时，这很有用）。语义学：
我们希望可以轻松访问现有的CLI语法（用于调试）。
我们希望它能很容易地发现mi操作。
gdb/mi的输出由零个或多个带外记录组成，随后可选地跟一个结果记录。该结果记录是针对最近的命令的。输出记录序列以‘（gdb）’终止。
如果输入命令前缀有标记，则该命令的相应输出也将被该标记前缀。
output→
（带外记录）*[结果记录]”（gdb）nl
结果记录‘→
[token]“^”结果类（，“结果”）nl
带外记录‘→
异步录制|播放录制
async-record→
exec-async-output | status-async-output | notify-async-output
exec-async-output‘→
[token]“*”异步输出
状态-非同步输出‘→
[token]“+”异步输出
通知-非同步输出‘→
[token]“=”异步输出
async-output→
异步类(“”，结果*nl
结果类别‘→
“完成”|“运行”|“连接”|“错误”|“退出”
async-class→
“停止”|其他人（根据需要添加其他人——这仍在开发中）。
result→
变量“=”值
variable→
细绳
值→const|元组|列表
const‘→c-string
tuple‘→“{}”|“{”result（“，”result）*“}”
list‘→“[]”|“[”值（“，”值）*“]”|“[”结果（“，”结果）*“]”
直播录制‘→
控制台流输出|目标流输出|日志流输出
控制台流输出‘→“~”c-string
target-stream-outputI→“@”c-string
日志流输出I→
“&”c字符串
nlI→ CR|CR-LF
token I→任何数字序列。
记下
所有输出序列以包含句点的单行结束。
令牌来自相应的请求。请注意，对于所有异步输出，虽然语法允许并可能由未来的gdb版本用于选择性异步输出消息，但通常会被省略。前端应将所有异步输出视为报告目标状态的一般变化，无需将异步输出与任何先前命令关联。
状态-处理中-输出包含有关缓慢操作进度的正在进行的状态信息。可以丢弃所有状态输出。所有状态输出都以‘+’为前缀。
•exec-async-output包含目标上的异步状态变化（停止、启动、消失）。所有异步输出都以“*”为前缀。
通知-异步输出包含客户端应处理的补充信息（例如，新的断点信息）。所有通知输出都以“=”开头。
控制台-流-输出是指应在控制台上显示的输出。它是对CLI命令的文本响应。所有控制台输出都以“”为前缀。
•target-stream-output是目标程序产生的输出。所有目标输出都以“@”为前缀。
log-stream-output是从gdb的内部输出的文本，例如应该作为错误日志的一部分显示的消息。所有日志输出都以“&”为前缀。
•Newgdb/mi命令应仅输出包含值的列表。
参见第295页27.7.2[gdb/mi Stream Records]部分 ，有关各种输出记录的详细信息。
27.5 gdb/mi与CLI的兼容性
对于开发人员来说，可以直接输入CLI命令，但可能会出现一些意外行为。例如，查询用户的命令会像用户回答“是”一样执行，断点命令列表不会被执行，某些CLI命令如if、when和defi ne会在输入‘>’时提示进一步操作，而‘>’并不是有效的MI输出。
此功能可能在未来的某个阶段被删除，建议前端使用interpreter- exec命令（参见[-interpreter-exec]，第351页 ).
将MI输出接收并把被调试程序的状态呈现给用户的应用程序被称为前端。
尽管gdb/miis仍不完整，但它目前已被多种gdb前端使用。这使得在不破坏现有用法的情况下引入新功能变得困难。本节试图通过描述协议可能如何改变来尽量减少这些问题。
MI的某些更改不需要破坏精心设计的前端，对于这些更改，MI版本将保持不变。以下是一个可能在一个级别内发生的更改列表，因此前端应该以能够处理它们的方式解析MI输出：
可添加新的MI命令。
可在任何MI命令的输出中添加新字段。
指定值的字段的值范围，例如，在scope中（参见[-var-update]， 第331页 ）可以延长。
如果更改可能会破坏前端，MI版本级别将增加一级。这将允许前端根据MI版本解析输出。除了mi 0，新的gdb版本将不支持旧版本的MI，前端需要负责与新版本兼容。
避免MI中可能出现的意外变化导致前端崩溃的最佳方法是让gdb开发者知道你的项目，并在gdb@sourceware.org上跟踪开发以及gdb-patches@ sourceware.org.
27.7 gdb/mi输出记录
27.7.1 gdb/ mi结果记录
除了多个带外通知之外，对agdb/mi命令的响应还包括以下结果指示之一：
“^完成”[，”结果]
同步操作成功，结果为返回值。
"^running"
此结果记录等同于“^完成”。历史上，如果命令已恢复目标，则会输出“^完成”而不是“^完成”。这种行为是为了向后兼容而保留的，但所有前端都应将“^完成”和“^运行”视为相同，并依赖于“*运行”输出记录来确定哪些线程已恢复。
"^connected"
gdb已连接到远程目标。
“^错误”、“c-string
操作失败。Thec-string包含相应的错误消息。
“^退出”gdb已终止。
gdb内部维护多个输出流：控制台、目标和日志。这些流的输出通过gdb/mi接口使用流记录进行传输。
每个流记录都以一个唯一的前缀字符开始，该字符标识其流（请参见第293页的第27.4.2[ gdb/ mi输出语法]节 ）。除了前缀之外，每个流记录还包含一个字符串输出。它要么是原始文本（带有隐式换行符），要么是一个引用的C字符串（不包含隐式换行符）。
“~”字符串输出
控制台输出流包含应在CLI控制台窗口中显示的文本。它包含对CLI带逗号的文本响应。
“@”字符串输出
目标输出流包含运行中的目标的所有文本输出。只有当GDB的事件循环真正异步时，才存在此目标输出流，而目前只有远程目标才存在这种情况。
“&”字符串输出
日志流包含由gdb内部生成的调试消息。
27.7.3 gdb/ mi Async记录
异步记录用于通知gdb/ mi客户端已发生的其他更改。这些更改可能是gdb/ mi命令的结果（例如，断点被修改），也可能是目标活动的结果（例如，目标已停止）。
以下是可能的异步记录列表：
*运行，线程ID=“线程”
目标现在正在运行。线程字段显示当前正在运行的具体线程，如果所有线程都在运行，则可以是“全部”。前端应假设在此通知发出后无法与正在运行的线程进行交互。前端不应假设此通知对于任何命令仅输出一次。gdb可能会多次发出此通知，要么是因为它无法同时恢复所有线程，要么即使对于单个线程也是如此，如果该线程需要先执行某些代码才能自由运行。
*停止，reason=“reason”，thread-id=“id”，stopped-threads=“stopped”，core=“core”目标已停止。原因字段可以具有以下值之一：
断点命中
断点为reached.watchpoint-trigger
一个观察点是triggered.read-watchpoint-trigger
读取观察点triggered.access-watchpoint-trigger
触发了访问监视点。
功能完成
已执行An-exec-finish或类似的CLI命令。
已到达位置
执行完An- exec-，直到完成类似的CLI命令。
监视点范围
监视点已超出范围。
端步距范围
已执行-exec-next、-exec-next-instruction、-exec-step、-exec-step-指令或类似的CLI命令。
已发出退出信号
下级因信号而退出。
退出下级exited.exited-normally
下级正常退出。
已接收信号
下部接收到信号。
id字段标识了直接导致停止的线程——例如通过触发断点。根据是否处于全停模式（见第5.4.1节[全停模式]，第65页），gdb可能会停止所有线程，或者仅停止直接触发停止的线程。如果所有线程都已停止，停止字段的值将是“all”。否则，停止字段的值将是一个线程标识符列表。目前，此列表始终包含单个线程，但前端应准备好看到列表中的多个线程。核心字段报告了停止事件发生时所在的处理器核心。如果此类信息不可用，此字段可能不存在。
=thread-group-created，id=“id”=thread-group-exited，id=“id”
一个线程组ei ther被附加到或已退出/脱离。id字段包含线程组的gdb标识符。
=线程创建，id=“id”，组ID=“gid”=线程退出，id=“id”，组ID=“gid”
线程要么已创建，要么已退出。id字段包含线程的gdb标识符。gid字段标识该线程所属的线程组。
=线程选择，id=“id”
通知已更改选定线程，这是由于上次命令的结果。此通知不会因线程选择命令而发出，但每当未被文档记载为改变选定线程的MI命令实际改变了它时，就会发出此通知。特别是，直接或间接（通过用户定义的命令）调用CLI线程命令，都会生成此通知。
我们建议，针对此通知，前端突出显示选定的线程，并使后续命令应用于该线程。
=载有库，...
程序加载了新的库文件。此通知包含四个字段——id、target-name、host-n ame和symbols-loaded。id字段是
库的不透明标识符。对于远程调试情况，target-name和host- name字段分别给出目标和主机上的库文件名。对于本地调试，这两个字段具有相同的值。symbols- loaded字段报告是否加载了此库的调试符号。
=库未加载，...
报告程序卸载了库。此通知包含3个字段——id、target-name和host-name，其含义与=library-loaded通知相同
27.7.4 gdb/ mi Frame信息
许多MI命令的响应都包括有关堆栈帧的信息。此信息是一个可能具有以下字段的字组：
层级堆栈框架的层级。最内层框架的层级为零。
领域总是存在的。
func帧对应的函数的名称。此字段可能不存在
如果gdb无法确定函数名。
addr帧的代码地址。此字段始终存在。
文件“源文件的名称”对应于帧的代码地址。此
字段可能不存在。
行对应于帧代码地址的源行。此字段可以是
缺席的
从二进制文件（可执行文件或共享库）的名称中对应
到帧的代码地址。此字段可能不存在。
每当gdb必须报告有关线程的信息时，它使用一个包含以下字段的元组：
id调用gdb分配给线程的数字标识。此字段始终存在。
目标ID
针对特定目标的字符串，用于标识线程。此字段始终存在。
详情目标提供的关于该线程的附加信息。它应该
可供人类阅读，但前端不对其进行解释。此字段是可选的。
状态为“停止”或“运行”，具体取决于线程当前的状态
运行。此字段始终存在。
核心此字段的值是线程所在的处理器核心的整数
上次看到的时间。此字段为可选字段。
27.8 gdb/mi交互的简单示例
本小节介绍了使用gdb/ mi接口的几个交互示例。在这些示例中，“->”表示将以下行作为输入传递给gdb/ mi，而“<-”表示从gdb/ mi接收的输出。
请注意，示例中显示的换行仅用于可读性，它们不会出现在实际输出中。
设置断点生成同步输出，其中包含有关断点的详细信息。
->-断开插入主开关
<- ^done, bkpt={number="1",type="breakpoint",disp="keep",
enabled="y",addr="0x08048564",func="main",file="myprog.c",
fullname="/home/nickrob/myprog.c",line="68",times="0"}<- (gdb )
程序执行
程序执行生成异步重连数据，MI给出停止执行的原因。
->-exec-run<- ^running<-（gdb）
<-*停止，reason=“breakpoint-hit”，disp=“keep”，bkptno=“1”，thread-id=“0”，帧={addr=“0x08048564”，func=“main”，
args=[{name="argc",value="1"},{name="argv",value="0xbfc4d4d4"}],
file="myprog.c",fullname="/home/nickrob/myprog.c",line="68"}<- (gdb )
->-执行-继续
<- ^running<- (gdb )
<-*stopped, reason="exited-normally"<- (gdb )
退出gdb
退出gdb只会打印结果class‘^exit’。
-> (gdb )
<--gdb-exit<-^exit
请注意，“^退出”会立即打印出来，但gdb实际退出可能需要一些时间。在此期间，gdb会执行必要的清理工作，包括终止正在调试的程序或断开与调试硬件的连接。因此，前端应等待gdb完全退出，只有当它未能在合理时间内退出时，才强制终止gdb。
命令不当
如果通过一个不存在的命令，将会发生以下情况：->-rubbish
<-^错误，msg=“未定义的MI命令：rubbish”<-（gdb）
27.9 gdb/mi命令描述格式
其余部分描述了命令块。每个命令块的布局方式与本节类似。
此命令集的动机。
介绍
对整个命令集的简要介绍。
命令
对于块中的每个命令，以下内容进行了描述：
概要
-command参数...
结果
gdb命令
相应的gdb CLI命令（如果有的话）。
样例
示例(s)的格式便于阅读。有些描述的命令尚未实现，这些命令标记为N.A.（不可用）。
27.10 gdb/mi Breakpo int命令
本节记录了用于操纵断点的gdb/mi命令。break-after命令
概要
-断行后数字计数
断点编号在被击中次数达到之前是无效的。要了解此如何反映在“-break-list”命令的输出中，请参见下面对“-break-list”命令的说明。
gdb命令
相应的gdb命令是“忽略”。
样例
(gdb)
断开插入主
^done, bkpt={number="1",type="breakpoint",disp="keep",
enabled="y",addr="0x000100d0",func="main",file="hello.c",fullname="/home/foo/hello.c",line="5",times="0"}
(gdb)
-1 3之后的断行
~
^done (gdb)
-断开列表
^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="1",type="breakpoint",disp="keep",enabled="y",
addr="0x000100d0",func="main",file="hello.c",fullname="/home/foo/hello.c",
line="5",times="0",ignore="3"}]} (gdb)
中断命令命令
概要
-break-commands数量[ command1 ... commandN]
指定当遇到断点时应执行的CLI命令。参数command1到commandN是这些命令。如果没有指定任何命令，则会清除之前设置的所有命令。请参见第58页第5.1.7节[BreakCommands]。此功能的典型用途是跟踪程序，即在遇到断点时打印某些变量的值，然后继续执行。
gdb命令
相应的gdb命令为“commands”。
样例
(gdb)
断开插入主
^done, bkpt={number="1",type="breakpoint",disp="keep",
enabled="y",addr="0x000100d0",func="main",file="hello.c",fullname="/home/foo/hello.c",line="5",times="0"}
(gdb)
-break-commands 1“print v”“continue”
^done (gdb)
break条件命令
概要
-break-condition数字表达式
只有当expr中的条件为true时，断点号才会停止程序。条件成为“-break-list”输出的一部分（请参见下面对“-break-list”命令的描述）。
gdb命令
相应的gdb命令是“condition”。
样例
(gdb)
-中断条件1 1^完成
(gdb)
-断开列表
^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="1",type="breakpoint",disp="keep",enabled="y",
addr="0x000100d0",func="main",file="hello.c",fullname="/home/foo/hello.c",
line="5",cond="1",times="0",ignore="3"}]} (gdb)
break-delete命令
概要
-中断-删除（brea kpoint）+
删除断点(s)，其编号(s)在参数列表中指定。这显然反映在断点列表中。
gdb命令
相应的gdb命令是“de delete”。
样例
(gdb)
-断开-删除1
^done (gdb)
-断开列表
^done, BreakpointTable={nr_rows="0",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=[]} (gdb)
break-disable命令
概要
-break-disable (断点）+
禁用命名的断点(s)。现在，断点列表中的字段“已启用”被设置为“n”用于命名的断点(s)。
gdb命令
相应的gdb命令是“disable”。
样例
(gdb)
-禁用break 2
^done (gdb)
-断开列表
^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",times="0"}]} (gdb)
break-enable命令
概要
-break-enable (断点）+
启用（以前已禁用）断点（个）。
gdb命令
相应的gdb命令是“enable”。
样例
(gdb)
-break-enable 2
^done (gdb)
-断开列表
^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",times="0"}]} (gdb)
break-info命令
概要
-break-info断点
获取有关单个断点的信息。
gdb命令
相应的gdb命令是“info break breakpoint”。
N.A.
break-insert命令
概要
-break-insert [-t] [-h] [-f][-d][-ccondition ] [ -iignore-count ]
[-pthread][位置]如果指定，则位置可以是以下之一：
功能
• filename: linenum
•文件名：函数
•*address
此命令的可能可选参数为：
‘-t’插入临时断点。‘-h’插入硬件断点。
‘-c条件’
使断点条件化为条件。
‘-忽略计数’
初始化ignore-count。
‘-f’如果无法解析位置（例如，如果它引用未知文件或函数），创建一个待处理的断点。如果没有此标志，gdb将报告错误，
如果无法解析位置，则不会创建断点。‘-d’创建禁用的断点。
结果
结果的格式如下：
^完成，bkpt={number=“number”，type=“type”，disp=“del”|“keep”，enabled=“y”|“n”，addr=“hex”，func=“funcname”，file=“filename”，fullname=“full_filename”，line=“lineno”，[thread=“threadno，]times=”times“}
其中，number是此断点的gdb编号，funcname是插入断点的函数名称，file是包含该函数的源文件名，lineno是该文件中的源行号，times表示断点被触发的次数（对于-break-insert为0，而对于- break- info或-break-list使用相同输出时，可能为更大的数字）。
注：此格式可更改。
gdb命令
相应的gdb命令为“break”、“tbreak”、“hbreak”、“thbreak”和“rbreak”。
(gdb)
断开插入主
^done, bkpt={number="1",addr="0x0001072c",file="recursive2.c",
fullname="/home/foo/recursive2.c,line="4",times="0"} (gdb)
-断言插入tfoo
^done, bkpt={number="2",addr="0x00010774",file="recursive2.c",
fullname="/home/foo/recursive2.c,line="11",times="0"} (gdb)
-断开列表
^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",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",times="0"}]} (gdb)
-break-insert-rfoo.*~intfoo（int，int）；
^done, bkpt={number="3",addr="0x00010774",file="recursive2 .c,"fullname="/home/foo/recursive2.c",line="11",times="0"}
(gdb)
break-list命令
概要
-断开列表
显示插入断点的列表，显示以下字段：“编号”断点的编号
断点的类型：“breakpoint”或“watchpoint”
‘性格’
当触发断点时，是否应删除或禁用断点：“keep”或“nokeep”：是否启用断点：“y”或“n”
设置断点的“地址”内存位置
断点的逻辑位置，由函数名、文件名和行号表示
‘次数’表示断点被击中的次数
如果没有断点或监视点，则BreakpointTable body fie ld是一个空列表。
gdb命令
相应的gdb命令是“info break”。
(gdb)
-断开列表
^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="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",fullname="/home/foo/hello.c",
line="13",times="0"}]} (gdb)
下面是存在nobreakpoint时的结果示例：（gdb）
-断开列表
^done, BreakpointTable={nr_rows="0",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=[]} (gdb)
break-watch命令
概要
-break-watch[-a|-r]
创建一个观察点。使用‘-a’选项，它将创建一个访问观察点，即在读取或写入内存位置时触发的观察点。使用‘-r’选项，创建的观察点是读取观察点，即仅在内存位置被读取时触发。如果不使用这两个选项，创建的观察点是常规观察点，即在内存位置被写入时触发。参见第5.1.2[设置观察点]，第49页。
请注意，“-break-list”将报告插入的单个监视点和断点列表。
gdb命令
相应的gdb命令为“watch”、“awatch”和“rwatch”。
样例
在mainfunction中的变量上设置一个监视点：（gdb）
-取消观看x
^done, wpt={number="2",exp="x"} (gdb)
-exec-继续^运行中
(gdb)
*停止，reason=“watchpoint-trigger”，wpt={number=“2”，exp=“x”}，值={old=“-268439212”，new=“55”}，
frame={func="main",args=[],file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="5"} (gdb)
在函数的局部变量上设置一个监视点。gdb将两次停止程序执行：第一次是因为变量值发生变化，第二次是因为监视点超出作用域。
(gdb)
-断开手表C
^完成，wpt={number=“5”，exp=“C”}（gdb）
-执行-继续
^running (gdb)
*停止，原因=“监视点触发”，
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"} (gdb)
-执行-继续
^running (gdb)
*已停止，reason=“watchpoint-scope”，wpnum=“5”，frame={func=“callee3”，args=[{name=“strarg”，
value=“0x11940”字符串参数。}]，
file=" ../ ../ ../devo/gdb/testsuite/gdb.mi/basics.c",
fullname="/home/foo/bar/devo/gdb/testsuite/gdb.mi/basics.c",line="18"} (gdb)
列出程序执行过程中不同点的断点和监视点。请注意，一旦监视点超出作用范围，它就会被删除。
(gdb)
-断开手表C
^完成，wpt={number=“2”，exp=“C”}（gdb）
-断开列表
^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="0x00010734", func=" callee4",
file=" ../ ../ ../devo/gdb/testsuite/gdb.mi/basics.c",
fullname="/home/foo/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)
-执行-继续
^running (gdb)
*已停止，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",
fullname="/home/foo/bar/devo/gdb/testsuite/gdb.mi/basics.c",line="13"} (gdb)
-断开列表
^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="0x00010734", func=" callee4",
file=" ../ ../ ../devo/gdb/testsuite/gdb.mi/basics.c",
fullname="/home/foo/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-继续^运行中
^完成，reason=“watchpoint-scope”，wpnum=“2”，frame={func=“callee3”，args=[{name=“strarg”，value=“0x11940\”A字符串参数。“[}]”
file=" ../ ../ ../devo/gdb/testsuite/gdb.mi/basics.c",
fullname="/home/foo/bar/devo/gdb/testsuite/gdb.mi/basics.c",line="18"} (gdb)
-断开列表
^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="1",type="breakpoint",disp="keep",enabled="y", addr="0x00010734", func=" callee4",
file=" ../ ../ ../devo/gdb/testsuite/gdb.mi/basics.c",
fullname="/home/foo/devo/gdb/testsuite/gdb.mi/basics.c",line="8",
times="1"}]} (gdb)
27.11 gdb/mi程序上下文
exec-arguments命令
概要
-exec-arguments参数
设置下级程序参数，用于下一个“执行-运行”。
gdb命令
相应的gdb命令是“setargs”。
(gdb)
-exec-arguments -v word
^done (gdb)
-environment-cd命令
概要
-environment-cd pathdir
Setgdb的工作目录。
gdb命令
相应的gdb命令是“cd”。
样例
(gdb)
-environment-cd/kwikemart/marge/ezannoni/flathead-dev/devo/gdb
^done (gdb)
环境指令命令
概要
-environment-directory [ -r] [pathdir ]+
将目录pathdir添加到源文件搜索路径的开头。如果使用了“-r”选项，则搜索路径将重置为默认搜索路径。如果除了“-r”选项外还提供了目录pathdir，则首先重置搜索路径，然后按常规方式添加目录。可以指定多个目录，用空格分隔。在一个命令中指定多个目录会导致这些目录按照它们在命令中出现的顺序被添加到搜索路径的开头。如果目录名称需要包含空格，则应在名称周围使用双引号。在命令输出中，路径将以系统目录分隔符字符分隔显示。目录分隔符字符不得用于任何目录名称。如果没有指定目录，则显示当前搜索路径。
gdb命令
相应的gdb命令是“dir”。
样例
(gdb)
-environment-directory/kwikemart/marge/ezannoni/flathead-dev/devo/gdb
^完成，source-path=“/kwikemart/marge/ezannoni/flathead-dev/devo/gdb：$cdir：$cwd”（gdb）
-环境目录“”
^完成，source-path=“/kwikemart/marge/ezannoni/flathead-dev/devo/gdb：$cdir：$cwd”（gdb）
-environment-directory-r/home/jjohnstn/src/gdb/usr/src
^完成，source-path=“/home/jjohnstn/src/gdb：/usr/src：$cdir：$cwd”
(gdb)
-environment-directory-r
^完成，源路径=“$cdir：$cwd”（gdb）
-environment-path命令
-environment-path [ -r][ pathdir ]+
将目录pathdir添加到对象文件搜索路径的开头。如果使用了‘-r’选项，则搜索路径将重置为gdb启动时存在的原始搜索路径。如果除了‘-r’选项外还提供了目录pathdir，则首先重置搜索路径，然后按常规方式添加。可以指定多个目录，用空格分隔。在一个命令中指定多个目录会导致这些目录按照它们在命令中出现的顺序被添加到搜索路径的开头。如果目录名称需要包含空格，则应在名称周围使用双引号。在命令输出中，路径将以系统目录分隔符字符分隔显示。目录分隔符字符不得用于任何目录名称中。如果没有指定目录，则显示当前路径。
gdb命令
相应的gdb命令是“path”。
样例
(gdb)
-环境路径
^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）
-environment-pwd命令
概要
-环境-pwd
显示当前工作负责人。
gdb命令
相应的gdb命令是“pwd”。
样例
(gdb)
-环境密码
^done, cwd="/kwikemart/marge/ezannoni/flathead-dev/devo/gdb" (gdb)
27.12 gdb/ mi Thread命令
-thread-info命令
-thread-info [ thread-id ]
如果thread- id参数存在，则报告有关特定线程的信息，或者报告有关所有线程的信息。打印有关所有线程的信息时，也会报告当前线程。
gdb命令
infothread命令打印所有线程的相同信息。
样例
-线程信息
^done, threads=[
{id=“2”，target-id=“Thread 0 xb 7e14b90（LWP 21257）”，
frame={level=“0”，addr=“0xffffe410”，func=“__kernel_vsyscall”，args=[]}，state=“running”}，{id=“1”，目标-id=“Thread 0 xb 7e156b0（LWP 21254）”，
frame={level="0",addr="0x0804891f",func="foo",args=[{name="i",value="10"}],file="/tmp/a.c",fullname="/tmp/a.c",line="158"},state="running"}],
current-thread-id=“1”（gdb）
“状态”字段可能具有以下值：
停止线程已停止。已停止的线程有帧信息。运行线程正在运行。没有运行线程的帧信息。-thread-list-ids命令
概要
-thread-list-ids-线程标识
生成当前已知的gdb线程ID列表。在列表末尾，它还会打印此类线程的总数。
由于历史原因，保留此命令，应改用thread-infocommand命令。
gdb命令
部分“信息线程”提供了相同的信息。
样例
(gdb)
-thread-list-ids-线程标识
^完成，thread-ids={thread-id=“3”，thread-id=“2”，thread-id=“1”}，
current-thread-id=“1”，number-of-threads=“3”（gdb）
-thread-select命令
-thread-select线程编号
将threadnum设为当前线程。它将打印新当前线程的编号以及该线程的顶层框架。
此命令已被弃用，建议使用每个命令的“--thread”选项。
gdb命令
相应的gdb命令是“thread”。
样例
(gdb)
-exec-next^正在运行
(gdb)
*停止，reason=“end-stepping-range”，thread-id=“2”，line=“187”，file=“../../../devo/gdb/testsuite/gdb.threads/linux-dp.c
(gdb)
-thread-list-ids^完成，
thread-ids={thread-id="3",thread-id="2",thread-id="1"},number-of-threads="3"
(gdb)
-线程选择3
^完成，新线程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)
27.13 gdb/mi程序执行
这些是生成带外记录“*停止”的异步命令。目前，gdb仅在远程目标上真正地异步执行，而在其他情况下则模拟这种交互。
exec-continue命令
概要
-exec-继续[--reverse] [--all|--thread-groupN]
恢复下级程序的执行，该程序将继续执行，直到遇到调试器停止事件。如果指定了“--reverse”选项，则执行将反向恢复，直到遇到停止事件。停止事件可能包括
断点或监视点
？过程的结束（或开始时的反向）
如果正在使用replay日志，则表示该日志的结束或开始。
在全停模式（见第65页第5.4.1节[全停模式]），只能恢复一个线程，或者根据的scheduler-locking变量的值恢复所有线程。如果
如果指定了‘--all’，则所有线程都将恢复。在all-stop模式下，将忽略‘--all’选项。如果指定了‘--thread-group’选项，则将恢复该线程组中的所有线程。
gdb命令
相应的gdb对应是“continue”。
样例
-执行-继续
^running (gdb)
@你好，世界
*已停止，reason=“breakpoint-hit”，disp=“keep”，bkptno=“2”，frame={
func="foo",args=[],file="hello.c",fullname="/home/foo/bar/hello.c",line="13"}
(gdb)
执行结束命令
概要
-exec-finish [--reverse]
恢复下级程序的执行，直到当前函数退出。显示由该函数返回的结果。如果指定了“--reverse”选项，则恢复下级程序的反向执行，直到调用当前函数的位置。
gdb命令
相应的gdb命令是“finish”。
样例
函数返回void。
-执行完毕^正在运行
(gdb)
@foo你好
*已停止，reason=“function-finished”，frame={func=“main”，args=[]，
file="hello.c",fullname="/home/foo/bar/hello.c",line="7"} (gdb)
函数返回值不是void。将打印存储结果的内部gdb变量的名称以及该值本身。
-执行完毕^正在运行
(gdb)
*已停止，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"},gdb-result-var="$1",return-value="0"
(gdb)
exec-interrupt命令
-exec-interrupt [--all|--thread-groupN]
中断目标的后台执行。请注意，与停止消息关联的令牌是被中断的执行命令的令牌。中断本身的令牌仅出现在‘^done’输出中。如果用户试图中断未运行的程序，将会打印错误消息。
请注意，当启用异步执行时，此命令与其他执行命令一样是异步的。也就是说，首先将打印“^done”响应，然后使用“*stopped”通知报告目标停止。
在不停止模式下，默认情况下只有上下文线程被中断。如果指定了“--all”选项，则所有线程都将被中断。如果指定了“--thread-group”选项，则该组中的所有线程都将被中断。
gdb命令
相应的gdb命令是interrupt‘。
样例
(gdb)
111-exec-continue111^正在运行
(gdb)
222-执行中断
222^done (gdb)
111*停止，signal-name=“SIGINT”，signal-meaning=“Interrupt”，frame={addr=“0x00010140”，func=“foo”，args=[]，file=“try.c”，
fullname="/home/foo/bar/try.c",line="13"} (gdb)
(gdb)
-执行中断
^错误，msg=“mi_cmd_exec_interrupt：Inferior未执行。”（gdb）
exec-jump命令
概要
-exec跳转位置
在参数指定的位置恢复下级进程的执行。有关不同形式位置的说明，请参见第84页第9.2[SpecifyLocation]节。
gdb命令
相应的gdb命令是“jump”。
样例
-exec-jump foo.c：10
*运行，thread-id=“all”^运行
exec-next命令
-exec-next[--reverse]
恢复下级程序的执行，当到达下一条源代码行的开头时停止。
如果指定了“--reverse”选项，则恢复子程序的反向执行，在上一行源代码的开头停止。如果在函数的第一行发出此命令，则会将您带回该函数的调用者，回到调用该函数的源代码行。
gdb命令
相应的gdb命令为“next”。
样例
-exec-next^正在运行
(gdb)
*停止，reason=“end-stepping-range”，line=“8”，file=“hello.c”（gdb）
执行下一条指令命令
概要
-exec-next-instruction [--reverse]
执行一个机器指令。如果该指令是函数调用，则会一直执行到该函数返回为止。如果程序在源代码行中间的指令处停止，则也会打印出地址。
如果指定了“--reverse”选项，则恢复子程序的反向执行，在上一条指令处停止。如果上一条执行的指令是从另一个函数返回，则会继续反向执行，直到到达对该函数的调用（从当前堆栈帧）为止。
gdb命令
相应的gdb命令是“nexti”。
样例
(gdb)
-执行下一个指令^正在运行
(gdb)
*停止，原因=“步长范围结束”，
addr="0x000100d4",line="5",file="hello.c" (gdb)
exec-return命令
-执行返回
使当前函数立即返回。不执行inferi或。显示新的当前帧。
gdb命令
相应的gdb命令为’return’。
样例
(gdb)
200断点插入calle e4
200^完成，bkpt={number=“1”，addr=“0x00010734”，
file=" ../ ../ ../devo/gdb/testsuite/gdb.mi/basics.c",line="8"} (gdb)
000-exec-run000^正在运行（gdb）
000*停止，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"} (gdb)
205-删除
205^done (gdb)
111-执行返回
111^done, frame={level="0",func="callee3",args=[{name="strarg",
value=“0x11940”字符串参数。}]，
file=" ../ ../ ../devo/gdb/testsuite/gdb.mi/basics.c",
fullname="/home/foo/bar/devo/gdb/testsuite/gdb.mi/basics.c",line="18"} (gdb)
exec-run命令
概要
-执行运行
从头开始执行子程序。子程序执行到遇到断点或程序退出为止。在后一种情况下，如果程序异常退出，则输出将包括一个退出代码。
gdb命令
相应的gdb命令是“run”。
示例
(gdb)
断开插入主
^done, bkpt={number="1",addr="0x0001072c",file="recursive2.c",line="4"} (gdb)
-exec-run^运行（gdb）
*已停止，reason=“breakpoint-hit”，disp=“keep”，bkptno=“1”，
frame={func="main",args=[],file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="4"} (gdb)
程序正常退出：
(gdb)
-exec-run^运行（gdb）
x= 55
*停止，原因=“正常退出”（gdb）
程序异常退出：
(gdb)
-exec-run^运行（gdb）
x= 55
*停止，原因=“退出”，退出代码=“01”（gdb）
程序终止的另一种方式是如果它接收到诸如SIGINT之类的信号。在这种情况下，gdb/mi显示如下：
(gdb)
*已停止，reason=“exited-signalled”，signal-name=“SIGINT”，signal-meaning=“Interrupt”
exec-step命令
概要
-exec-step[--reverse]
恢复下级程序的执行，当到达下一行源代码的开头时停止，前提是下一行不是函数调用。如果是，则在被调用函数的第一条指令处停止。如果指定了“--reverse”选项，则恢复下级程序的反向执行，在先前已执行的源代码行的开头处停止。
gdb命令
相应的gdb命令是“step”。
样例
进入一个函数：
-exec-step^运行
(gdb)
*停止，原因=“结束步长范围”，
frame={func="foo",args=[{name="a",value="10"},{name="b",value="0"}],file="recursive2.c",
fullname="/home/foo/bar/recursive2.c",line="11"} (gdb)
定期踏步：
-exec-step^运行
(gdb)
*停止，原因=“end-stepping-range”，行=“14”，文件=“r ecursive2.c”（gdb）
exec-step-instruction命令
概要
-exec-step-instruction [--reverse]
恢复执行一个机器指令的子程序。如果指定了“--reverse”选项，则恢复子程序的反向执行，在上次执行的指令处停止。一旦g db停止，输出会根据我们在源代码行中是否中途停止而有所不同。在前一种情况下，还会打印程序停止的地址。
gdb命令
相应的gdb命令是“stepi”。
样例
(gdb)
-执行步骤指令^运行
(gdb)
*停止，原因=“结束步长范围”，
frame={func="foo",args=[],file="try.c",
fullname="/home/foo/bar/try.c",line="10"} (gdb)
-执行步骤指令^运行
(gdb)
*停止，原因=“结束步长范围”，
frame={addr="0x000100f4",func="foo",args=[],file="try.c",
fullname="/home/foo/bar/try.c",line="10"} (gdb)
exec-until命令
概要
-exec-until[位置]
执行子程序，直到到达参数中指定的位置。如果没有参数，则子程序执行到比当前行更高级的源行为止。在这种情况下停止的原因将是“位置已到达”。
gdb命令
相应的gdb命令是“until”。
样例
(gdb)
-执行直到recursive2.c：6^运行
(gdb) x= 55
*已停止，reason=“location-reached”，frame={func=“main”，args=[]，
file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="6"} (gdb)
27.14 gdb/mi堆栈操作命令
stack-info-frame命令
概要
-堆栈信息帧
获取所选帧的信息。
gdb命令
相应的gdb命令是“infoframe”或“frame”（不带参数）。
样例
(gdb)
-堆栈信息帧
^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"} (gdb)
stack-info-depth命令
概要
-stack-info-depth[max-depth ]
返回堆栈的深度。如果指定了整数参数max-depth，则不要计算超过max-depth的帧。
gdb命令
没有等效的gdb命令。
样例
对于具有帧级0至11的堆栈：（gdb）
-stack-info-depth^已完成，深度=“12”（gdb）
-堆栈信息深度4^完成，深度=“4”
(gdb)
-堆栈信息深度12^完成，深度=“12”
(gdb)
-堆栈信息深度11
^完成，深度=“11”（gdb）
-堆栈信息深度13^完成，深度=“12”
(gdb)
堆栈列表参数命令
概要
-stack-list-argumentsprint-values[低帧率高帧率]
显示低帧和高帧（包括）之间的帧参数列表。如果未提供低帧和高帧，则列出整个调用栈的参数。如果两个参数相等，则显示相应层级的单个帧。如果低帧大于实际帧数，这将是一个错误。另一方面，高帧可能大于实际帧数，在这种情况下，仅返回存在的帧。
如果print-values是0或--no-values，则只打印变量的名称；如果它是1或--all-values，则打印它们的值；如果它是2或--simple-values，则打印简单数据类型的名称、类型和值，以及数组、结构体和联合体的名称和类型。
不建议使用此命令来获取单个框架中的参数，而应使用“-stack-list-variables”命令。
gdb命令
gdb没有等效的命令。gdbtk有一个“gdb_get_args”命令，它与“-stack-list-args”的功能部分重叠。
样例
(gdb)
-堆栈列表帧^完成，
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"},
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"},
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"},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"},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"}] (gdb)
-stack-list-arguments 0^完成，
堆栈参数=[
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^完成，
堆栈参数=[
frame={level="0",args=[]},frame={level="1",
args=[{name=“strarg”，value=“0x11940\”字符串参数。}\“]}，frame={level=”2“，args=[
{name="intarg",value="2"},
{name="strarg",value="0x11940\"A stringargument.\""}]},
{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
^完成，stack-args=[frame={level=“2”，args=[name=“intarg”，name=“strarg”]}]（gdb）
-stack-list-arguments 1 2 2
^完成，stack-args=[frame={level=“2”，args=[{name=“intarg”，value=“2”}，
{name="strarg",value="0x11940\"A stringargument.\""}]}] (gdb)
stack-list-frames命令
概要
-堆栈列表帧[低帧高帧]
列出当前堆栈上的帧。对于每个帧，它显示以下信息：‘级别’帧号，0是最高帧，即最内层函数。
‘addr’该帧的$pc值。‘func’函数名。
‘file’源文件的文件名，其中函数驻留。‘line’与$pc相对应的行号。
如果调用时没有参数，此命令会打印整个堆栈的回溯。如果有两个整数参数，它会显示级别介于这两个参数之间的所有帧（包括这两个参数）。如果两个参数相等，则显示相应级别的单个帧。如果低级帧数大于实际的帧数，则视为错误。另一方面，高级帧数可能大于实际的帧数，在这种情况下，只会返回现有的帧。
gdb命令
相应的gdb命令是backtrace和where。
完整堆栈回溯：（gdb）
-堆栈列表帧^完成，堆栈=
[frame={level="0",addr="0x0001076c",func="foo",
file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="11"},frame={level="1",addr="0x000107a4",func="foo",
file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="14"},frame={level="2",addr="0x000107a4",func="foo",
file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="14"},frame={level="3",addr="0x000107a4",func="foo",
file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="14"},frame={level="4",addr="0x000107a4",func="foo",
file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="14"},frame={level="5",addr="0x000107a4",func="foo",
file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="14"},frame={level="6",addr="0x000107a4",func="foo",
file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="14"},frame={level="7",addr="0x000107a4",func="foo",
file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="14"},frame={level="8",addr="0x000107a4",func="foo",
file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="14"},frame={level="9",addr="0x000107a4",func="foo",
file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="14"},frame={level="10",addr="0x000107a4",func="foo",
file=“recursive2.c”，fullname=“/home/foo/bar/recursive2.c”，line=“14”}，frame={level=“11”，addr=“0x00010738”，func=“main”，
file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="4"}] (gdb)
显示低帧和高帧之间的帧：（gdb）
-堆栈列表帧3 5^完成，堆栈=
[frame={level="3",addr="0x000107a4",func="foo",
file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="14"},frame={level="4",addr="0x000107a4",func="foo",
file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="14"},frame={level="5",addr="0x000107a4",func="foo",
file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="14"}] (gdb)
显示单帧：（gdb）
-stack-list-frames 3 3^完成，stack=
[frame={level="3",addr="0x000107a4",func="foo",
file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="14"}] (gdb)
stack-list-locals命令概要
-stack-list-localsprint-values
显示所选帧的局部变量名。如果print-值为0或--no-值，则只打印变量名；如果它为1或--all-值，则还打印它们的
值；如果它是2或简单值，打印名称、类型和值，对于简单数据类型，以及名称和类型，对于数组、结构和联合体。在最后一种情况下，前端可以立即显示简单数据类型的值，并在用户希望更详细地探索其他数据类型的价值时创建变量对象。
此命令已被弃用，取而代之的是“-stack-list-variables”命令。
gdb命令
gdb中的“infolocals”，gdbtk中的“gdb_get_locals”。
样例
(gdb)
-stack-list-locals 0
^完成，本地人=[name=“A”，name=“B”，name=“C”]（gdb）
-stack-list-locals--所有值
^done, locals=[{name="A",value="1"},{name="B",value="2"},{name="C",value="{1, 2,3}"}]
-stack-list-locals--简单值
^done, locals=[{name="A",type="int",value="1"},
{name="B",type="int",value="2"},{name="C",type="int [3]"}] (gdb)
堆栈列表变量Comm和
概要
-stack-list-variablesprint-values
显示选定帧的局部变量和函数参数的名称。如果print-values是0或--no-values，则仅打印变量的名称；如果它是1或--all-values，则还打印它们的值；如果它是2或--simple-values，则打印简单数据类型的名称、类型和值，以及数组、结构体和联合体的名称和类型。
样例
(gdb)
-stack-list-variables--线程1--帧0--所有值
^done, variables=[{name="x",value="11"},{name="s",value="{a= 1, b=2}"}] (gdb)
stack-select-frame命令
概要
-堆栈选择帧帧号
更改所选的帧。在堆栈上选择不同的帧framenum。
此命令已被弃用，建议将--frame选项传递给每个命令。
gdb命令
相应的gdb命令为frame、up、down、select-frame、up-silent和down-silent。
(gdb)
-堆栈选择框2
^done (gdb)
27.15 gdb/ mi可变对象
变量对象简介
变量对象是一种面向对象的MI接口，用于检查和更改表达式的值。与其他一些处理表达式的工作MI接口不同，变量对象专门设计用于前端的简单高效展示。变量对象通过字符串名称来标识。当创建一个变量对象时，前端会指定该变量对象的表达式。这个表达式可以是一个简单的变量，也可以是一个任意复杂的表达式，甚至可以涉及CPU寄存器。创建变量对象后，前端可以调用其他变量对象操作——例如获取或更改变量对象的值，或者更改显示格式。
变量对象具有层次树结构。任何对应于复合类型的变量对象，例如C语言中的结构体，都包含多个子变量对象，例如每个元素对应的结构体。子变量对象本身也可以有子对象，递归地进行。当到达叶节点变量对象时，递归终止，这些叶节点变量对象总是具有内置类型。子变量对象仅通过显式请求创建，因此如果前端不关注某个特定变量对象的子对象，则不会创建任何子对象。
对于叶变量对象，可以将其值转换为字符串，或者从字符串中设置其值。非叶变量对象也可以获取字符串值，但通常这只是一个表示对象类型而不列出其内容的字符串。不允许将值赋给非叶变量对象。
前端无需每次程序停止时都读取所有变量对象的值。相反，MI提供了一个更新命令，列出了自上次更新操作以来所有值发生变化的变量对象。这大大减少了必须传输到前端的数据量。如上所述，子变量对象按需创建，只有叶变量对象具有实际值。因此，gdb仅会读取前端创建的叶变量的目标内存。
自动更新并不总是理想的选择。例如，前端可能希望保留某个表达式的值以供将来参考，而不会对其进行更新。再比如，对于嵌入式目标而言，获取内存相对较慢，因此前端可能希望禁用那些不在屏幕上显示或已“关闭”的变量的自动更新。这可以通过所谓的“冻结变量对象”来实现。这些变量对象永远不会被隐式更新。
可变对象可以是固定的或浮动的。对于固定的可变对象，在创建该对象时解析表达式，包括将标识符关联到特定变量。表达式的含义始终不变。对于浮动的可变对象，每次在当前框架的上下文中评估表达式中出现的变量名称时，都会计算这些变量的值。考虑这个例子：
voiddo_work( . . .){
structwork_statestate;
如果
do_work（. ..）；
}
如果在此函数中创建一个固定变量对象作为状态变量，并且我们进入递归调用，那么该变量对象将在top-leveldo_work调用中报告状态值。另一方面，浮动变量对象将在当前帧中报告状态值。
如果在创建固定变量对象时指定的表达式引用了局部变量，该变量对象就会绑定到创建该变量对象的线程和框架中。当此类变量对象被更新时，gdb会确保该变量对象所绑定的线程/框架组合仍然存在，并在该线程/框架的上下文中重新评估该变量对象。
以下是定义用于访问此函数的gdb/mi操作的完整集合-
| ality: | |
| 操作 | 描述 |
| 启用pretty-printing | 启用基于Python的漂亮打印 |
| -变量创建 | 创建可变对象 |
| -变量删除 | 删除变量对象和/或其子项 |
| -变量集格式 | 设置此变量的显示格式 |
| -变量显示格式 | 显示此变量的显示格式 |
| -儿童信息编号 | 告诉这个物体有多少个孩子 |
| -var-list-children | 返回对象子项的列表 |
| -变量信息类型 | 显示此变量对象的类型 |
| -变量信息表达式 | 打印此变量对象所代表的父级/相对表达式 |
| -var-info-path-expression | 打印此变量对象所代表的完整表达式 |
| -显示属性 | 此变量是否可编辑？它是否存在于此处？ |
| -变量-评估表达式 | 获取此变量的值 |
| -变量分配 | 设置此变量的值 |
| -变量更新 | 更新变量及其子项 |
| -变量集已冻结 | 设置冻结属性 |
| -变量集更新范围 | 设置更新时显示的儿童范围 |
在下一小节中，我们将详细描述每个操作，并建议如何使用它。
变量对象操作的描述和用法
enableprettyprint命令-enableprettyprint
gdb允许基于Python的可视化程序影响MI变量对象命令的输出。但是，由于无法以完全向后兼容的方式实现此功能，因此前端必须请求启用此功能。
启用此功能后，将无法禁用。
请注意，如果Python支持没有编译到gdb中，此命令仍然会成功（但不会执行任何操作）。
此功能目前（在gdb 7.0中）是实验性的，未来版本的gdb可能以不同的方式工作。
var-create命令
概要
-var-create{name|"-"}
{frame-addr|“*”|“@”}表达式
此操作创建一个可变对象，该对象允许监视可变、表达式的结果、存储单元或CPU寄存器。
名称参数是用于引用对象的字符串。它必须是唯一的。如果指定“-”，varobj系统将自动生成字符串“var NNNNNN”。只要不指定该格式的名称，它将是唯一的。如果找到重复的名称，则命令将失败。
表达式应被评估的框架可以通过frame-addr指定。A‘*’表示应使用当前框架。A‘@’表示必须创建一个浮动变量对象。
表达式是当前语言集上的任何有效表达式（不能以“*”开头），或者是以下表达式之一：
•‘*addr，其中，addr是存储单元的地址
•‘*addr-addr’—一个内存地址范围（TBD）
•‘$regname’—CPU寄存器名称
变量对象的内容可以由基于Python的漂亮打印器提供。在这种情况下，变量对象被称为动态变量对象。动态变量对象在某些情况下具有略微不同的语义。如果未发送启用漂亮打印命令，则gdb将永远不会创建动态变量对象。这确保了现有客户端的向后兼容性。
结果
此操作返回新创建的varobj的属性。这些属性包括：‘name’varobj的名称。
numchild
varobj的子对象数量。对于动态varobj，此数目不一定可靠。必须检查“has_more”属性。
“值”varobj的标量值。对于类型为某种聚合体（例如，结构）的varobj或动态varobj，该值将不具任何意义。
“类型”varobj的类型。这是类型的字符串表示形式，将由gdb CLI打印。
‘thread-id’
如果可变对象绑定到特定线程，则此为该线程的标识符。
‘还有更多’
对于动态varobj，这表示是否显示任何可用子项。对于非动态varobj，这将为0。
‘dynamic’如果varobj是一个d ynamic varobj，则此属性将存在并且具有值‘1’。如果varobj不是d ynamic varobj，则此属性将不存在。
displayhint
动态varobj可以向前端提供显示提示。该值直接来自Pythonpretty-printer object的sdisplay_hint方法。请参见第23.2.2.6[PrettyPrinting]节，第269页。
典型输出将如下所示：
name=“name”，numchild=“N”，type=“type”，thread-id=“M”，有更多=“有更多”
var-delete命令
概要
-var-delete[-c]名称
删除先前创建的变量对象及其所有子项。使用“-c”选项，仅删除子项。
如果找不到对象名称，则返回错误。var-set-format命令
-var-set-formatname格式-spec
设置对象名称值的输出格式为format-spec。format-spec的语法如下：
格式规范‘→
{binary | decimal| hexadecimal| octal| natural}
自然格式是根据变量类型自动选择的默认格式（例如，对于int值，选择decimal；对于指针，选择hex等）。
对于具有子项的变量，仅在该变量本身上设置格式，而子项不受影响。
var-show-format命令
概要
-var-show-format名称
返回用于显示对象名称值的格式。
format→
格式规范
var-info-num-children命令
-变量信息-子名称
返回变量objectname的子对象数：numchild=n
请注意，对于动态varobj，此数字并不完全可靠。它将返回当前子项数，但可能还有更多子项可用。
var-list-children命令
-var-list-children[打印值]名称[从到]
返回指定变量对象的子列表，并为它们创建变量对象，如果这些变量不存在的话。如果只有一个参数或print-values的值为0或--无值，则仅打印变量的名称；如果printvalues是1或--所有值，则同时打印它们的值；如果它是2或--简单值，则对于简单数据类型打印名称和值，而对于数组、结构体和联合体则仅打印名称。
如果指定了from和to，则表示要报告的子项范围。如果from或to小于零，则重置范围并报告所有子项。否则，将报告从from (基于零）开始至to为止的子项。
如果请求一个子范围，这仅会影响当前调用var-list-children的操作，而不会影响未来的var-update调用。为此，您必须使用var-set-update-range。这种方法的目的是让前端能够实现任何它喜欢的更新方式；例如，滚动视图可能会导致前端请求更多的children通过var-list-children，然后前端可以调用var-set-update-range并提供不同的范围，以确保未来的更新仅限于可见项目。
对于每个孩子，返回以下结果：
name为该子对象创建的变量对象的名称。
exp前端显示给用户以指定此子项的表达式。
例如，这可能是结构构件的名称。
对于动态varobj，此值不能用于形成表达式。使用动态varobj时根本无法做到这一点。
对于C/C++结构，有多个p假儿童返回以指定访问限定符。对于这些假儿童，exp是“public”、“private”或“protected”。在这种情况下，类型和值不存在。
动态varobj不会报告访问限定的伪子，不管使用何种语言。动态varobj无法提供此信息。
numchild此子对象所拥有的子对象数。对于动态varobj，此值为0。
类型子类型的类型。
value如果请求了值，则为该值。
thread-id如果此变量对象与线程相关联，则这是threadid。其他-
明智的做法是，这个结果并不存在。
如果变量对象被冻结，此变量将具有值1。结果可能具有自己的属性：
displayhint
动态varobj可以向前端提供显示提示。该值直接来自Pythonpretty-printer object的sdisplay_hint方法。请参见第23.2.2.6[PrettyPrinting]节，第269页。
‘还有更多’
这是一个整数属性，如果在选定范围结束之后仍有子项，则该属性为非零。
样例
(gdb)
-var-list-children n
^done, numchild=n,children=[child={name=name, exp=exp ,
numchild=n，type=type}（重复N次）]（gdb）
-var-list-children--all-values n
^完成，numchild=n，children=[child={name=name，exp=exp，numchild=n，value=value，type=type}，（rep eatsN times）]
var-info-type命令
概要
-var-info-type名称
返回指定变量名的类型。该类型以与gdbCLI输出的相同格式作为字符串返回：
type=typename
命令上的var-info-expression
概要
-var-info-expression名称
返回一个字符串，该字符串适合在用户界面中显示此变量对象。该字符串通常不是当前语言中的有效表达式，因此无法进行评估。
例如，如果a是一个数组，并且为a创建了变量对象A，则我们将得到以下输出：
（gdb）-var-info-expression A.1^done，lang=“C”，exp=“1”
在此，lang的值可以为“C”|“C++”|“Java”。
请注意，var-list-children命令的输出也包括这些表达式，因此var-info-expression命令的作用有限。
var-info-path-expression命令
-var-info-path-expression名称
返回一个可以在当前上下文中评估的表达式，该表达式的值与变量对象具有相同的值。请将其与-var-info-expression命令进行比较，后者的返回值仅可用于用户界面显示。-var-info-path-expression命令的典型用法是从变量对象创建一个观察点。
此命令目前对动态varobj的子对象无效，如果在e上调用此命令，将会出现错误。
例如，假设C是一个从类Base派生的aC++类，并且类Base有一个名为m_size的成员。假设变量c是a的类型，类型为C，并且为变量c创建了对象C。那么，我们将得到这样的输出：
（gdb）-var-info-path-expression C .Base .public.m_size^done，path_expr=（（Ba se）c）.m_size)
var-show-attribut es命令
概要
-var-show-属性名
列出指定变量objectname的属性：status=attr[（，attr）*]
其中attr是{ {editable|non editable}| TBD}。
var-evaluate-expression命令
概要
-var-evaluate-expression [-f format-spec]名称
评估指定变量对象所表示的表达式，并返回其值作为字符串。可以使用‘-f’选项指定字符串的格式。此选项的可能值与var-set-format的相同（参见[-var-set-format]， 第327页 ）。如果未指定“-f”选项，则将使用当前显示格式。可以使用var-set-fo rmat命令更改当前显示格式。
value=value
请注意，在可以评估子变量的值之前，必须调用var-list-children函数。
var-assign命令
概要
-var-分配名称表达式
将表达式的值赋给按名称指定的变量object。该对象必须是“可编辑”的。如果变量的值被assign改变，则该变量将显示在任何后续的var-up date列表中。
(gdb)
-var-assign var1 3^done，value=“3”
(gdb)
-var-update*
^完成，changelist=[{name=“var1”，in_scope=“true”，type_changed=“false”}]（gdb）
var-update命令
概要
-var-update[打印值]{name|“*”}
重新评估与变量对象名称及其所有直接和间接子对象相对应的表达式，并返回值已更改的变量对象列表；名称必须是根变量对象。这里，“已更改”意味着在变量更新前后，-var-evaluate-expression的结果不同。如果使用‘*’作为变量对象名称，则除了冻结的对象外，所有现有变量对象都会被更新（参见[-var-set-frozen]，第332页。 ）。optionprint-values确定是否打印名称和值，或者仅打印名称。此选项的可能值与var-list-children的值相同（参见[-var-list-children]，第328页 ）。建议使用“--all-values”选项，以减少每个程序停止时所需的MI命令数量。
使用“*”参数，如果变量对象绑定到当前运行的线程，则不会更新该变量对象，且没有任何诊断信息。
如果之前在varobj上使用了-var-set-update-range，则仅报告所选的子项范围。
-var-update报告名为“change list”的元组中所有更改的varobjs。更改列表中的每个项目本身都是一个元组，包含：
‘name’varobj的名称。
‘value’如果为此更新请求了值，则此字段将存在，并且将保存varobj的值。
此字段是一个字符串，可以取三个值之一：“true”变量object的当前值有效。
“错误”变量对象当前不持有有效值，但可能
如果相关的表达式重新进入作用域，则将来会保留一个。
无效的
变量对象不再持有有效的值。当正在调试的可执行文件通过重新编译或使用gdb file命令而发生更改时，可能会出现这种情况。前端通常会选择删除这些变量对象。
未来可能会向该列表添加新的值，因此应为这种可能性做好准备。请参见第27.6节[GDB/MI开发和前端]， 第294页 .
‘类型已更改’
只有当varobj仍然有效时，才会出现此情况。如果类型已更改，则此值为字符串“true”；否则，该值为“false”。
‘新类型’
如果varobj的类型已更改，则此字段将存在，并且将保存新类型。
‘new_num_children’
对于动态varobj，如果子项数量发生变化，或者类型发生变化，则这是子项的新数量。
其他变量对象响应中的“numchild”字段通常对非动态变量对象无效—它将显示gdb知道的子对象数量，但由于动态变量对象会延迟地实例化其子对象，因此这将不能反映可能可用的子对象数量。
‘new_num_children’属性仅报告gdb所知子项数量的变化。这是检测更新是否删除了子项的唯一方法（这必然只能在更新范围结束时发生）。
displayhint
显示提示，如果有。
‘还有更多’
这是一个整数值，如果varobj的更新范围之外还有其他可用的子项，则该值为1。
‘dynamic’如果varobj是一个d ynamic varobj，则此属性将存在并且具有值‘1’。如果varobj不是d ynamic varobj，则此属性将不存在。
‘新儿童’
如果在选定的更新范围（由var-set-update-range设置）内向动态varobj添加新儿童，则它们将被列在此属性中。
样例
(gdb)
-var-assign var1 3^done，value=“3”
(gdb)
-var-update--所有值var1
^完成，changelist=[{name=“var1”，value=“3”，in_scope=“true”，
type_changed=“false”]（gdb）
-var-set-frozen名称标志
设置变量对象名称的冻结标志。标志参数应为‘1’以使变量冻结，或‘0’以使其解冻。如果一个变量对象被冻结，则该对象及其所有子对象都不会因父变量的-var-update或-var-update*而隐式更新。只有该变量自身的-var-update才会更新其值及其子对象的值。变量对象解冻后，所有后续的-var-update操作都会隐式更新它。解冻变量不会立即更新，只有后续的-var-update才会更新。
样例
(gdb)
-var-set-frozen V 1
^done (gdb)
var-set-update-range命令
概要
-from到的var-set-update-range名称
设置将来调用var-update时返回的子范围。
用于指示要报告的儿童范围。如果从或到小于零，则重置范围，并报告所有儿童。否则，从从（零开始）到并排除到的儿童将被报告。
样例
(gdb)
-var-set-update-range V 1 2^完成
var-set-visualizer逗号nd
概要
-var-set-visualizer名称visualizer
为变量对象名称设置可视化器。
visualizer是要使用的可视化程序。特殊值“None”表示禁用任何正在使用的可视化程序。
如果不是“None”，可视化器必须是一个表达式中的Pyth on对象。该表达式必须评估为一个可调用的对象，接受单个参数。gdb将以变量对象名称的值作为参数调用此对象（这样做是为了使相同的Pyth on好看打印代码既适用于命令行界面也适用于交互式模式）。当调用时，此对象必须返回一个符合漂亮打印接口的对象（参见第23.2.2.6[漂亮打印]节，第269页）。
预定义的functiongdb.default_visualizer可以通过遵循内置过程来选择可视化器（请参见第23.2.2.7[SelectingPretty-Printers]节，第2 71页）。当创建varobj时，此过程会自动执行，因此通常不需要。
只有启用Python支持时才可用此功能。MI command-list-features（请参见第347页第27.22[GDB/MI Miscellaneous Commands]节）)可用于检查这一点。
重置可视化器：（gdb）
-var-set-visualizer V未完成^done
重新选择默认的（基于类型）可视化器：（gdb）
-var-set-visualizer Vgdb.default_visualizer^完成
假设SomeClass是一个可视化类。可以使用lambda表达式为varobj实例化此类：
(gdb)
-var-set-visualizerV“lambdaval：SomeClass（）”^完成
27.16 gdb/mi数据操作
本节介绍用于操作的thegdb/mi命令：检查内存和寄存器、评估表达式等。
数据解压缩命令
概要
-数据拆分
[-sstart-addr -e end-addr ]
|[-ffilename -l linenum[-nlines ]]
--模式其中：
‘起始地址’
是起始地址（或$pc）
‘端口号’
是结束地址
filename
是用于反编译的文件名
‘linenum’是要围绕其拆分的行号
‘行数’是要生成的反汇编行数。如果为-1，则整个函数将被反汇编，除非指定了end-地址。如果end-地址指定为非零值，且行数小于start-地址和end-地址之间的反汇编行数，则仅显示行数；如果行数大于start-地址和end-地址之间的行数，则仅显示到end-地址的行数。
“mode”为0（表示仅反汇编）或1（表示混合源代码和反汇编）。
结果
每个指令的输出由四个字段组成：
·地址
·功能名称
抵消
·指导
请注意，无论指令字段中包含什么内容，都不可直接由gdb/mi进行操作，即无法调整其格式。
gdb命令
此命令与CLI之间没有直接映射。
样例
从当前值$pc拆分为$pc+20：（gdb）
-数据-拆卸-s$pc-e“$pc+20”--0^完成
asm_ insns=[
{address=“0x000107c0”，func-name=“main”，offset=“4”，inst=“mov 2，%o0”
{address=“0x000107c4”，func-name=“main”，offset=“8”，inst=“seti%hi（0x11800），%o2”
{address="0x000107c8",func-name="main",offset="12",
inst=”或%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=“”或%o2,0x168，%o4\t！0x11968<_lib_version+48>}]（gdb）
拆卸整个主功能。第32行是主功能的一部分。
-数据拆解基础.c-l 32--0^完成，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条指令：（gdb）
数据分解基础.c-l 32-n 3--0^完成，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条指令：
(gdb)
数据拆解基础.c- l 32-n 3--1^完成，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)
数据评估表达式命令
概要
数据-评估表达式expr
将expr作为表达式进行评估。该表达式可以包含下述函数调用。函数调用将同步执行。如果表达式包含空格，则必须将其置于双引号中。
gdb命令
相应的gdb命令是print、output和call，在gd btk中，还有一个对应的gdb_eval命令。
样例
在下面的示例中，命令前的数字是第292页第27.4[ gdb/ mi命令语法]节中描述的标记 注意gdb/ mi在输出中返回相同的标记。
211-data-evaluate-expression A211^已完成，值=“1”
(gdb)
311-data-evaluate-expression&A311^done，值=“0xefffeb7c”
(gdb)
411-data-evaluate-expressionA+3411^已完成，value=“4”
(gdb)
511-data-evaluate-expression“A+3”
511^完成，值=“4”（gdb）
data-list-changed-registers命令
数据列表更改寄存器
显示已更改的寄存器列表。
gdb命令
gdb没有这个命令的直接模拟器；gdbtk有对应的命令‘gdb_changed_register_list’。
样例
在PPC MBXboard上：
(gdb)
-exec-继续^运行中
(gdb)
*已停止，reason=“breakpoint-hit”，disp=“keep”，bkptno=“1”，frame={func=“main”，args=[]，file=“try.c”，fullname=“/home/foo/bar/try.c”，
line="5"} (gdb)
数据列表更改寄存器
^完成，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命令
概要
-数据列表-注册名称[（regno）+]
显示当前目标的寄存器名称列表。如果没有给出参数，则显示所有寄存器名称的列表。如果以整数形式给出参数，则会打印与参数相对应的寄存器名称列表。为了确保寄存器名称与其编号之间的一致性，输出列表中可能包含空的寄存器名称。
gdb命令
gdb没有一个与‘-data-list-register-names’相对应的comm，而在gdbtk中有一个对应的命令‘gdb_regn ames’。
样例
对于PPC MBXboard：
(gdb)
-数据列表-注册名称
^已完成，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)
数据列表注册表名称1 2 3
^完成，寄存器名称=[“r1”，“r2”，“r3”]（gdb）
data-list-register-values命令
数据列表寄存器值fmt[（regno）*]
显示寄存器的内容。fmt是返回寄存器内容的格式，后面可选地列出要显示的寄存器编号。缺少的编号列表表示必须返回所有寄存器的内容。
允许的格式为：x十进制
o八位
t二进制r十进制r原始
N自然
gdb命令
相应的gdb命令为“inforeg”、“infoall-reg”和（在gdbtk中）“gdb_fetch_registers”。
样例
对于PPC MBX板（注：换行只是为了便于阅读，实际输出中不会出现换行）：
(gdb)
数据列表寄存器值r 64 65
^完成，register-values=[{number=“64”，value=“0xfe00a300”}，
{ number="65", value="0x00029002"}] (gdb)
-数据列表-注册值x
^完成，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="0 xfa202820"},{ number="10", value="0 xfa202808"},
{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="0 xfe 010000"},
{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="0 xfe 00a300"},
{ number="65", value="0x29002"},{ number="66", value="0x202f04b5"},
{ number="67", value="0 xfe0043b0"},{ number="68" , value="0 xfe00b3e4"},
{ number="69", value="0x20002b03"}] (gdb)
数据读取内存命令
概要
-data-read-memory [ -o字节偏移量]地址字节格式字节大小
nr-行nr-列[aschar]
在哪里
address指定要读取的第一个内存字的地址的表达式。包含嵌入空白的复杂表达式应使用C规约进行引用。
‘文字格式’
用于打印内存字的格式。该符号与gdb的sprint命令的符号相同（请参见第10.5[输出格式]节，第97页）。
‘字长’
每个内存字的大小，以字节为单位。
‘nr-rows’输出表中的行数。
‘nr-cols’输出表中的列数。
‘aschar’如果存在，则表示每一行都应包含一个ascii转储。当字节不是可打印ascii字符集的成员时，aschar的值用作填充字符（可打印ascii字符是指代码在32到126之间的字符）。
‘字节偏移量’
在获取内存之前要添加到地址上的偏移量。
此命令以nr行nr列的表格形式显示内存内容，每行包含字大小的字节。总共读取nr行*nr列*字大小的字节
（返回为“总字节数”）。如果目标返回的字节数少于请求的数量，则使用“N/A”标识缺失的字节。从目标读取的字节数以“nr-字节”返回，用于读取内存的起始地址以“addr”返回。
在“下一行”和“上一行”、“下一页”和“上一页”中提供了下一行/上一行或p页的地址。
gdb命令
相应的gdb命令是x。gdbtk有gdb_get_mem内存读取命令。
样例
从字节+6开始读取6个字节的内存，然后向后偏移-6个字节。格式为三行两列。每个单词一个字节。以十六进制显示每个单词。
(gdb)
9-数据读取内存-o -6 --字节+6 x 1 3 2
9^完成，addr=“0x00001390”，nr-bytes=“6”，total-bytes=“6”，
下一行=“0x00001396”，上一行=“0x0000138e”，下一页=“0x00001396”，上一页=“0x0000138a”，内存=[
{ addr="0x00001390", data=["0x00","0x01"]},{ addr="0x00001392", data=["0x02","0x03"]},{ addr="0x00001394", data=["0x04","0x05"]}] (gdb)
从地址shorts+ 64开始读取两个字节的内存，并以十进制格式显示为一个单词。
(gdb)
5-数据读取存储器短路+64 d 2 1 1
5^完成，addr=“0x00001510”，nr-bytes=“2”，total-bytes=“2”，下一行=“0x00001512”，上一行=“0x0000150e”，
下一页=“0x00001512”，上一页=“0x0000150e”，内存=[
{ addr="0x00001510", data=["128"]}] (gdb)
读取从字节+16开始的32个字节内存，并以8行4列的格式显示。包括一个字符串编码，其中使用x作为不可打印字符。
(gdb)
4-数据读取内存字节+16 x 1 8 4 x
4^完成，addr=“0x000013a0”，nr-bytes=“32”，total-bytes=“32”，下一行=“0x000013c0”，上一行=“0x0000139c”，
下一页=“0x000013c0”，上一页=“0x00001380”，内存=[
{ 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)
27.17 gdb/ mi Tracepoint命令
尚未实现跟踪点命令。
27.18 gdb/ mi符号查询命令
symbol-list-lines命令
-symbol-list-lines文件名
打印包含代码的行及其相关程序地址的列表，这些行和程序地址属于给定的源文件名。条目按升序的程序计数器顺序排序。
gdb命令
没有相应的gdb命令。
样例
(gdb)
-symbol-list-lines basics .c
^完成，行=[{pc=“0x08048554”，line=“7”}，{pc=“0x0804855a”，line=“8”}]（gdb）
27.19 gdb/ mi文件命令
本节介绍用于指定可执行文件名以及读入和获取符号表信息的GDB/ MI命令。
file-exec-and-symbols命令
概要
-file-exec-and-symbols文件
指定要调试的可执行文件。该文件也是读取符号表的来源。如果没有指定文件，命令会清除可执行文件和符号信息。如果在没有参数的情况下使用此命令设置断点，gdb将产生错误消息。否则，除了完成通知外，不会生成任何输出。
gdb命令
相应的gdb命令是“file”。
样例
(gdb)
-file-exec-and-symbols/kwikemart/marge/ezannoni/TRUNK/mbx/hello .mbx
^done (gdb)
file-exec-file命令
概要
-文件-exec-file文件
指定要调试的可执行文件。与“-file-exec-and-symbols”不同，符号表不会从该文件中读取。如果未使用参数，gdb将清除有关可执行文件的信息。除了完成通知外，不生成任何输出。
gdb命令
相应的gdb命令是“exec-file”。
(gdb)
-file-exec-file/kwikemart/marge/ezannoni/TRUNK/mbx/he你好。mbx
^done (gdb)
-file-list-exec-source-file命令
概要
-file-list-exec-源文件
列出行号、当前源文件和当前可执行文件的当前源文件的绝对路径。宏信息字段的值为“1”或“0”，这取决于文件是否包含预处理器宏信息。
gdb命令
gdb的等效命令是“infosource”
样例
(gdb)
123-文件列表执行源文件
123^完成，line=“1”，file=“foo.c”，fullname=“/home/bar/foo.c，macro-info=”1“（gdb）
-file-list-exec-source-fi文件命令
概要
-file-list-exec源文件
列出当前可执行文件的源文件。
它将始终输出文件名，但只有当gdb能够找到源文件的绝对文件名时，它才会输出完整文件名。
gdb命令
gdb的等效命令是“infosources”。gdbtk有一个类似的命令“gdb_listfiles”。
样例
(gdb)
-file-list-exec-source-files^完成，文件=[
{file=foo.c,fullname=/home/foo.c},
{file=/home/bar .c，fullname=/home/bar.c}，{file=gdb_could_not_find_fullpath.c}]
(gdb)
file-symbol-file命令
-file-symbol-file文件
从指定的文件参数中读取符号表信息。如果不带参数使用，则清空sgdb的符号表信息。除了完成通知外，不产生任何输出。
gdb命令
相应的gdb命令是“symbol-file”。
样例
(gdb)
-file-symbol-file/kwikemart/marge/ezannoni/TRUNK/mbx/hello .mbx
^done (gdb)
27.20 gdb/mi目标操作命令
目标附加命令
概要
目标-附加pid| gid|文件
附加到进程pid或gdb外的文件file，或线程组gid。如果附加到线程组，则必须使用先前由‘-list-thread-groups--available’返回的id。
gdb命令
相应的gdb命令是“attach”。
样例
(gdb)
-目标-附加34
=thread-created，id=“1”
*已停止，thread-id=“1”，frame={addr=“0xb7f7e410”，func=“bar”，args=[]}
^done (gdb)
target-detach命令
概要
-target-detach[ pid|gid ]
从远程目标分离，该远程目标通常会继续执行。如果指定了pid或gid，则从指定的进程或指定的线程组分离。没有输出。
gdb命令
相应的gdb命令是“detach”。
(gdb)
-目标分离
^done (gdb)
目标断开命令
概要
-断开目标
断开与远程目标的连接。没有输出，且通常不会恢复目标。
gdb命令
相应的gdb命令是“disconnect”。
样例
(gdb)
-断开目标
^done (gdb)
目标下载命令
概要
-目标下载
将可执行文件加载到远程目标上。它每半秒打印一条更新消息
第二，包括以下字段：
‘部分’部分的名称。‘section-sent’
到目前为止，这一部分所发送的内容的大小。
‘截面尺寸’
截面的尺寸。
‘总发送量’
迄今为止发送的邮件的总大小（当前和之前的邮件）。“total-size”
要下载的可执行文件的大小。
每条消息都以状态记录的形式发送（请参见第293页的27.4.2[gdb/mi输出语法]部分 ).
此外，它还会打印下载的章节的名称和大小。这些
消息包括以下字段：“section”部分的名称。“section-size”部分的大小
截面的尺寸。
‘总大小’
下载的可执行文件的总大小。最后，打印摘要。
gdb命令
相应的gdb命令是“load”。
样例
注意：每个状态消息显示在一行上。这里消息被拆分，以便可以显示在一页上。
(gdb)
-目标下载
+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"}
^完成，address=“0x10004”，load-size=“9880”，transfer-rate=“6586”，
写速率=“429”（gdb）
gdb命令没有等效命令。
N.A.
target-select命令
概要
-target-select类型参数...
将gdb连接到远程目标。此命令接受两个参数：type目标类型，例如remote等等。
因素
设备名称、主机名等。更多详细信息，请参见第19.2节[用于管理目标的命令]，第200页。
输出为连接通知，随后是目标程序所在地址，如下所示：
^connected，addr=“地址”，func=“函数名”，args=[参数列表]
gdb命令
相应的gdb命令是“target”。
样例
(gdb)
-选择目标-远程/dev/ttya
^connected, addr="0xfe00a300",func="??",args=[] (gdb)
27.21 gdb/ mi文件传输命令
target-file-put命令
概要
-target-file-put主机文件targetfile
将主机系统（运行gdb的机器）上的文件hostfile复制到目标系统上的目标文件targetfile。
gdb命令
相应的gdb命令是“r emoteput”。
(gdb)
-target-file-put localfile remotefile
^done (gdb)
target-file-get命令
概要
-target-file-get tar getfile主机文件
将目标系统上的文件targetfile复制到主机系统上的hostfile。
gdb命令
相应的gdb命令是’remoteget’。
样例
(gdb)
-target-file-get远程文件本地文件
^done (gdb)
target-file-delete命令
概要
-target-file-delete targetfile
从目标系统中删除targetfile。
gdb命令
相应的gdb命令是“remote delete”。
样例
(gdb)
-target-file-delete远程文件
^done (gdb)
The-gdb-exit命令
概要
-退出gdb
立即退出gdb。
gdb命令
大致相当于“退出”。
(gdb)
-gdb-exit^exit
The-gdb-set命令
概要
-gdb-set
设置内部gdb变量。
gdb命令
相应的gdb comm和is‘set’。
样例
(gdb)
-gdb-set$foo=3
^done (gdb)
The- gdb- show命令
概要
-显示-gdb
显示gdb变量的当前值。
gdb命令
相应的gdb命令是“show”。
样例
(gdb)
-gdb-show annotate^done，值=“0”
(gdb)
The-gdb-version Comm和
概要
-gdb-version
显示gdb的版本信息。主要用于测试。
gdb命令
gdb的等效命令是“showversion”。在启动交互式会话时，默认情况下，gdb将显示此信息。
样例
(gdb)
-gdb-version
~GNU gdb 5 .2 .1
~版权所有2000 Free Software Foundation，Inc。
~GDB是免费软件，受GNU通用公共许可证保护，~欢迎您修改它和/或在以下条件下分发它的副本
~某些条件。
~键入“显示复制”以查看条件。
~对GDB没有任何保证。请注明“展示保修”
~详情。
~此GDB配置为
“--host=sparc-sun-solaris2.5.1--target=ppc-eabi”。
^done (gdb)
列表功能Comm和
返回一个列表，列出此版本的gdb实现的MI协议的具体特性。这些特性可以是命令，也可以是在某些命令输出中的新字段，甚至是一个重要的错误修复。虽然前端有时可以在运行时检测到特性，但在调试器启动时进行检测更为简便。
该命令返回一个字符串列表，每个字符串表示一个可用的功能。返回的每个字符串只是一个名称，没有内部结构。可能的功能名称列表如下所示。
示例输出：
（gdb）-list-features
^完成，结果=[“feature1”，“feature2”]当前的特征列表是：
‘冻结变量’
指示var-set-frozen命令的存在，以及varobj-create输出中可能存在的对冻结字段的预感。
‘待断点’
指示break-insert命令中是否存在th‘-f’选项。
‘python’表示存在Python脚本支持、基于Python的漂亮打印命令，以及输出var-list-children中可能存在的‘display_hint’字段
‘线程信息’
指示是否存在thread-info命令。The-list-target-features命令
返回目标支持的特定功能列表。这些功能影响允许的MI命令，但与通过-list-features命令报告的功能不同，这些功能取决于当前正在使用的哪个目标GDB。每当目标因诸如-target-select、-target-attach或-exec-run等命令而发生变化时，目标功能列表可能会改变，前端应重新获取该列表。示例输出：
（gdb）-list-features
^done, result=["async"]
当前功能列表为：
‘async’表示目标能够执行异步命令，这意味着在目标运行时，gdb将接受更多的命令。
list-thread-groups命令
-list-thread-groups [--available] [ --recurse 1] [ group... ]
列出线程组（请参见第291页的“27.3.3[Thread groups]”一节 ）。当传递单个线程组作为参数时，列出该组的子线程组。当传递多个线程组时，列出这些线程组的信息。如果没有参数，则列出所有顶级线程组的信息。
通常情况下，会报告正在调试的线程组。使用“--available”选项时，gdb会报告目标t上可用的线程组。
此命令的输出可以是“线程”结果或“组”结果。“线程”结果的值是一个元组列表，每个元组描述一个线程（请参见第27.7.5[ GDB/ MI线程信息]节，第298页 ）。`groups`的结果是一个元组列表，每个元组描述一个线程组。如果请求的是顶级组（即不传递参数），或者当传递多个组时，输出始终具有`groups`结果。`group`结果的格式如下所述。
要减少往返次数，可以列出线程组，以便与他们的孩子一起，通过传递‘--recurse’选项和递归深度。目前，仅允许递归深度为1。如果此选项存在，则每个报告的线程组还将包括其子线程，无论是作为‘group’还是‘threads’字段。
一般情况下，允许使用选项和参数的任意组合，但有以下注意事项：
当传递单个线程组时，输出通常为线程的结果。由于线程可能不包含任何内容，因此将忽略“递归”选项。
当传递了“--可用”选项时，可能只能获取有限的信息。特别是，进程的线程列表可能无法访问。此外，指定特定的线程组可能不会比列出所有线程组带来任何性能优势。前端应假设“-列出线程组--可用”始终是一项昂贵的操作，并缓存结果。
“”组的结果是一个元组列表，其中每个元组可能具有以下字段：id线程组的标识符。此字段始终存在。
类型线程组的类型。目前，只有“进程”是有效的类型。
pid目标特定进程标识符。此字段仅存在于类型为“process”的线程组中。
num_children
此线程组中的儿童数量。对于可用的线程组，此字段可能不存在。
线程此字段有一个值为元组的列表，每个元组描述一个线程。它可能
如果指定了“--recurse”选项，则会显示该选项，而且实际上可以获取这些线程。
cores这个字段是一个整数列表，每个整数标识组中一个线程的核心
正在运行。如果此类信息不可用，则此字段可能不存在。
gdb
-列表线程组
^完成，groups=[{id=“17”，type=“process”，pid=“yyy”，num_children=“2”}]-list-thread-groups 17
^已完成，线程=[{id=“2”，target-id=“Thread 0 xb 7e14b90（LWP 21257）”，
frame={level=“0”，addr=“0xffffe410”，func=“__kernel_vsyscall”，args=[]}，state=“running”}，{id=“1”，目标-id=“Thread 0 xb 7e156b0（LWP 21254）”，
frame={level="0",addr="0x0804891f",func="foo",args=[{name="i",value="10"}],
file="/tmp/a.c",fullname="/tmp/a.c",line="158"},state="running"}]]-list-thread-groups--available
^完成，groups=[{id=“17”，type=“process”，pid=“yyy”，num_children=“2”，cores=[1,2]}]-list-thread-groups--available--recurse 1
^完成，groups=[{id=“17”，types=“process”，pid=“yyy”，num_children=“2”，cores=[1,2]，threads=[{id=“1”，target-id=“Thread0xb7e14b90”，cores=[1]}，
{id=“2”，target-id=“Thread 0xb7e14b90”，cores=[2]}]}，..]-list-thread-groups--available--recurse 1 17 18
^完成，groups=[{id=“17”，types=“process”，pid=“yyy”，num_children=“2”，cores=[1,2]，threads=[{id=“1”，target-id=“Thread0xb7e14b90”，cores=[1]}，
{id=“2”，target-id=“Thr ead0xb7e14b90”，cores=[2]}]}，...]The-interpreter-exec命令
-解释器-exec解释器命令
在指定的解释器中执行指定的命令。
gdb命令
相应的gdb命令是interpreter-exec。
样例
(gdb)
-解释器-exec console“breakmain”
&“符号读取期间，无法解析类型；调试器过时？。\n”&“符号读取期间，结构类型格式错误。\n”
~“断点1在0x8074fc6：文件../ ../src/gdb/main.c，行743。\n”
^done (gdb)
inferior-tty-set命令
概要
-inferior-tty-set/dev/pts/1
设置程序调试的未来运行的终端。
gdb命令
相应的gdb命令是“setinferior-tty”/dev/pts/1。
(gdb)
-inferior-tty-set/dev/pts/1
^done (gdb)
inferior-tty-show命令
概要
-低级电视节目
显示调试程序的未来运行的终端。
gdb命令
相应的gdb命令是“showinferior-tty”。
样例
(gdb)
-inferior-tty-set/dev/pts/1
^done (gdb)
-下级电视节目
^完成，inferior_tty_terminal=“/dev/pts/1”（gdb）
enable-timings命令
概要
-启用定时器[是|否]
在输出中将MI命令作为字段，切换显示墙钟、用户和系统时间的打印状态。此命令有助于前端开发人员优化代码性能。没有参数等同于“yes”。
gdb命令没有等效命令。
样例
(gdb)
-启用计时
^done (gdb)
断开插入主
^done, bkpt={number="1",type="breakpoint",disp="keep",enabled="y",addr="0x080484ed",func="main",file="myprog.c",
fullname="/home/nickrob/myprog.c",line="73",times="0"},
time={ wallclock="0.05185", user="0.00800", system="0.00000"} (gdb)
启用定时器no^完成
(gdb)
-exec-run^正在运行
(gdb)
*已停止，reason=“breakpoint-hit”，disp=“keep”，bkptno=“1”，thread-id=“0”，frame={addr=“0x080484ed”，func=“main”，args=[{name=“argc”，value=“1”}，
{name="argv",value="0xbfb60364"}],file="myprog.c",
fullname="/home/nickrob/myprog.c",line="73"} (gdb)
扫一扫
2668
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
