dbx 命令

用途

提供了一个调试和运行程序的环境。

语法

dbx [-a ProcessID] [-B DebugFile] [-c CommandFile] [-I Directory] [-E DebugEnvironment] [-p oldpath=newpath: ... | pathfile] [-u] [-F] [-L ] [-r] [-x] [-v] [-C CoreFile | ObjectFile [CoreFile]]

描述

dbx 命令为 C、C++ 和 Fortran 程序提供了符号调试程序，可让您执行以下操作：

检验对象和核心文件。
为程序运行提供一个控制环境。
在选中的语句处设置断点或单步执行程序。
使用符号变量进行调试并将它们以正确的格式进行显示。

ObjectFile 参数是一个由编译器产生的对象（可执行）文件。编译程序时使用 -g (生成符号表) 标志以生成 dbx 命令所需的信息。

注: 编译对象文件时，必须使用 cc 命令的 -g 标志。如果未使用 -g 标志，或者如果使用 strip 命令从 xcoff 文件中除去符号引用，那么 dbx 命令的符号功能将受到限制。此外，请勿使用 -O 编译器选项来优化您计划使用 dbx进行调试的可执行文件。优化操作将重新编排代码，并在调试数据方面取得折中，进而限制了用 dbx 命令来调试可执行程序的值。

如果未指定 -c 标志，那么 dbx 命令将检查用户的 $HOME 目录中的 .dbxinit 文件。然后它在用户当前目录中检查 .dbxinit 文件。如果在当前目录中存在一个 .dbxinit 文件，该文件将覆盖用户的 $HOME 目录中的 .dbxinit 文件。如果 .dbxinit 文件存在于用户的 $HOME 目录或当前目录中，那么该文件的子命令将在调试会话开始时运行。使用编辑器创建一个 .dbxinit 文件。

如果不指定 ObjectFile，那么 dbx 将询问要进行检查的对象文件的名称。缺省值为 a.out。如果当前目录中存在 core 文件或者指定了 CoreFile 参数，那么 dbx 将报告程序发生错误的位置。开始执行 ObjectFile 之前，可能会检查保存在核心映像中的变量、寄存器和内存。那时 dbx 调试程序提示输入命令。

使用 -B 标志来指定包含启动相关调试信息的备用对象文件或单独 .stab 文件。只有在连接至进程时才能指定备用对象文件。从此备用对象文件或 .stab 调试文件而不是从正在运行的进程的磁盘副本中读取调试信息。此备用对象文件必须是原始对象文件的完整副本；否则，它将被忽略。当调试节大小过大时使用 -B 标志。请在运行时使用对象文件的完整副本而在调试时使用非完整副本。可通过 –bstabsplit 链接程序选项生成 .stab 调试文件。如果未对可执行文件 stabsplit 指定 -B 标志，那么 dbx 命令将尝试从可执行文件目录获取相应的 .stab 文件。

表达式处理

dbx 程序可以显示各种各样的表达式。可以在 dbx 调试程序中使用 C 语法和一些 Fortran 扩展来指定表达式。

以下运算符在调试程序中有效：

项	描述
* (星号) 或 ^ (插入标记)	表示正在取消引用间接寻址或者指针。
[] (方括号) 或 () (括号)	表示数组表达式的下标。
. (句点)	通过指针和结构来使用该字段引用运算符。此运算符使 C 运算符-> (箭头) 是不必要的，尽管它是允许的。
及	获得变量的地址。
.. (两个句点)	在指定数组子部分时将上下界分开。例如：n[1..4]。

以下类型的运算在调试程序的表达式中有效：

项	描述
代数运算	=、-、、/（浮点运算的除法）、div（整数运算的除法）、mod* 和 exp（乘幂运算）。
按位运算	-, 我, 比特, 西或, ~. <<, >>
逻辑	或, 和, 不, 二., &&
比较运算	<， >， <=， >=， < > 或 !=， = 或 ==
其他	（类型名），sizeof

允许逻辑表达式和比较表达式作为 stop 和 trace中的条件。

检验表达式类型。您可以通过重命名或者重载运算符的方式重设一个表达式类型。三种重命名的格式分别是：类型名（表达式），表达式 |类型名以及（类型名）表达式。以下是一个示例，其中 x 变量是一个值为 97 的整数：

(dbx) print x
97
(dbx) print char (x), x \ char, (char) x, x
'a' 'a' 'a' 97

命令行编辑

dbx 命令提供的一种命令行编辑功能类似于 Korn Shell 程序提供的功能。 vi 方式提供了 vi-like 编辑功能，而 emacs 方式提供了类似于 emacs的控件。

可以使用 dbx 子命令 set -o 或 set edit来打开这些功能部件。要开启 vi 样式的命令行编辑，请输入子命令 set edit vi 或 set -o vi。

您也可以使用 EDITOR 环境变量来设置编辑方式。

dbx 命令会将命令行中输入的命令的历史记录保存在历史记录文件 .dbxhist 中。如果没有设置环境变量 DBXHISTFILE，那么会使用历史记录文件 $HOME/.dbxhist。

缺省情况下，dbx 将保存最近输入的 128 个命令的文本。 DBXHISTSIZE 环境变量可以从来增加该限制。

标志

项	描述
-a `ProcessID`	将调试程序和正在运行的进程连接起来。要连接调试程序，您需要向此进程发送信号的权限。使用 ps 命令来决定进程标识。如果您具有许可权，那么 dbx 程序将使用 ptrace 系统调用来中断该进程，以向该进程发送 SIGTRAP 信号，这不能忽略 SIGTRAP 信号。然后，dbx 确定对象文件的全名、读入符号信息，并提示输入命令。
-B`DebugFile`	此标志可让您在启动时指定备用调试文件。
-c `CommandFile`	读入标准输入之前，在文件中运行 dbx 子命令。 $HOME 目录中指定的文件将首先被处理；然后处理当前目录中的文件。当前目录中的命令文件将会覆盖 $HOME 目录中的命令文件。如果指定的文件既不存在于 $HOME 目录也不存在于当前目录，将会显示警告消息。一旦启动了 dbx 程序，就可以使用 source 子命令。
-C `CoreFile`	在未指定对象文件的情况下分析核心文件。在此情况下，dbx 命令会使用核心文件中提到的对象文件（如果该文件存在于当前目录中并且与核心文件相匹配）。否则，它会在没有对象文件的情况下继续处理。如果在 -r 标志或 -a 标志后使用此标志，那么此标志会被忽略。
-E `DebugEnvironment`	指定调试程序的环境变量。
-p `oldpath=newpath: ... \| pathfile`	使用格式 `oldpath=newpath` 在检查核心文件或连接进程时指定替换的库路径。 `oldpath` 变量指定了将被替换的值（存储在核心文件中或连接时进程的装入程序部分）。 `newpath` 变量指定将被替换的内容。 `oldpath` 变量和 `newpath` 变量可以是完整路径、部分路径、相对路径或绝对路径。可以指定多个替换，它们之间用冒号隔开。或者，-p 标志可指定文件名，将从该文件读取采用先前描述格式的映射。每行中只允许有一个映射从文件中读出。如果在连接进程时使用 -p 标志，那么从被替换路径文件中读取调试信息。路径文件必须与正在运行的库的副本匹配。
-F	可用于关闭延迟读取方式，并使 dbx 命令在启动时读取所有符号。缺省情况下，缓读方式是打开的：它仅读取有关 dbx 会话初始化的必需符号表信息。在此方式下，对于未读取其符号信息的局部变量和类型，dbx 不会读取这些局部变量和类型。因此，诸如 whereis i 等命令并不会列示每个函数中局部变量 i 的所有实例。
-L	保留链接符号。
-I`Directory`	（大写 i）将 `Directory` 变量指定的目录包含到搜索源文件目录列表中。搜索源文件的缺省目录为：文件编译时该源文件所在的目录。只有编译器设置了对象中的源路径时才能搜索目录。当前目录。当前程序所在的目录。
-r	立即运行对象文件。如果它成功结束，dbx 调试程序将会退出。否则，将会进入调试程序并报告中断的原因。注: 除非指定了 -r ，否则 dbx 命令会提示用户并等待命令。
-u	让 dbx 命令为文件名加上 @（at 符号）前缀。该标志减少符号名混淆的可能性。
-v	导致 dbx 命令跳过核心文件的有效性检验。此标志允许您分析核心文件的有效部分，即使某些部分无效时也是如此。
-x	防止 dbx 命令除去来自 Fortran 源代码的符号中的 _（拖尾下划线）字符。此标志允许 dbx 区分除下划线字符以外的相同符号，例如`xxx`和`xxx_`.

示例

以下示例说明如何与进程同时启动 dbx 调试程序。此示例使用名为 samp.c的程序。此 C 程序首先使用 -g 标志进行编译，以生成包含符号表引用的对象文件。在此情况下，该程序命名为：samp：
```
$ cc -g samp.c -o samp
```
samp 程序运行后，操作系统会报告一个总线错误并将核心映像写入到您当前的工作目录中，如下所示：
```
$ samp
Bus Error - core dumped
```
要确定发生错误的位置，请输入：
```
$ dbx samp
```
系统将会返回如下消息：
```
dbx version 3.1
Type 'help' for help.
reading symbolic information . . . [
using memory image in core]
  25   x[i] = 0;
(dbx) quit
```
此示例说明如何将 dbx 附加到流程。该示例使用了如下程序 looper.c：
```
main()
{
      int i,x[10];
       
      for (i = 0; i < 10;);
}
```
因为 i 永不递增，所以程序永不终止。使用 -g 标志编译 looper.c 以获取符号调试功能:
```
$ cc -g looper.c -o looper
```
从命令行运行 looper ，并执行以下步骤以在运行程序时将 dbx 连接到该程序:
1. 要将 dbx 连接到 looper，必须确定进程标识。如果您没有运行 looper 作为后台进程，您必须启动另外一个 Xwindow 窗口。在此 Xwindow 窗口中，输入：
```
ps -u UserID
```
  其中 UserID 是您的登录标识。所有属于您的活动的进程将会显示如下所示：
```
PID     TTY      TIME    COMMAND
68      console   0:04    sh
467     lft3     10:48    looper
```
  在此示例中，与 looper 关联的进程标识为467.
2. 要将 dbx 连接到 looper，请输入:
```
$ dbx -a 467
```
  系统将会返回如下消息：
```
Waiting to attach to process 467 . . .
Successfully attached to /tmp/looper.
dbx is initializing
Type 'help' for help.
reading symbolic information . . .
 
attached in main at line 5
5     for (i = 0; i < 10;);
(dbx)
```
  您现在可以查询和调试进程，就像最初使用 dbx 来启动了该进程。
要将目录添加到要搜索可执行文件 objfile的源文件的目录列表中，可以输入:
```
$dbx -I /home/user/src -I /home/group/src 
objfile
```
一旦启动 dbx ， use 子命令可能用于此函数。 use 命令重新设置目录清单，而 -I 标志则向清单中添加目录。

要使用 -r 标志，请输入:

$ dbx -r samp

系统将会返回如下消息：

Entering debug program . . .
dbx version 3.1
Type 'help' for help.
reading symbolic information . . .
bus error in main at line 25
  25   x[i] = 0;
(dbx) quit

虽然没有设置核心映像，但 -r 标志仍然允许您检查内存中进程的状态。

要指定调试程序的环境变量，请输入：

dbx -E LIBPATH=/home/user/lib -E LANG=Ja_JP objfile

要在连接至进程时指定备用对象文件和库，请输入：
```
dbx –a 467 –B debug_samp –p /usr/lib/=./dir/debug_libs/
```
要在启动时指定独立的调试文件，请输入：
```
 dbx –B /usr/debug_samp.stab debug_samp
```

dbx 子命令

注: 子命令只能在运行 dbx 调试程序时使用。

项	描述
/	在当前源文件中向前搜索某种模式。
?	在当前源文件中向后搜索某种模式。
addcmd	将 dbx 子命令添加到指定的事件号。
alias	为 dbx 子命令创建别名。
assign	为一个变量赋值。
attribute	显示所有或者选中属性对象的信息。
call	运行与指定的过程或函数相关的对象代码。
case	更改 dbx 调试程序解释符号的方式。
catch	在一个信号送到应用程序之前启动捕获此信号。
clear	除去特定源程序行处的所有停止点。
cleari	除去地址中所有的断点。
condition	显示全部或者选中的条件变量的信息。
cont	从当前停止点继续应用程序的执行直到程序终止或者遇到下一个断点。
corefile	显示有关核心文件的高级数据。
coremap	显示特定地址空间区域的映射。
delcmd	删除与指定事件号关联的 dbx 子命令。
delete	除去与线程的指定事件号和 tskip 计数对应的跟踪和停止。
detach	继续应用程序的执行并退出调试程序。
disable	禁用与指定事件号对应的跟踪和停止。
display memory	显示内存中的内容。
down	将当前函数在堆栈中向下移动。
dump	显示指定过程中的变量的名称和值。
edit	启动编辑器编辑指定文件。
enable	启用与指定事件号对应的跟踪和停止。
fd	显示文件描述符信息。
file	将当前源文件修改成指定的文件。
frame	将当前函数更改为对应指定堆栈帧号的函数。
func	将当前函数修改成指定的过程或者函数。
goto	使所指定的源行成为要运行的下一行。
gotoi	修改程序计数器地址。
handler	显示有关 pthread atfork 或取消清除处理程序的信息。
help	显示 dbx 子命令或主题的帮助信息。
ignore	在一个信号送到应用程序之前停止捕获此信号。
kthread	显示有关内核线程的信息。
limitbp	限制可以运行断点的次数。
list	显示当前源文件的行。
listi	列示应用程序的指令清单。
malloc	显示有关程序使用 malloc 子系统的信息。
map	显示关于应用程序装入特征的信息。
move	跳到下一行并显示。
multproc	启用或禁用多线程调试。
mutex	显示全部或者选中的互斥信息。
next	运行应用程序直到下一个源程序行。
nexti	运行应用程序，直到下一条机器指令。
onceblock	显示有关 once 块的信息。
plugin	调用插件子命令或显示可用插件名称。
pluginload	装入插件。
pluginunload	卸载插件。
print	显示表达式的值，或者运行一个过程，并显示该过程的返回码。
printbp	显示断点的运行次数。
proc	显示有关进程的信息。
prompt	更改 dbx 命令提示符。
quit	停止 dbx 调试程序。
registers	显示所有通用寄存器、系统控制寄存器、浮点寄存器和当前指令寄存器的值。
重新运行	按照以前设置的参数开始运行应用程序。
resource	显示有关 pthread 拥有或等待的资源的信息。
return	继续应用程序的运行直到达到返回一个指定的过程。
rwlock	显示有关 rwlock 的信息。
run	开始运行一个应用程序。
screen	打开 Xwindow 以进行 dbx 命令交互。
set	为 dbx 调试程序变量定义值。
sh	传递命令到 shell 去运行。
skip	从当前的停止处继续运行应用程序。
source	从文件中读取 dbx 子命令。
status	打印有关断点的详细信息。它还显示活动跟踪， stop 子命令和其余线程 tskip 计数。
step	运行一个源命令行。
stepi	运行一条机器指令。
stophwp	设置一个硬件的观察点停止。
stop	停止运行应用程序。
stopi	在指定位置设置停止点。
thdata	显示特定于线程的数据。
thread	显示和控制线程。
tls	显示 TLS 初始化模板信息。
tm_status	显示存储在 `$texasr` 变量中的值，并对其进行解释。
tnext	运行线程直到下一个源程序行。
tnexti	运行线程，直到下一条机器指令。
trace	打印跟踪信息。
tracehwp	设置硬件观察点跟踪。
tracei	打开跟踪。
tskip	跳过线程断点。
tstep	为一个源程序行运行一个线程。
tstepi	为一条机器指令运行线程。
tstop	为线程设置源程序级断点停止。
tstophwp	设置线程级硬件观察点停止。
tstopi	为线程设置指令级断点停止。
ttrace	为线程设置源程序级跟踪。
ttracehwp	设置线程级硬件观察点跟踪。
ttracei	为线程设置指令级跟踪。
unalias	删除别名。
unset	删除一个变量。
up	将当前函数在堆栈中向上移动。
use	设置在搜索源文件时要搜索的目录列表。
whatis	显示应用程序组件的声明。
where	显示活动过程和函数的清单。
whereis	显示所有名称匹配指定标识的符号的全限定。
which	显示所指定标识的全限定。

/子命令

/ [ RegularExpression [ / ] ]

/ 子命令在当前源文件中向前搜索由 RegularExpression 参数指定的模式。输入不带自变量的 / 子命令将导致 dbx 向前搜索先前的正则表达式。搜索将会在文件的结尾折返。

示例

要在当前源文件中向前搜索数字 12 ，请输入:
```
/ 12
```
要重复先前的搜索，请输入:
```
/
```

请参阅 ? (search) 子命令和 regcmp 子例程。

? 子命令

? [ RegularExpression [ ? ] ]

? 子命令在当前源文件中向后搜索 RegularExpression 参数指定的模式。在不带参数的情况下输入 ? 子命令可促使 dbx 命令向后搜索先前的正则表达式。搜索将会在文件的结尾折返。

示例

要在当前源文件中向后搜索字母z，请输入:
```
?z
```
要重复先前的搜索，请输入:
```
?
```

请参阅 / (search) 子命令和 regcmp 子例程。

addcmd 子命令

addcmd { 编号... | 全部 } "命令字符串

addcmd 子命令将 dbx 子命令添加到指定事件。每当执行对应于此特定事件的断点、跟踪点或观察点时，都会运行该事件。可以通过 "commands_string" 参数指定 dbx 子命令，该参数是一组以分号 (;) 分隔的 dbx 子命令。可以通过 Number 参数指定要将 dbx 子命令添加到的事件，也可以使用 all 标志将 dbx 子命令添加到所有事件。

标志

项	描述
all	将 dbx 子命令添加到所有事件。

示例

要将 where 子命令添加到事件号 1 ，请输入:
```
addcmd 1 "where"
```
要将 registers 子命令添加到事件号 2 ，请输入:
```
addcmd 2 "registers"
```
要将 where 和 registers 子命令添加到事件号 3 ，请输入:
```
addcmd 3 "where;registers"
```

请参阅 clear 子命令， delcmd 子命令， delete 子命令， disable 子命令， enable 子命令， stop 子命令， status 子命令和 trace 子命令。另请参阅在 常规编程概念: 编写和调试程序 中中的 "设置和删除断点"。

alias 子命令

alias [ Name [ [ (Arglist) ] String | Subcommand ] ]

alias 子命令为 dbx 子命令创建别名。 Name 参数是要创建的别名。 String 参数是一系列 dbx 子命令，在执行此子命令之后，可以通过 Name来引用这些子命令。如果 alias 子命令没有指定参数，那么它将显示所有当前的别名。

示例

要替换rrforrerun，请输入:
```
alias rr rerun
```
要运行两个子命令print n和stepWHENEVERprintandstep在命令行上输入，请输入:
```
alias printandstep "print n; step"
```
alias子命令也可以用作有限的宏工具。例如：
```
(dbx) alias px(n) "set $hexints; print n; unset $hexints"
(dbx) alias a(x,y) "print symname[x]->symvalue._n_n.name.Id[y]"
(dbx) px(126)
0x7e
```
在此示例中，别名px打印十六进制值，而不会永久影响调试环境。

assign 子命令

assign 变量=表达式

assign 子命令将 Expression 参数指定的值分配到由 Variable 参数指定的变量。

示例

要指定值，请执行以下操作:5IBM Think 大会之x变量，输入:
```
assign x = 5
```
要分配y变量到x变量，输入:
```
assign x =  y
```
要分配字符值'z'IBM Think 大会之z变量，输入:
```
assign  z  =  'z'
```
要分配布尔值false到逻辑类型变量B，请输入:
```
assign  B  =  false
```
要分配"Hello World"字符串到字符指针Y，请输入:
```
assign  Y  =  "Hello  World"
```
要禁用类型检查，请设置 dbx 调试程序变量$unsafeassign通过输入:
```
set $unsafeassign
```

请参阅显示和修改变量。

attribute 子命令

attribute [ AttributeNumber ... ]

attribute 子命令显示关于 AttributeNumber 参数定义的用户线程、互斥或者条件属性对象的相关信息。如果未指定任何参数，那么会列示所有属性对象。

对于列示的每个属性对象，将显示如下信息：

项	描述
`attr`	指示属性对象的符号名称，格式为`$aAttributeNumber`.
`obj_addr`	指示属性对象的地址。
`type`	指示属性对象的类型; 此值可以是`thr`,`mutex`，或`cond`分别针对用户线程，互斥对象和条件变量。
`state`	指示属性对象的状态。此值可以是`valid`或`inval`.
`stack`	指示线程属性对象的堆栈大小属性。
`scope`	指示线程属性对象的作用域属性。此值确定线程的争用作用域，并定义与该线程争用处理资源的线程集。值可以是`sys`或`pro`用于系统或进程争用作用域。
`prio`	指示线程属性对象的优先级属性。
`sched`	指示线程属性对象的调度策略属性。此属性控制调度策略，并且可以`fifo`,`rr`(循环) ，或`other`.
`p-shar`	指定互斥或条件属性对象的进程共享属性。如果可以由不同进程的线程访问，该互斥或条件是进程共享的。值可以是`yes`或`no`.
`protocol`	指示互斥对象的协议属性。该属性决定了保持线程优先级互斥的作用。值可以是`no_prio`,`prio`，或`protect`.
`clock`	显示条件属性对象的时钟属性。该属性确定将等待条件变量的线程指定为超时的时候必须使用的时钟。该值可以是 `realtime` 或 `monotonic`。

注意：

dbx 调试程序的 print 子命令识别符号属性名称，还可用于显示相应对象的状态。
可用的属性取决于 POSIX 选项的实现。

示例

要列示所有属性的信息，请输入：

attribute

输出类似于：

attr   obj_addr   type  state  stack   scope    prio 
sched p-shar
$a1   0x200035c8  mutex valid                                no 
$a2   0x20003628  cond  valid                                no
$a3   0x200037c8  thr   valid  57344    sys      126 other
$a4   0x200050f8  thr   valid  57344    pro      126 other

要列出有关属性 1 和 3 的信息，请输入:

attribute 1 3

输出类似于：

attr   obj_addr   type  state  stack   scope    prio 
sched p-shar
$a1   0x200035c8  mutex valid                                no 
$a3   0x200037c8  thr   valid  57344    sys      126 other

请参阅 condition 子命令， mutex 子命令， print 子命令和 thread 子命令以获取 dbx 命令。

另请参阅 常规编程概念: 编写和调试程序中的创建线程，使用互斥对象和使用条件变量。

call Subcommand

callProcedure ( [ Parameters ] )

call 子命令运行由 Procedure 参数指定的过程。不会显示返回码。如果指定了参数，它们将传给正在运行的过程。

注: call 子命令不能用于调用采用向量参数的函数。

示例

要在运行 dbx 命令时调用命令，请输入：

(dbx) call printf("hello")
hello

printf 成功返回。

case 子命令

case [ 默认 | 混合 | 下部 | 上部 ]

case 子命令修改 dbx 调试程序解释符号的方式。缺省的符号处理视当前使用的语言而定。如果当前语言是 C、C++ 或未定义，那么不会折转符号；如果当前语言是 Fortran，那么会将符号折转为小写。如果符号需要使用与当前语言不一致的方法解释，那么使用该子命令。

输入不带参数的 case 子命令将显示当前个案方式。

标志

项	描述
缺省值	随当前语言变化。
混合	按实际显示的情况解释符号。
较低	按小写来解释符号。
上限	按大写来解释符号。

示例

要显示当前案例方式，请输入:
```
case
```
要指示 dbx 在符号实际出现时对其进行解释，请输入:
```
case mixed
```
要指示 dbx 将符号解释为大写，请输入:
```
case upper
```

请参阅将变量折叠到小写和大写。

catch 子命令

catch [ SignalNumber | SignalName ]

catch 子命令在信号送到应用程序之前启动捕获此信号。该子命令在调试应用程序处理例如中断之类的信号时非常有用。待捕获的信号可以分别用 SignalNumber 参数按号码或者用 SignalName 参数按名称来指定。信号名不区分大小写，而前缀 SIG 为可选。如果不指定 SignalNumber 和 SignalName 参数，那么缺省情况下会捕获 SIGHUP、SIGCLD、SIGALARM 和 SIGKILL 信号之外的所有其他信号。如果不指定参数，那么将显示当前能够捕获的信号的列表。

示例

要显示要由 dbx 命令捕获的信号的当前列表，请输入:
```
catch
```
要捕获信号SIGALARM，请输入:
```
catch SIGALARM
```

请参阅 ignore 子命令和处理信号。

clear 子命令

clear SourceLine

clear 子命令除去特定源行处的所有停止。 SourceLine 参数可以按照两种格式指定：

作为整数
作为文件名字符串，后跟: (冒号) 和整数

示例

除去在行上设置的断点19，请输入:

clear 19

cleari 子命令和 delete 子命令。另请参阅在 常规编程概念: 编写和调试程序 中中的 "设置和删除断点"。

cleari 子命令

cleari 地址

cleari 子命令清除由 Address 参数指定的地址的所有断点。

示例

要除去在地址处设置的断点，请执行以下操作:0x100001b4，请输入:
```
cleari 0x100001b4
```
要除去在以下位置设置的断点:main()过程地址，请输入:
```
cleari &main
```

请参阅 clear 子命令， delete 子命令以及在 常规编程概念: 编写和调试程序 中中的 "设置和删除断点"。

condition 子命令

condition [ wait | nowait | ConditionNumber ... ]

condition 子命令显示一个或多个条件变量的相关信息。如果给定了一个或多个 ConditionNumber 参数，那么 condition 子命令将显示有关指定条件变量的信息。如果不指定标志或者参数，condition 子命令列示所有条件变量的清单。

各个条件的信息列表如下所示：

项	描述
`cv`	指示条件变量的符号名称，格式为`$cConditionNumber`.
`obj_addr`	设定条件变量的内存地址。
`clock`	显示条件变量的时钟属性。
`num_wait`	设定条件变量中等待的线程的数量。
`waiters`	列示等待条件变量的用户线程。

注: dbx 调试程序的 print 子命令可识别符号条件变量名称，并可用于显示相应对象的状态。

标志

项	描述
WAIT	显示有等待线程的条件变量。
NOWAIT	显示没有等待线程的条件变量。

示例

要显示有关所有条件变量的信息，请输入:
```
condition
```
要显示有关具有等待线程的所有条件变量的信息，请输入:
condition wait

要显示有关条件变量 3 的信息，请输入:

condition 3

输出类似于：

cv      obj_addr     num_wait  waiters
$c3     0x20003290         0

请参阅 attribute 子命令， mutex 子命令， print 子命令和 thread 子命令。

另请参阅 常规编程概念: 编写和调试程序中的使用条件变量。

cont 子命令

cont [ SignalNumber | SignalName ]

cont 子命令从当前的断点开始继续执行应用程序直到该程序结束或者遇到另外一个断点。如果按 SignalNumber 参数中指定的编号或按 SignalName 参数中指定的名称来指定信号，那么程序会继续运行，就像收到了该信号一样。信号名称不区分大小写，并且 SIG 前缀是可选的。如果不指定信号，那么程序会继续运行，就像没有停止过。

示例

要从当前断点位置继续执行程序，请输入：
```
cont
```
要如同收到 SIGQUIT 信号一样继续执行程序，请输入：
```
cont SIGQUIT
```

请参阅 detach 子命令 (对于 dbx 命令) ， goto 子命令 (对于 dbx 命令) ， next 子命令 (对于 dbx 命令) ， skip 子命令 (对于 dbx 命令) ， step 子命令 (对于 dbx 命令)。

corefile 子命令

corefile 子命令显示核心文件头中的信息，其中包括可执行文件名、核心文件格式版本信息、用于指示哪些数据可用的标志、导致崩溃的信号，以及对核心进行转储的进程的执行方式。

coremap Subcommand

coremap [ 堆栈 | 数据 | sdata | mmap | shm | 加载器 ]

coremap 子命令显示特定地址空间区域的映射。如果不指定区域名称，那么 coremap 子命令会显示所有可用映射。

示例

要显示共享内存区域的映射，请输入：
```
coremap shm
```
要显示内存映射区域的映射，请输入：
```
coremap mmap
```
要显示装入器条目描述的所有区域的映射，请输入：
```
coremap loader
```
要显示所有可用映射，请输入：
```
coremap
```

请参阅 corefile 子命令。

delcmd 子命令

delcmd EventNumber { Number ... | all }

delcmd 子命令除去与指定事件关联的 dbx 子命令。可以通过 Number 参数指定要除去的 dbx 子命令，也可以使用 all 标志除去与指定事件相关联的所有 dbx 子命令。 EventNumber 参数指定要从中除去 dbx 子命令的事件。

标志

项	描述
all	除去与指定事件关联的所有 dbx 子命令。

示例

要从事件号 2 除去所有 dbx 子命令，请输入：
```
delcmd 2 all
```
要从事件号 3 除去 1 号 dbx 子命令，请输入：
```
delcmd 3 1
```
要从事件号 2 除去 1 号和 2 号 dbx 子命令，请输入：
```
delcmd 2 1 2
```

请参阅 addcmd 子命令， clear 子命令， delete 子命令， disable 子命令， enable 子命令， stop 子命令， status 子命令和 trace 子命令。另请参阅在 常规编程概念: 编写和调试程序 中中的 "设置和删除断点"。

delete 子命令

delete { 编号... | 全部 tskip [ for $tthreadnumber ]}

delete 子命令从应用程序中除去跟踪和停止，并对线程进行 tskip 计数。可以通过 Number 参数指定要除去的跟踪和停止，也可以使用 all 标志除去所有跟踪和停止。可使用 status 子命令来显示由 dbx 调试程序使其与跟踪或停止关联的编号。

可以使用 tskip 标志来删除使用线程的 tskip 子命令设置的剩余 tskip 计数。使用 status 子命令来显示剩余线程 tskip 计数。如果未指定任何线程，那么使用当前线程。

标志

项	描述
all	删除所有的跟踪和停止。
for $t `threadnumber`	指定线程号。

示例

要从应用程序中删除所有的跟踪和停止，请输入：
```
delete all
```
要删除事件号为 4 的跟踪和停止，请输入：
```
delete 4
```
要除去线程 3 的 tskip 计数，请输入:
```
delete tskip for $t3
```
要除去当前线程的 tskip 计数，请输入:
```
delete tskip 
```

请参阅 clear 子命令， cleari 子命令， status 子命令， tskip 子命令和在 常规编程概念: 编写和调试程序 中中的设置和删除断点。

detach 子命令

detach [ SignalNumber | SignalName ]

detach 子命令将继续应用程序的执行并退出调试程序。信号可以通过以下任意一项指定：

名称，使用 SignalName 参数
序号，使用 SignalNumber 参数
信号名称不区分大小写，并且 SIG 前缀是可选的。

如果指定信号，那么程序会继续运行，就像收到了该信号。如果不指定信号，那么程序会继续运行，就像没有停止过。

示例

要退出 dbx 而继续执行应用程序，请输入：
```
detach
```
退出 dbx 并继续执行应用程序，就像它接收到信号一样SIGREQUEST，请输入:
```
detach SIGREQUEST
```

请参阅“使用 dbx 调试程序”。

disable 子命令

disable { 数字 ... 全部 }

disable 子命令禁用与调试事件关联的跟踪和停止。要禁用的跟踪和停止可通过 Number 参数指定，或者可使用标志 all 来禁用所有跟踪和停止。可使用 status 子命令来显示由 dbx 调试程序使其与跟踪或停止关联的事件号。

标志

项	描述
all	删除所有的跟踪和停止。

示例

要从应用程序禁用所有跟踪和停止，请输入：
```
disable all
```
要禁用事件号 4 的跟踪和停止，请输入：
```
disable 4
```

有关更多信息，请参阅 enable subcommand， delete subcommand和 status 子命令。

另请参阅 "设置和删除断点" 在 常规编程概念: 编写和调试程序 中。

display memory 子命令

{ 地址，地址/| 地址/ [ 计数 ]} [ 方式 ] [ >文件 ]

display memory 子命令 (没有用于启动命令的关键字) 显示由以下因素控制的内存部分:

显示的内存范围通过指定以下某个方法进行控制：

两个 Address 参数，其中显示这两个地址之间的所有行，
或
一个 Address 参数 (其中显示开始) 和一个 Count 参数 (用于确定从 Address 显示的行数)。

在名称之前加上一个 &（与符号）指定符号地址。地址可以是其他地址和 +（加号）、-（减号）以及 *（间接乘法）运算组成的表达式。任何包含在括号中间的表达式都将认为是一个地址。

显示内存的格式由 Mode 参数控制。 Mode 参数的缺省值为当前方式。 Mode 的初始值为 X。可能的方式包括:

项	描述
博	打印八进制的字节。
c	按字符打印一个字节。
天	按十进制打印一个短字。
深	按十进制打印一个长字。
Df	打印双精度十进制浮点数。
DDf	打印四倍精度的十进制浮点数。
f	打印单精度的实数。
g	打印一个双精度的实数。
h	以十六进制打印一个字节。
Hf	打印单精度十进制浮点数。
i	打印机器指令。
lld	打印带符号的 8 字节十进制数。
llu	打印无符号的 8 字节十进制数。
llx	打印无符号的 8 字节十六进制数。
llo	打印无符号的 8 字节八进制数。
o	按八进制打印一个短字。
O	按八进制打印一个长字。
p	以十六进制格式打印地址/指针。
q	打印一个扩展精度的浮点数。
请	打印一个空字节结尾的字符串。
X	按十六进制打印一个短字。
X	按十六进制打印一个长字。

标志

项	描述
>`文件`	重定向输出到指定的文件。

示例

从地址开始以十六进制显示一个长字的内存内容0x3fffe460，请输入:
```
0x3fffe460 / X
```
将两个字节的内存内容显示为从变量开始的字符y地址，输入:
```
&y / 2c
```
要显示 Fortran 字符串 a_string 的第六到第八个元素，请输入:
```
&a_string + 5, &a_string + 7/c
```

请参阅检查内存地址在 常规编程概念: 编写和调试程序 中。

down 子命令

down [ Count ]

down 子命令将当前函数在堆栈中向下移动 Count 级。当前函数用来解析名称。 Count 参数的缺省值为 1。

示例

要在堆栈中下移一层，请输入:
```
down
```
要在堆栈中下移三个级别，请输入:
```
down 3
```

请参阅 up 子命令， where 子命令和显示堆栈跟踪在 常规编程概念: 编写和调试程序 中。

dump 子命令

dump [ 过程 | "PATTERN"] [ >文件 ]

dump 子命令显示所指定过程中所有变量的名称和值，或者那些与所指定模式匹配的变量。如果 Procedure 参数为句点 (.)，那么会显示所有活动变量。如果指定了 Procedure 或 "PATTERN" 参数，那么将使用当前过程。 "PATTERN" 参数是包含 *， ?和 [] 元字符的通配符表达式。使用 "PATTERN" 时，它将显示全局空间中的所有匹配符号 (来自所有过程)。如果使用 >File 标志，那么输出将重定向到指定的文件。

标志

项	描述
>`文件`	重定向输出到指定的文件。

示例

要显示当前过程中变量的名称和值，请输入:
```
dump
```
要在 add_count 过程中显示变量的名称和值，请输入:
```
dump add_count
```
要显示以字符 s 开头的变量的名称和值，请输入：
```
dump "s*"
```
要将当前过程中变量的名称和值重定向到 var.list 文件，请输入:
```
dump > var.list
```

请参阅显示和修改变量在 常规编程概念: 编写和调试程序 中。

edit 子命令

edit [ Procedure | File ]

edit 子命令会对所指定的文件启动编辑器。要指定文件，可使用 File 参数，或者指定 Procedure 参数，其中会对该过程所在的文件启动编辑器。如果不指定文件，那么会对当前源文件启动编辑器。缺省值为 vi 编辑器。要覆盖缺省值，请将 EDITOR 环境变量重置为所需编辑器的名称。

示例

要对当前源文件启动编辑器，请输入:
```
edit
```
要在以下对象上启动编辑器:main.c文件，请输入:
```
edit main.c
```
要对包含以下内容的文件启动编辑器:do_count()过程，请输入:
```
edit do_count
```

请参阅 list 子命令， vi 或 vedit 命令。

enable 子命令

enable { 数字 ... 全部 }

enable 子命令启用与调试事件关联的跟踪和停止。要启用的跟踪和停止可通过 Number 参数指定，或者可使用标志 all 来启用所有跟踪和停止。可使用 status 子命令来显示由 dbx 调试程序使其与跟踪或停止关联的事件号。

标志

项	描述
all	删除所有的跟踪和停止。

示例

要从应用程序启用所有跟踪和停止，请输入：
```
enable all
```
要启用事件号 4 的跟踪和停止，请输入：
```
enable 4
```

有关更多信息，请参阅 disable subcommand， delete subcommand和 status subcommand。

另请参阅 "设置和删除断点" 在 常规编程概念: 编写和调试程序 中。

fd 子命令

fd [ raw ] [ start [ end ] ]

fd 子命令显示文件描述符信息。使用 raw 选项可导致输出以原始十六进制格式显示。其他可选参数包括 start 和 end 下标。如果未给出下标，那么会显示有关所有可用文件描述符的信息。使用一个下标会显示单个文件描述符，使用两个下标则会显示一个范围值。

示例

要以十六进制查看所有文件描述符的相关信息，请输入：
```
fd raw
```
要查看范围介于 3 到 5 之间的文件描述符的相关信息，请输入：
```
fd 3 5
```

file 子命令

file [ 文件 ]

file 子命令将当前源文件更改为 File 参数指定的文件; 它不会写入该文件。 File 参数可以向文件指定完整路径名。如果 File 参数没有指定路径，那么 dbx 程序通过搜索使用路径试图找到该文件。如果不指定 File 参数，那么 file 子命令将会显示当前的源文件名。如果路径已知，那么 file 子命令还显示文件的完整路径名或相对路径名。

示例

要将当前源文件更改为main.c文件，请输入:
```
file main.c
```
要显示当前源文件的名称，请输入:
```
file
```

请参阅 func 子命令。另请参阅 "更改当前文件或过程" 和 "显示当前文件" 在 常规编程概念: 编写和调试程序 中。

frame 子命令

frame [ 数字 ]

frame 子命令将当前函数更改为与指定堆栈帧号 num对应的函数。当前函数用来解析名称。堆栈帧的编号起始于当前处于活动状态的函数堆栈帧（当前处于活动状态的函数帧总是以 0 为编号）。如果存在 n 帧，那么 main 函数的帧编号为 n-1。如果未指定帧号，那么显示有关与当前帧关联的函数的信息。

示例

移动到帧号2，请输入:
```
frame 2
```
要显示堆栈上的当前函数，请输入：
```
frame
```

请参阅 up 和 down 子命令。另请参阅 "更改当前文件或过程" 和显示堆栈跟踪在 常规编程概念: 编写和调试程序 中。

func Subcommand

func [ Procedure ]

func 子命令将当前函数更改为由参数 Procedure 指定的过程或函数。如果不指定 Procedure 参数，那么缺省值为显示当前的函数。更改当前函数将当前源文件更改为包含新函数的文件；当前名称解析的作用域也发生更改。

示例

要将当前函数更改为do_count过程，请输入:
```
func do_count
```
要显示当前函数的名称，请输入:
```
func
```

请参阅 file 子命令。另请参阅 "更改当前文件或过程" 在 常规编程概念: 编写和调试程序 中。

goto 子命令

goto SourceLine

goto 子命令使指定的源行接下来运行。通常指定的源行必须与当前行在同一函数中。要重设该约束，使用 set 子命令并带有 $unsafegoto 标志。

示例

要使下一个执行的行为第六行，请输入：

goto 6

请参阅 cont 子命令， gotoi 子命令和 set 子命令。

gotoi 子命令

gotoi 地址

gotoi 子命令修改程序计数器地址为 Address 参数指定的地址。

示例

将程序计数器地址更改为地址0x100002b4，请输入:

gotoi 0x100002b4

请参阅 goto 子命令。

handler 子命令

handler { atfork | cancel_cleanup [ all | pthread id ] }

handler 子命令显示分别使用 pthread_atfork 和 pthread_cleanup_push 注册的 atfork 或取消清除处理程序的相关信息。如果使用 atfork 选项，那么会显示注册为 pre、parent 和 child atfork 处理程序的例程的名称（在兼容非 POSIX 的 atfork 处理程序情况下，还附带各自的参数）。 cancel_cleanup 选项会促使显示所有已注册的取消清除处理程序：如果使用可选的 pthread id 参数，那么指定特定 pthread；如果使用 all，那么指定所有 pthread。如果不指定任何参数，那么会显示当前 pthread 的取消清除处理程序（如果有的话）。

示例

要查看所有已注册 atfork 处理程序的相关信息，请输入：
```
handler atfork
```
要查看当前 pthread 的任何已注册取消清除处理程序的相关信息，请输入：
```
handler cancel_cleanup
```
要查看 pthread 对象（称为 $t2）的任何已注册取消清除处理程序的相关信息，请输入：
```
handler cancel_cleanup 2
```

help 子命令

help [ Subcommand | Topic ]

根据您指定的参数 help 子命令显示 dbx 子命令或主题的帮助信息。输入 help 子命令并带有 Subcommand 参数显示语法语句和指定子命令的描述。输入 help 子命令并带有 Topic 参数显示指定主题的详细描述。您无需对 help 子命令提供完整的主题字符串。如果您提供从主题开头部分开始的子串，dbx 程序可识别该主题。以下是可用的主题：

项	描述
startup	列示 dbx 启动选项列表。
execution	列示和程序执行相关的 dbx 子命令。
breakpoints	列示和断点和跟踪相关的 dbx 子命令。
files	列示用于访问源文件的 dbx 子命令。
data	列示用于访问程序变量和数据的 dbx 子命令。
machine	列示用于机器级别的调试的 dbx 子命令描述。
environment	列出用于设置 dbx 配置和环境的 dbx 子命令。
threads	列示 dbx 子命令获得线程相关的对象。
expressions	描述 dbx 表达式语法和运算符。
scope	描述 dbx 如何解析不同于作用域的名称。
set_variables	列示 dbx 带有用法说明的调试变量。
usage	列示带有简单描述的 dbx 公共子命令。

示例

要列出所有可用的 dbx 子命令和主题，请输入:
```
help
```
要显示 dbx 子命令 list的描述，请输入:
```
help list
```
要显示 dbx 主题 set_variables的描述，请输入:
```
help set_variables
```

ignore 子命令

ignore [ SignalNumber | SignalName ]

ignore 子命令在信号送到应用程序之前停止指定信号的捕捉。该子命令在调试应用程序处理例如中断之类的信号时非常有用。

要捕捉的信号可以通过以下任意一项指定：

Number ，带有 SignalNumber 参数
名称，带有 SignalName 参数

信号名称不区分大小写。前缀 SIG 为可选。

如果指定 SignalNumber 和 SignalName 参数，那么缺省情况下会捕捉 SIGHUP、SIGCLD、SIGALRM 和 SIGKILL 信号之外的所有其他信号。如果 SIGTRAP 信号来自调试器外部的进程，那么 dbx 调试程序不能忽略该信号。如果不指定任何参数，那么将显示当前被忽略的信号列表。

示例

要使 dbx 忽略发送到应用程序的警报时钟超时信号，请输入：

ignore alrm

请参阅 catch 子命令。另请参阅处理信号在 常规编程概念: 编写和调试程序 中。

kthread 子命令

kthread [ raw ] [ info | ru ] [ tid ]

kthread 子命令显示有关内核线程的信息。使用 raw 选项会促使所有输出以十六进制显示，而不考虑输出是否能以符合人类阅读习惯的格式来显示。如果不使用参数，那么将打印有关所有内核线程的摘要信息。提供数字线程标识会促使 dbx 命令显示有关单个线程的信息。 info 选项从用户线程结构产生有关线程的更详细输出。使用 ru 选项会显示 ti_ru 数据成员，它包含了资源使用信息。

有关用户线程的更多信息，请参阅 thread subcommand。

示例

要查找当前正在运行的线程的相关信息，您必须先在命令行上输入以下命令来获取所有线程的相关信息：
```
kthread
```
会使用星号来标记就在 dbx 命令停止进程之前正在运行（或可运行）的线程。根据输出选择正确的线程标识并输入：
```
kthread info tid
```
要以十六进制查看有关所有线程的资源信息，请输入：
```
kthread raw ru
```

limitbp 子命令

limitbp ( bp1， 限制 ) [( bp2， [ + ] 限制 ) ...]

limitbp 子命令会指示 dbx 命令只有在执行断点指定次数后才停止运行调试程序。如果在限制 (Limit) 前面加上“+”字符，那么该事件的限制值会更改为该子命令中所指定的限制值，与事件已经执行的次数之和。即，在已经运行 limitbp 子命令后，执行断点即将达到所指定的 Limit 时，dbx 命令会停止运行调试程序。

示例

要指示 dbx 命令在断点 1 即将执行第 10 次时停止执行调试程序，请输入：
```
limitbp (1, 10)
```
要指示 dbx 命令在断点 1 即将执行第 15 次时，及/或断点 2 即将执行第 20 次时停止执行调试程序，请输入：
```
limitbp (1, 15) (2, 20)
```
要指示 dbx 命令在运行 limitbp 子命令后的第 20次即将执行断点 1 时停止执行调试程序，请输入:
```
limitbp (1, +20)
```

list 子命令

list[程序 | SourceLine-Expression ,源代码行表达式] | 'at 地址］

list 子命令显示指定数目的源文件的行。通过以下其中一种方法来指定显示的行数：

通过使用 Procedure 参数来指定过程。
在这种情况下，list 子命令显示从指定过程开始前的几行开始直到列表窗口已满。
通过使用 SourceLine-Expression 参数来指定起始和结束源程序行号。
SourceLine-Expression 参数必须由后面跟有可选 +（加号）或 -（减号）的有效行号以及一个整数组成。此外，可使用 $（美元符号）的 SourceLine 来表示当前行号；可使用 @（at 符号）的 SourceLine 来表示下一个要列示的行号。
通过指定 $listwindow 内部 dbx 变量。
如果使用的 list 子命令未指定参数，那么将从当前源行开始打印 $listwindow 变量指定的行数。要更改缺省行数，请将 $listwindow 变量设置为需要的行数。 $listwindow 变量是一个特殊调试程序变量。 $listwindow 变量的初始值为 10。

如果未指定第二源行，那么只打印第一行。

所有在第一个指定的行号和第二个指定的行号之间（包括这两行）的行都将被显示出来。

当您在 list 子命令中的 at 参数后面指定地址时， list 子命令将显示与指定地址对应的源行。可以将地址指定为一个十进制或十六进制无符号整数，或对应注册数的助记符，例如，$iar、$tfiar 和 $tfhar 或调试变量。

示例

列出行1到10在当前文件中，输入:
```
list 1,10
```
目标列表10，或$listwindow，周围的行main过程，请输入:
```
list main
```
要列出当前行周围的 11 行，请输入:
```
list $-5,$+5
```

您可以在表达式中使用涉及加法和减法的简单整数表达式。 SourceLineExpression 表达式。例如：

(dbx) list $
4 {

(dbx) list 5
5 char i = '4';

(dbx) list sub
23 char *sub(s,a,k)
24 int a;
25 enum status k;  .  .  .  

(dbx) move 
25
(dbx) list @ -2
23 char *sub(s,a,k)

可以显示对应指定地址的源行。例如：

(dbx) r
[1] stopped in main at line 5
    5 int i, sum = 0;

(dbx) list at $iar
source file: "tt.c"
    5 int i, sum = 0;
    6 int last = 0;
    7
    8 scanf("%d", &last);
    9 
    10 for ( i = 1; i &lt;=last; i++ ) { 
    11 sum += i; 
    12 } 
    13 printf("sum = %d\n", sum); 
    14 

(dbx) list at ($iar+16) 
source file: "tt.c" 
    8 scanf("%d", &last); 
    9 
    10 for ( i = 1; i <= last; i++ ) { 
    11 sum += i; 
    12 } 
    13 printf("sum = %d\n", sum); 
    14 
    15 return 0; 
    16 }

请参阅 edit 子命令， listi 子命令和 move 子命令。另请参阅显示当前文件在 常规编程概念: 编写和调试程序 中。

listi 子命令

listi [ 过程 | at SourceLine | 地址 [ , 地址 ]]

listi 子命令显示源文件指定的指令集合。显示的指令可以通过以下方法指定：

提供 Procedure 参数，其中 listi 子命令列出从指定过程开始直到填充列表窗口的指令。
使用 at SourceLine 标志，其中 listi 子命令显示从指定的源行开始并继续直到填充列表窗口的指令。 SourceLine 变量可指定为整数，也可指定为后跟一个 :（冒号）和一个整数的文件名字符串。
使用 Address 参数指定开始地址和结束地址，其中显示两个地址 (包括两个地址) 之间的所有指示信息。

如果 listi 子命令没有使用标志或参数，那么显示下一个 $listwindow 指令。要修改当前列表窗口的大小，可以使用 set $listwindow=Value 子命令。

反汇编方式

dbx程序可以反汇编POWER 系列或PowerPC架构的指令。在缺省方式下，dbx 程序显示正在运行的结构的指令。

dbx 命令的 set 子命令的 $instructionset 和 $mnemonics 变量允许您覆盖缺省反汇编方式。要获得更多的信息，请参阅 dbx 命令中的 set 子命令。

标志

项	描述
at `SourceLine`	指定列表的开始源行。

示例

要列出下一个 10 ，或$listwindow，指示信息，请输入:
```
listi
```
列出从源行开始的机器指令10，请输入:
```
listi at 10
```
列出从源行开始的机器指令5在文件中sample.c，请输入:
```
listi at "sample.c":5
```
列出地址之间的指示信息0x10000400和0x10000420，请输入:
```
listi 0x10000400, 0x10000420
```

请参阅 list 子命令和 set 子命令。另请参阅使用 dbx 在机器级别进行调试在 常规编程概念: 编写和调试程序 中。

malloc 子命令

malloc [> 文件 ]

不带选项的 malloc 子命令会打印已启用选项和分配策略的列表以及进程启动以来 malloc 使用的统计摘要。

malloc [ 分配 [ { 地址 | 大小 | 堆 | 标识 | 蒂德 | 时间 } { "<" | "==" | ">" "!=" | “~=” ]} 值 ] ] [ > 文件 ]

malloc 子命令的 allocation 选项显示进程当前持有的所有分配的排序列表。使用可选 attribute RELOP value 参数允许更窄地选择活动分配。

malloc [ 可用空间 [ { 地址 | 大小 | 堆 } { "<" | "==" | ">" | "!=" | “~=”]} 值 ] ] [ > 文件 ]

malloc 子命令的 freespace 选项显示进程堆中所有可用空间的排序列表。使用可选 attribute RELOP value 参数允许更窄地选择可用空间节点。

注: ~ = 运算符只能与地址选项配合使用。使用此运算符来访存指定的地址所属的可用空间或分配节点。

malloc 地址

带有地址的 malloc 子命令会显示该地址的节点详细信息，该地址不一定是已分配节点或可用节点的起始地址。

标志

项	描述
> `文件`	重定向输出到指定的文件。

有关更多信息，请参阅 常规编程概念: 编写和调试程序中的使用 malloc 子系统进行系统内存分配。

map 子命令

map {[Format] [ entry ModuleNumber [， ModuleNumber ] | Address | SymbolName ] [for $tthreadnumber] [ > File ]}

map 子命令显示应用程序装入部分的特征。该信息可以包括每个装入模块的模块名称、成员名、文本起点、文本终点、文本长度、数据起点、数据终点、数据长度、TLS 数据起点、TLS 数据终点、TLS 数据长度以及文件描述符。可用以下方式指定要显示的项：

通过使用 ModuleNumber 参数指定单个项。
通过使用两个逗号分隔的 ModuleNumber 参数指定某个范围的项。
通过使用 Address 参数向装入模块指定要解析的地址。
通过使用 SymbolName 参数向装入模块指定要解析的符号名称。

如果不带以上任何说明调用 map 子命令，那么该子命令显示应用程序所有装入部分的信息。

Format 参数指定装入模块描述的输出方式。以下表包含 Format 参数的可能值：

项	描述
缩写	指定简略输出方式，该方式包含每个装入模块的包含项编号、模块名称和该模块的可选成员名的单行。
normal	指定常规输出方式，该方式包含每个装入模块的项编号、模块名称、成员名、文本起点、文本长度、数据起点、数据长度和文件描述符。如果装入模块有 TLS 数据，那么 TLS 数据起点和 TLS 数据长度也将显示。
原始	指定原始输出方式，该方式由每个模块的包含以下空格分隔字段的无格式单行组成：项编号、带有可选成员名的模块名称、文本起点、文本终点、文本长度、数据起点、数据终点、数据长度和文件描述符。如果装入模块有 TLS 数据，那么也将显示 TLS 数据起点、TLS 数据终点和 TLS 数据长度。
verbose	指定详细输出方式，该方式包含每个装入模块的项编号、模块名称、成员名、文本起点、文本终点、文本长度、数据起点、数据终点、数据长度和文件描述符。如果装入模块有 TLS 数据，那么也将显示 TLS 数据起点、TLS 数据终点和 TLS 数据长度。

如果未指定 Format 参数，那么 dbx 参数会使用内部变量 $mapformat 的值。如果未指定 Format 参数并且已取消设置 $mapformat，那么 dbx 命令会以正常方式显示装入模块的信息。

如果装入模块有 TLS 数据，那么指定线程的 TLS 数据信息会显示。如果未指定任何线程，那么使用当前线程。

标志

项	描述
> `文件`	重定向输出到指定的文件。
entry `ModuleNumber` [， `ModuleNumber` ]	指定要显示的模块或模块范围。
for $t `threadnumber`	指定线程号。

示例

要以简略方式列示所有已装入的模块，请输入：
```
map abbr
```
要以详细方式列示已装入的模块 3 到 5，请输入：
```
map verbose entry 3,5
```
要列示包含地址 0x20001000 的已装入模块，请输入：
```
map 0x20001000
```
要列示包含变量 example 的已装入模块，请输入：
```
map example
```
要以正常方式为线程 2 列示已装入的模块以及这些模块的 TLS 数据信息，请输入：
```
map normal for $t2
```

有关更多信息，请参阅 $mapformat 内部变量。另请参阅使用 dbx 在机器级别进行调试在 常规编程概念: 编写和调试程序 中。

move 子命令

move SourceLine

move 子命令将下一个显示行更换为由 SourceLine 参数指定的行。该子命令修改 @ （at 符号）变量的值。

SourceLine 变量可以通过一个整数或者代表文件名的字符串后跟 :（冒号）和一个整数的方法指定。

示例

要将要列示的下一行更改为行12，请输入:
```
move 12
```
要将要列示的下一行更改为行5在文件中sample.c，请输入:
```
move "sample.c":5
```

请参阅 list 子命令。另请参阅 "显示当前文件" 在 常规编程概念: 编写和调试程序 中。

multproc 子命令

multproc [ 关于父| 子代| 关闭 ]

multproc 子命令指定 dbx 调试程序在创建派生或者越权进程时的行为。使用 on 标志来指定将创建新的 dbx 会话以调试派生的子路径。原始 dbx 会继续调试父路径。 parent 以及 child 标志用来指定派生进程的单一路径。除了 off 的所有标志都能使 dbx 跟随越权进程。 off 标志禁用多进程调试。如果不指定标志，那么 multproc 子命令会返回多进程调试的状态。

dbx 程序将 X Window System 用于多进程调试。 dbx 程序将会打开足够多的窗口供多进程调试使用。每个子窗口的标题为子进程 ID (pid)。要在进程之间进行切换，请使用 X Window System 处理技术来激活用于显示 dbx 命令会话的窗口。如果系统不支持 X Window System，那么当调试器派生进程时，会发出一条警告消息，并且 dbx 程序继续仅调试父进程。多进程调试也可能因如下原因失败：

dbx 程序在 X Window System 环境中没有处于运行状态。
X Window System 正在运行，但 dbx 全局 $xdisplay 变量未设置为有效的显示名称。 $xdisplay 变量被初始化成 shell 的 DISPLAY 环境变量。 set Name=Expression dbx 子命令可用于更改显示名的值。
/tmp 目录不允许对调试程序进行读或写访问。在控制 Xwindow 环境时， dbx 程序在此目录中需要少量空间。
该系统没有足够的资源来容纳新 Xwindow。

如果 $xdisplay 设置为远程显示，那么用户可能看不到新创建的 Xwindow。如果 $xdisplay 设置不正确，那么 X Window System 或其他系统资源会报告发生故障的原因。

dbx 程序不能区分不同类型错误的区别，但是将会在子命令失败时发送以下消息：

Warning: dbx subcommand multiproc fails. dbx 
continued with multproc disabled.

新创建窗口的用户定义的配置可以在 .Xdefaults 文件中由 dbx_term 应用程序名定义。

标志

项	描述
on	启用多进程调试。
关	禁用多进程调试。

示例

要检查多进程调试的状态，请输入：
```
multproc
```
要启用多进程调试，请输入：
```
multproc on
```
要禁用多进程调试，请输入：
```
multproc off 
```

请参阅 screen 子命令和 fork 子例程。另请参阅 "涉及多个进程的调试程序" 在 常规编程概念: 编写和调试程序 中。

mutex 子命令

mutex [ lock | unlock | thnum | utid | MutexNumber ...]

mutex 子命令显示关于互斥的信息。如果给定 MutexNumber 参数，那么 mutex 子命令将显示指定互斥的信息。如果不指定标志或者参数，那么 mutex 子命令将会显示所有的互斥信息。

每个互斥信息列示如下所示：

项	描述
`mutex`	指示互斥对象的符号名称，格式为`$mMutexNumber`.
`type`	指示互斥对象的类型:`non-rec`(非递归) ，`recursi`(递归) 或`fast`.
`obj_addr`	指示互斥对象的内存地址。
`lock`	指示互斥对象的锁定状态:`yes`如果互斥锁上了`no`如果没有
`owner`	如果锁定了互斥对象，那么指示挂起该互斥对象的用户线程的符号名称。
`blockers`	列示在互斥变量中锁定的用户线程。

注: dbx 调试程序的 print 子命令可识别符号互斥名称，并且可用于显示相应对象的状态。

标志

项	描述
lock	显示关于锁定互斥的信息。
撤消锁定	显示关于未锁定互斥的信息。
鄙人	显示特定线程的所有互斥的信息。
实用程序	显示其用户线程标识与该用户线程标识匹配的用户线程所持有的所有互斥的相关信息。

示例

要显示有关全部互斥的信息，请输入：
```
mutex
```
要显示有关全部锁定互斥的信息，请输入：
mutex lock

要显示有关编号为 4、5 和 6 的互斥的信息，请输入：

mutex 4 5 6

输出类似于：

mutex   obj_addr         type     lock owner  blockers
$m4    0x20003274        non-rec   no
$m5    0x20003280        recursi   no
$m6    0x2000328a        fast      no

要显示所有线程 1 的互斥信息，请输入：
```
mutex thnum 1
```
要显示线程号为 0x0001 的线程拥有的所有互斥信息，请输入：
```
mutex utid 0x0001
```

请参阅 attribute 子命令， condition 子命令， print 子命令和 thread 子命令。

另请参阅使用互斥对象 常规编程概念: 编写和调试程序。

下一个子命令

next [ 数字 ]

next 子命令运行应用程序到下一行。 Number 参数指定 next 子命令的运行次数。如果不指定 Number 参数，那么 next 只运行一次。

如果在多线程应用程序中使用 next 子命令，那么所有用户线程都在该操作期间运行，但该程序仍继续执行，直到正在运行的线程到达指定的源程序行。如果要仅单步执行正在运行的线程，请使用 set 子命令来设置变量 $hold_next。设置此变量可能会导致死锁，因为正在运行的线程可能会等待其中一个阻塞线程所持有的锁。

示例

要继续执行到下一源程序行，请输入：
```
next
```
要继续执行到当前源程序行后的第三个源程序行，请输入：
```
next 3
```

请参阅 cont 子命令， goto 子命令， nexti 子命令， set 子命令和 step 子命令。

nexti 子命令

nexti [ 数字 ]

nexti 子命令运行应用程序到下一个指令。 Number 参数指定 nexti 子命令的运行次数。如果不指定 Number 参数，那么 nexti 只运行一次。

如果在多线程应用程序中使用 nexti 子命令，那么所有用户线程都在该操作期间运行，但该程序仍继续执行，直到正在运行的线程到达指定的机器指令。如果要仅单步执行正在运行的线程，请使用 set 子命令来设置变量 $hold_next。设置此变量可能会导致死锁，因为正在运行的线程可能会等待其中一个阻塞线程所持有的锁。

示例

要继续执行到下一条机器指令，请输入：
```
nexti
```
要继续执行到当前机器指令后面的第三条机器指令，请输入：
```
nexti 3
```

请参阅 gotoi 子命令， next 子命令， set 子命令和 stepi 子命令。另请参阅在机器级别运行程序在 常规编程概念: 编写和调试程序 中。

onceblock 子命令

onceblock [ uninit | done ]

onceblock 子命令显示有关使用 pthread_once 例程注册的初始化代码块的信息。如果不指定参数，那么会显示所有已注册 once 块的相关信息。可选的 uninit 和 done 标志仅分别显示未执行或已执行的 once 块，而提供数字 once 标识则显示单个 once 块的信息。

注: 要使 onceblock 子命令在调试实时进程时起作用，必须将环境变量 AIXTHREAD_ONCE_DEBUG 设置为等于 ON。类似地，如果调试核心文件，而且在进程运行时变量未打开，那么 onceblock 子命令无法获取任何信息。

示例

要查明是否有任何 once 块尚未执行，请输入：
```
onceblock uninit
```

plugin 子命令

plugin [ Name [ Command ] ]

plugin 子命令会将 Command 参数所指定的命令传递到 Name 参数所指定的插件。如果未指定参数，将显示所有可用插件的名称。

示例

要列示所有可用插件，请输入：
```
plugin
```
要启动名为“sample”的插件的子命令“help”，请输入：
```
plugin sample help
```
要启动名为“xyz”的插件的子命令“interpret 0x20000688”，请输入：
```
plugin xyz interpret 0x20000688
```

请参阅 pluginload 子命令和 pluginunload 子命令。另请参阅 常规编程概念中的为 dbx 插件框架开发。

pluginload 子命令

pluginload 文件

pluginload 子命令装入 File 参数指定的插件。 File 参数必须指定插件路径。

注: 由于缺省 dbx 命令是 64 位进程，因此必须使用名为 dbx32的 32 位版本的 dbx 命令来装入 32 位插件。

示例

要装入“/home/user/dbx_plugins/libdbx_sample.so”处名为“sample”的插件，请输入：

pluginload /home/user/dbx_plugins/libdbx_sample.so

请参阅 plugin 子命令和 pluginunload 子命令。另请参阅 常规编程概念中的为 dbx 插件框架开发。

pluginunload 子命令

pluginunload 名称

pluginunload 子命令卸载 Name 参数指定的插件。

示例

要卸载名为“sample”的插件，请输入：

pluginunload sample

请参阅 plugin 子命令和 pluginload 子命令。另请参阅 常规编程概念中的为 dbx 插件框架开发。

print 子命令

print 表达式 ...

printProcedure ( [ Parameters ] )

print 子命令执行以下一项操作：

打印用 Expression 参数指定的表达式列表的值。
执行用 Procedure 参数指定的过程，并打印该过程的返回值。包括的参数传递给过程。

示例

显示x和价值y左移两个位，输入:
```
print x, y << 2
```
显示通过调用sbrk带有自变量 0 的例程，请输入:
```
print sbrk(0)
```

请参阅 assign 子命令， call 子命令和 set 子命令。

printbp 子命令

printbp [ bp1 ] [ bp2 ] ... | 所有

printbp 子命令会指示 dbx 命令打印每个断点或所有子命令的运行次数，以及对断点设置的任何限制的详细信息。

示例

要指示 dbx 命令打印断点 1 的运行次数，以及所设置限制的详细信息，请输入：
```
printbp 1
```
要指示 dbx 命令打印断点 1 和断点 2 的运行次数，以及限制断点 1 和断点 2 可以运行的次数（如果在断点上设置了限制），请输入：
```
printbp 1, 2
```
要指示 dbx 命令打印所有断点的运行次数，以及任何断点上限制（如果适用）的详细信息，请输入：
```
printbp all
```

proc 子命令

proc [ raw ] [ cred | cru | ru | sigflags | signal ]

proc 子命令显示有关进程的信息。如果使用 raw 选项，那么会导致输出以原始十六进制显示，而不是以更人类可读的方式解释值。如果不带其他参数使用 proc 子命令，那么会输出用户进程数据结构中存储的有关进程的一般信息。 cred 选项显示 pi_cred 数据成员的内容，其中该数据成员描述进程的凭证。 cru 和 ru 选项分别显示数据成员 pi_cru 和 pi_ru，包含资源使用信息。 sigflags 和 signal 选项显示与当前信号状态和已注册信号处理程序相关的信息，这些信息包含在 pi_sigflags 和 pi_signal 数据成员中。

示例

要以原始十六进制查看当前进程（或核心文件）的资源使用信息，请输入：
```
proc raw ru
```
要查看信号处理程序信息，请输入：
```
proc signal
```

prompt 子命令

prompt [ " 字符串 " ]

prompt 子命令将 dbx 命令的提示符修改为 String 参数指定的字符串。

示例

要将提示符切换至 dbx>，请输入：

prompt "dbx>"

请参阅定义新的 dbx 提示在 常规编程概念: 编写和调试程序 中。

quit 子命令

quit

quit 子命令终止在 dbx 调试会话中运行的所有进程。

请参阅 detach 子命令。

registers 子命令

registers [ALL | $tthreadnumber ...] [ >文件 ]

registers 子命令显示通用寄存器、系统控制寄存器、浮点寄存器、向量寄存器以及当前指令寄存器的值。

通用寄存器由 $rNumber 变量表示，其中 Number 参数指示寄存器编号。
注：寄存器值可设置为 0xdeadbeef 十六进制值。十六进制数 0xdeadbeef 是一个在进程初始化时就赋到通用寄存器中的初始值。
浮点寄存器由 $frNumber 变量表示。按照缺省设置，浮点寄存器不会被显示出来。要显示浮点寄存器，请使用 unset $noflregs dbx 子命令。
浮点寄存器由 $vrNumber 变量表示。 $novregs 内部变量控制是否显示向量寄存器。缺省情况下会设置 $novregs 变量，并且不会显示向量寄存器。如果未设置 $novregs ，并且向量寄存器有效 (在支持向量的处理器上调试程序，或分析包含向量寄存器状态的核心文件) ，那么将显示所有向量寄存器 (vr0–vr31， vrsave 和 vscr)。还可以按类型引用向量寄存器。例如，可以将 $vrNf (float) ， $vrNs (short) 和 $vrNc (char) 向量寄存器变量与 print 和 assign 子命令配合使用，以按类型显示和设置向量寄存器。
由 $vsrNumber 变量来表示向量标量寄存器。缺省情况下，不会显示向量标量寄存器。取消设置 $novsregs 变量，以便每当向量标量寄存器有效时就显示这些向量标量寄存器；可通过在能够处理向量标量的处理器上调试程序，或者分析包含向量标量寄存器状态的核心文件来取消设置此变量。因为向量标量寄存器是旧浮点寄存器和向量寄存器的超集，所以调试变量 $novsregs 在取消设置的情况下优先于 $noflregs 和 $novsregs （只要向量标量寄存器状态有效）。然后，registers 子命令将显示向量标量寄存器，并将它与旧的寄存器别名一起用花括号括起来。浮点寄存器别名仅对应于低 64 位。还可以按类似于向量寄存器的类型来引用向量标量寄存器。例如，可以对 print 和 assign 子命令使用 $vsrNf (float)、$vsrNs (short)、$vsrNc (char)、$vsrNg (double) 和 $vsrNll (long long) 这些向量标量寄存器变量，以按类型显示和设置向量标量寄存器。
在多线程环境选项中，ALL 显示所有可用线程的寄存器详细信息。通过指定线程数与 registers 子命令来显示各个线程的寄存器详细信息。使用不带任何选项的 registers 子命令会显示当前线程的寄存器。

注: 如果当前线程处于内核方式，那么 registers 子命令无法显示寄存器。

标志

项	描述
>`文件`	重定向输出到指定的文件。

请参阅 set 子命令和 unset 子命令。另请参阅使用机器寄存器在 常规编程概念: 编写和调试程序 中。

示例

要显示线程 $t1、$t2 和 $t3 的寄存器详细信息，请输入：

registers $t1 $t2 $t3

请参阅 set 子命令和 unset 子命令。另请参阅使用机器寄存器在 常规编程概念: 编写和调试程序 中。

rerun 子命令

rerun [ 参数 ] [ < 文件 ] [ > 文件 ] [ > > 文件 ] [ 2> 文件 ] [ 2> > 文件 ] [ >& 文件 ] [ > >& 文件 ]

rerun 子命令开始对象文件的执行。 Arguments 会作为命令行参数来传递。如果不指定 Arguments 参数，最近一次 run 或 rerun 子命令使用的参数将会被再次使用。

标志

项	描述
<`文件`	将输入重定向使得从 `File` 文件中获得输入。
>`文件`	重定向输出到 `File`文件中。
>>`文件`	添加重定向输出到 `File` 中。
2>`文件`	将标准错误重定向至 `File`。
2>>`文件`	添加重定向标准错误到 `File` 中。
>&`文件`	将输出和标准错误重定向至 `File`。
> >&`文件`	添加输出和标准错误到 `File` 中。

请参阅 run 子命令。

resource 子命令

resource { owner | waiter } [ all | pthread id]

resource 子命令显示有关当前 pthreads 保留或正在等待哪些资源的信息。第一个参数（必需）指示您是否有兴趣查看拥有资源或正在等待资源的 pthread。第二个参数可用于指示所有 pthread 或某个特定 pthread。如果未给出任何参数，那么仅显示与当前 pthread 相关的信息（如果适用）。

注: resource 子命令仅用于调试在将多个调试环境变量设置为 ON的情况下运行的进程。这些变量包括 AIXTHREAD_MUTEX_DEBUG、AIXTHREAD_COND_DEBUG、AIXTHREAD_RWLOCK_DEBUG、 AIXTHREAD_READ_OWNER 和 AIXTHREAD_WAITLIST_DEBUG。如果在调试活动的进程时或在调试器核心文件生成时未开启这些变量，那么 resource 子命令只能检索到很少的信息，或者根本没有信息。因为使用这些功能可能会使性能下降，所以建议只有在调试时才激活这些功能。

示例

要确认当前 pthread 是否占用任何资源，请输入：
```
resource owner
```
要查看 pthread 正在等待哪些资源，请输入：
```
resource waiter all
```

return 子命令

return [ 过程 ]

return 子命令使应用程序执行直到返回到由 Procedure 参数指定的过程。如果不指定 Procedure 参数，执行将会在当前过程返回时停止。

示例

要继续执行到调用例程，请输入：
```
return
```
要继续执行main过程，请输入:
```
return main 
```

rwlock 子命令

rwlock [read | write | RwlockNumber....]

rwlock 子命令显示有关 rwlock 的信息。如果给定 RwlockNumber 参数，rwlock 子命令将会显示有关指定 rwlock 的信息。如果未指定标志或参数，那么 rwlock 子命令将显示有关所有 rwlocks 的信息。

每个 rwlock 的信息如下所示：

项	描述
`rwl`	设定 rwlock 的符号名称，格式为 $rw `RwlockNumber`。
`flag_value`	指示标志值。
`owner`	指示 rwlock 的所有者
`status`	指示拥有该 rwlock 的用户。此值可以是读入（如果由读入者拥有）、写出（如果由写出者拥有）或者空闲（如果空闲）。
`wsleep[#]`	指示在写操作中阻塞的线程。# 指示在写中阻塞的线程总数。
`rsleep[#]`	指示在读取中阻塞的线程。# 指示读中阻塞的线程总数。

注: dbx 调试程序的 print 子命令可识别符号 rwlock 名称，并可用于显示相应对象的状态。

标志

项	描述
READ	显示所有处于读状态的 rwlock 的信息。
WRITE	显示所有处于写状态的 rwlock 的信息。

示例

要显示所有 rwlock 的信息，请输入：

rwlock

输出类似于：

rwl     flag_value    owner status
$rwl        1         $t1    write
        rsleeps[     0]:
        wsleeps[     0]:

要显示处于写状态的所有 rwlock 的信息，请输入：

rwlock write

输出类似于：

rwl     flag_value    owner status
$rwl        1         $t1    write
        rsleeps[     0]:
        wsleeps[     0]:

请参阅 attribute 子命令， condition 子命令， mutex 子命令， print 子命令和 thread 子命令

run 子命令

run [ 参数 ] [ <文件 ] [ >文件 ] [ > >文件 ] [ 2>文件 ] [ 2> >文件 ] [ >&文件 ] [ > >&文件 ]

run 子命令打开对象文件。 Arguments 会作为命令行参数来传递。

标志

项	描述
<`文件`	将输入重定向使得从 `File` 文件中获得输入。
>`文件`	重定向输出到 `File`文件中。
2>`文件`	将标准错误重定向至 `File`。
>>`文件`	添加重定向输出到 `File` 中。
2>>`文件`	添加重定向标准错误到 `File` 中。
>&`文件`	将输出和标准错误重定向至 `File`。
> >&`文件`	添加输出和标准错误到 `File` 中。

示例

使用自变量运行应用程序blue和12，请输入:

run blue 12

请参阅 rerun 子命令。

screen 子命令

screen

screen 子命令为 dbx 命令交互打开一个 Xwindow 窗口。您可以在进程发生的窗口继续操作。

当 dbx 调试程序在 X Window System 环境中运行时，必须运行 screen 子命令。如果在非 Xwindow 环境中发出 screen 子命令，那么 dbx 程序会显示一条警告消息并继续调试，就像未给定 screen 子命令一样。 screen 子命令也可能在下述情况下失败：

dbx 程序在 X Window System 环境中没有处于运行状态。
X Window System 正在运行，但是 dbx 全局 $xdisplay 变量未设置为有效显示名称。 $xdisplay 变量被初始化成 DISPLAY 环境变量的值。 dbx 子命令 set Name=Expression 更改显示名的值。
X Window System 正在运行，但 TERM 环境变量未设置为有效命令名来启动新窗口。
/tmp 目录不允许对程序进行读或写访问。执行屏幕命令时， dbx 程序需要此目录中有少量空间。
系统没有足够的资源来容纳新 Xwindow。

dbx 程序不能区分不同类型错误的区别，但是将会在子命令失败时发送以下消息：

Warning: dbx subcommand screen fails. dbx 
continues.

如果 $xdisplay 设置为远程显示，那么您可能看不到新创建的 Xwindow。如果 $xdisplay 设置不正确，那么 X Window System 或其他系统资源会报告该问题。

新创建窗口的用户定义的配置可以在 .Xdefaults 文件中由 dbx_term 应用程序名定义。

示例

要打开一个 dbx 命令交互的 Xwindow 窗口，请输入：

screen

set 子命令

set [ 变量=表达式 ]

set 子命令为 dbx 调试程序变量定义一个值。其值由 Expression 参数指定；而程序变量由 Variable 参数指定。该变量的名称不能与正在调试的程序中的名称冲突。在其他命令内部扩展变量至相应的表达式。如果 set 子命令没有参数使用，将会显示当前的变量。

变量	描述
$catchbp	在下一个命令执行期间捕捉断点。
代码页	指定要用于解释程序内的字符的代码集。使用有效代码页指定后，将从指定代码集读取所有字符并将其转换为当前环境正在使用的代码集。
$compact_bt_ident	指定对标识名称内可显示在堆栈跟踪中的字符数的限制。指定的限制必须为范围在 4 - 128 中的正整数。如果设置了此变量但未指定任何限制值，那么可显示的缺省字符数为 8。如果设置了该变量，并且标识名称比指定的限制至少多四个字符，那么 dbx 命令会将原始标识名称的指定数目字符显示在堆栈跟踪中，并且这些字符后跟三个句点 (...)。例如，如果标识名称为 `variable_example`（其长度为 16 个字符），并且指定的限制为 7，那么标识名称显示为 `variabl...`。但是，如果标识名称为 `variable_1`（其长度为 10 个字符），并且指定的限制为 7，那么 dbx 命令不会将标识名称缩减为后跟三个句点的七个字符。它会显示为 `variable_1`。
$compact_bt_string	指定对函数自变量字符串内可显示在堆栈跟踪中的字符数的限制。指定的限制必须为范围在 4 - 128 中的正整数。如果设置了此变量但未指定任何限制值，那么可显示的缺省字符数为 8。如果设置了该变量，并且字符串的长度比指定的限制至少多四个字符，那么 dbx 命令会将原始字符串的指定数目字符显示在堆栈跟踪中，并且这些字符后跟三个句点 (...)。例如，如果字符串为 `string_example`（其长度为 14 个字符），并且指定的限制为 5，那么字符串显示为 `strin...`。但是，如果字符串为 `string_1`（其长度为 8 个字符），并且指定的限制为 5，那么 dbx 命令不会将字符串缩减为后跟三个句点的五个字符。它会显示为 `string_1`。
$deferevent	开启延迟事件功能。
$display_address_name	检查一组正在使用 dbx 命令的内存地址时，显示成员变量标识及其占用的内存地址。
$expandunions	显示变体记录或变体联合的每个部分的值。
$frame	使用由 $frame 的值指定的地址所指向的堆栈框架，来执行堆栈跟踪和访问局部变量。
$hexchars	按照十六进制值打印字符。
$hexin	按照十六进制解释地址。
$hexints	按照十六进制数值打印整数。
$hexstrings	以十六进制打印字符指针。
$hold_next	控制在运行 cont、next、nexti 和 step 子命令时获得除了正在运行线程之外的所有线程。设置此变量可能会导致死锁，因为正在运行的线程可能会等待其中一个阻塞线程所持有的锁。
$ignoreifhandler	您的程序接收到带已注册处理程序的信号时，不要停止。
$ignoreload	在您运行 load、unload 或 loadbind 子例程时不会停止。
$ignorenonbptrap	您的程序遇到非断点捕获指令且具有已注册的 SIGTRAP 处理程序，不要停止。
指令集	重设缺省反汇编方式。以下列表包含了 `Expression` 参数可能取的值： "缺省值" 指定 dbx 程序运行的结构。 "com" 指定 PowerPC 和 POWER 系列体系结构的公共交叉方式的指令集。 dbx 程序缺省为基于 POWER 处理器的助记符。 "电力" 指定 POWER 系列体系结构的指令集和助记符。 "pwrx" 为 "AIX 5.1及更早版本 "POWER 家庭架构的 "POWER2实现指定指令集和助记符。 "pwr6" 指定 PowerPC 体系结构的 POWER6 实现的指令集和助记符。 "pwr7" 指定 PowerPC 体系结构的 POWER7 实现的指令集和助记符。 "pwr8" 指定 PowerPC 体系结构的 POWER8 实现的指令集和助记符。 "pwr9" 指定 PowerPC 体系结构的 POWER9 实现的指令集和助记符。 "pwr10" 指定 PowerPC 体系结构的 POWER10 实现的指令集和助记符。 "601" 指定 PowerPC 601 RISC Microprocessor for AIX 5.1 和更低版本的指令集和助记符。 "603" 指定 PowerPC 603 RISC Microprocessor for AIX 5.1 和更低版本的指令集和助记符。 "604" 指定 PowerPC 604 RISC 微处理器的指令集和助记符。 "970" 指定 PowerPC 970 微处理器的指令集和助记符。 "ppc" 指定在基于 POWER 处理器的体系结构中定义的指令集和助记符，不包括可选指令。除了 AIX 5.1 和更低版本中的 PowerPC 601 RISC 微处理器之外，所有基于 POWER 处理器的实现中都提供了这些指示信息。 "任何" 指定任何有效的基于 POWER 处理器的或 POWER 系列指令。对于重叠的指令集，缺省值为基于 POWER 处理器的助记符。如果没有设置 `Expression` 参数，dbx 将会使用缺省反汇编方式。
$java	设置时，还会设置以下变量，将 dbx 命令置于调试 Java 应用程序的方式。如果取消设置，还将取消设置以下变量： $ignorenonbptrap 禁止通知 Java Just-In-Time (JIT) 编译器生成的陷阱指令。
$listwindow	指定在不带参数的情况下使用 list 子命令时要列示在函数周围的行数和要列示的行数。缺省值为 10 行。
$mapaddrs	开始映射地址。取消 $mapaddrs 设置将停止地址映射。
$mapformat	指定 map 子命令的缺省输出方式。 "辣妹" 指定简略输出方式，该方式包含每个装入模块的包含项编号、模块名称和该模块的可选成员名的单行。 "正常" 指定常规输出方式，该方式包含每个装入模块的项编号、模块名称、成员名、文本起点、文本长度、数据起点、数据长度和文件描述符。如果装入模块有 TLS 数据，那么也将显示 TLS 数据起点和 TLS 数据长度。 "原始" 指定原始输出方式，该方式由每个模块的包含以下空格分隔字段的无格式单行组成：项编号、带有可选成员名的模块名称、文本起点、文本终点、文本长度、数据起点、数据终点、数据长度和文件描述符。如果装入模块有 TLS 数据，那么也将显示 TLS 数据起点、TLS 数据终点和 TLS 数据长度。 "详细" 指定详细输出方式，该方式包含每个装入模块的项编号、模块名称、成员名、文本起点、文本终点、文本长度、数据起点、数据终点、数据长度和文件描述符。如果装入模块有 TLS 数据，那么也将显示 TLS 数据起点、TLS 数据终点和 TLS 数据长度。如果没有为 `Expression` 参数设置任何值，那么 dbx 程序会使用常规输出方式。
$mnemonics	在拆卸时更改 dbx 程序要使用的助记符集。 "缺省值" 指定最接近指定的指令的助记符。 "电力" 指定 POWER 系列体系结构的助记符。 "ppc" 指定基于 POWER 处理器的体系结构书籍中定义的助记符，不包括可选指令。如果没有为 `Expression` 参数设置任何值，那么 dbx 程序将使用与指定的指令集最为匹配的助记符。
$noargs	省略来自子命令的参数，例如 `where`、`up`、`down` 和 `dump`。
$noflregs	省略 registers 子命令中浮点寄存器的显示。
$novregs	省略 registers 子命令中向量寄存器的显示。
$novsregs	在 registers 子命令中不显示向量标量寄存器
$octint	解释八进制的地址。
$octints	打印八进制的整数。
$pretty	使用 print 子命令以 `漂亮的打印` 格式显示复杂 C 和 C++ 数据结构 (struts ，并集， array) 值。 "开" 指定值不换行打印、并带有表示值的静态范围的限定名称的美化打印。 "详细" 指定各自行中每个值的恰当的打印并带有表示值的静态范围的限定名称。一个限定名称包含一个由点隔开与值相关外部块的列表。 "关闭" 指定关闭恰当打印。这是缺省值。
$print_dynamic	使用 print/dump 命令显示动态类型的 C++ 对象。缺省情况下未设置此变量。
重复	如果没有输入命令则重复前一个命令。
$sigblock	程序的阻塞信号。
$show_vft	使用 print/dump 命令打印 C++ 对象时显示虚函数表。缺省情况下未设置此变量。
$stack_details	显示 where 子命令显示的每个活动函数或过程的帧号和寄存器集。
$stepignore	控制当 step/tstep 子命令在调用另一个没有可用的调试信息的例程的源行上运行时， dbx 命令的行为方式。此变量使 step/tstep 子命令能够单步执行没有可用调试信息的大型例程。以下列表包含了 `Expression` 参数可能取的值： "函数" 对 dbx 命令执行 next/tnext 子命令的功能。此值是缺省值。 "模块" 如果函数位于没有可用调试信息的装入模块 (例如系统库) 中，那么执行 next/tnext 子命令的函数。 "无" 在后台执行 dbx 命令的 stepi/tstepi 子命令的功能，直到它到达源信息可用的指令为止。在那个点，dbx 会显示执行的停止位置。
跟踪良好交易	指导 dbx 命令在每次成功完成事物内存 (TM) 事务时显示下列信息。 `Process {PID} may have performed a transaction - $texasr, $tfiar, $tfhar are valid and may be inspected` 不会报告成功的事物，因为缺省情况下，会禁用此变量。
$thcomp	当设置了 $thcomp 将会按照压缩格式显示线程命令 th- 的显示信息。
$unsafeassign	关闭对 assign 语句两端严格的类型检查语句。即使设置了 $unsafeassign 变量，assign 语句的两边也不能包含大小不同的存储类型。
$unsafebounds	关闭数组的下标检查。
$unsafecall	关闭子例程或者函数调用参数的严格类型检查。
$unsafegoto	关闭 goto 子命令目标检查。
$vardim	指定在打印未知边界的数组时将使用的维度。缺省值为 10。
$xdisplay	指定 X Window System 的显示名称，供与 multproc 子命令或 screen 子命令配合使用。缺省值为 shell DISPLAY 变量的值。

$unsafe 变量限制了 dbx 调试程序在错误检测中的用途。

示例

要将要列示的缺省行数更改为20，请输入:
```
set $listwindow=20
```
要在以下对象上禁用类型检查:assign子命令，输入:
```
set $unsafeassign
```
要拆卸 POWER7 处理器的机器指示信息，请输入:
```
set $instructionset="pwr7"
```
要显示以-eucCN代码集编码的字符串，请输入：
```
set $codepage="IBM-eucCN"
```
要指定标识和字符串内显示在堆栈跟踪中的字符数限制分别为 4 和 12，请输入以下命令：
```
set $compact_bt_ident=6
set $compact_bt_string=12
```
如果堆栈跟踪使用诸如 long_identifier、long_variable_name_str 和 recursive_fun 之类的标识以及诸如 this_is_a_really_long_string 之类的字符串，那么该堆栈跟踪类似于以下输出：
```
long_i...(a = 11, long_v... = "this_is_a_re..."), line 3 in "example.c"
recurs...(), line 13 in "example.c"
```

请参阅 unset 子命令。另请参阅使用特殊调试程序变量更改打印输出在 常规编程概念: 编写和调试程序 中。

set edit [vi, emacs] 或 set -o [vi, emacs] 子命令

带有 -o 或 edit 选项的 set 子命令可用于开启其中一种行编辑方式。如果给出了 set-o vi 或 set edit vi 命令，那么您将处于 vi 行编辑器的输入方式。如果给出了 set -o emacs 或 set edit emacs 命令，那么您将处于 emacs 行编辑器的输入方式。

示例

要打开 vi 行编辑器，请输入：
```
set-o vi
```
或
```
set edit vi
```

sh 子命令

sh [ 命令 ]

sh 子命令将 Command 参数指定的命令传递到 shell 执行。 SHELL 环境变量决定使用哪个 shell。缺省值为 sh shell。如果不指定参数，那么将控制权交给 shell。

示例

运行 ls命令，输入:
```
sh ls
```
要进入 shell，请输入：
```
sh
```
要使用SHELL环境变量，请输入:
```
sh echo $SHELL
```

请参阅从 dbx 运行 Shell 命令在 常规编程概念: 编写和调试程序 中。

skip 子命令

skip [ 数字 ]

skip 子命令从当前停止点继续执行应用程序。数目等于 Number 参数的值的断点将会被跳过并将在下一个断点处或者程序结束时停止执行。如果不指定 Number 参数，缺省值为 1。

示例

要继续执行程序直到遇到第二个断点，请输入：

skip 1

也可请参阅 cont 子命令。

source 子命令

source 文件

source 子命令从 File 参数指定的文件中读取 dbx 子命令。

示例

要读取 dbx 子命令，请执行以下操作:cmdfile文件，请输入:

source cmdfile

请参阅从文件中读取 dbx 子命令在 常规编程概念: 编写和调试程序 中。

status Subcommand

status [ more ] [ >文件 ]

status 子命令显示所有用户定义的断点，跟踪点和观察点以及其余线程 tskip 计数 (使用 tskip 子命令设置)。如果指定了 more 参数，那么 status 子命令还将显示与这些断点、跟踪点和观察点关联的 dbx 子命令。 status 子命令列出启用的事件，事件编号周围用方括号（[]）标出；禁用的事件，事件编号周围用句号（...）标出；推迟的事件，事件编号周围用角括弧（<>）标出。

> 标志将 status 子命令的输出发送到 File 参数中指定的文件。

标志

项	描述
>`文件`	重定向输出到 `File`文件中。

示例

要显示用户定义的所有断点，跟踪点和观察点以及其余线程 tskip 计数，请输入:

status

输出类似于：

[1] stop at 13
[2] stop at 14
.3. stop at 15
.4. stop at 16
[5] stop at 17 ( count = 0, limit = 3 )
<6> stop at 18 if g > 10
<7> stop in func

Remaining tskip counts:
tskip 2 for $t1
tskip 1 for $t5

在示例输出中，事件 3 和 4 已禁用，而事件 6 和 7 已延迟。

要使用关联的 dbx 子命令来显示所有用户定义的断点、跟踪点和观察点，请输入：

status more

输出类似于：

       [1] stop at 13
           [1] where 
       .2. stop at 14
           [1] where
           [2] registers        
       <3> stop at 15 if g > 10
           [1] where; registers

请参阅 addcmd 子命令， clear 子命令， delete 子命令， delcmd 子命令， tskip 子命令， stop 子命令和 trace 子命令以获取 dbx 命令。

另请参阅设置和删除断点在 常规编程概念: 编写和调试程序 中。

step 子命令

step [ 数字 ]

step 子命令运行应用程序源命令行。通过 Number 参数指定执行的行数。如果省略了 Number 参数，那么缺省值为 1。

如果在多线程应用程序中使用 step 子命令，那么所有用户线程都在该操作期间运行，但该程序仍继续执行，直到正在运行的线程到达指定的源程序行。如果要仅单步执行正在运行的线程，请使用 set 子命令来设置变量 $hold_next。设置此变量可能会导致死锁，因为正在运行的线程可能会等待其中一个阻塞线程所持有的锁。

注: 使用 set 子命令的 $stepignore 变量来控制 step 子命令的行为。 $stepignore 变量使 step 子命令单步跳过大的无法获得调试信息的例程。

示例

要继续执行一个源程序行，请输入：
```
step
```
要继续执行五个源程序行，请输入：
```
step 5
```
要防止 dbx 程序单步执行 printf 函数，如以下示例代码中所说明：
```
60 printf ("hello world \n");
```
请输入：
```
set $stepignore="function"; step
```

请参阅 cont 子命令， goto 子命令， next 子命令， set 子命令和 stepi 子命令。

stepi 子命令

stepi [ 数字 ]

stepi 子命令运行应用程序的指令。通过 Number 参数指定执行的指令数。如果省略了 Number 参数，那么缺省值为 1。

如果在多线程应用程序上使用，stepi 子命令只单步执行当前运行的线程。所有其他的线程都将停止。

示例

要继续执行一条机器指令，请输入：
```
stepi 
```
要继续执行五条机器指令，请输入：
```
stepi 5
```

请参阅 gotoi 子命令， nexti 子命令和 step 子命令。

stop 子命令

stop {[Variable ] [ at SourceLine | in Procedure | on load ["ModuleName"]] [ if Condition ]} ["{"Limit"}"]

stop 子命令在满足特定条件时停止应用程序。应用程序将会在以下条件停止：

当使用 if Condition 标志时， Condition 为 true。
如果使用了在 程序 标志，那么将调用 程序 。
在指定了 Variable 参数的情况下更改了 Variable。
如果使用 at SourceLine 标志，那么将达到 SourceLine 行号。
SourceLine 变量可以通过一个整数或者代表文件名的字符串后跟 :（冒号）和一个整数的方法指定。
如果使用了 on load 标志并且指定了 ModuleName 参数，那么将装入或卸载 ModuleName 装入的模块。
可选的 ModuleName 变量可指定为单个模块名称或以以下格式与成员名配对的模块名称。
```
ModuleName(MemberName)
```
如果使用 on load 标志且不指定 ModuleName 参数，那么装入或卸载任何已装入的模块。

可以设置 Limit 参数以指示 dbx 命令忽略某个条件达指定次数。换句话说，Limit 参数指定在停止执行调试程序之前必须满足指定条件的次数。

在上述任何命令之后，dbx 调试程序会以一条消息来响应，报告它因为您执行命令而构建的事件。该消息包括和您的断点相关的事件的 ID 以及您的命令的解释。解释的语法可能与您的命令不同。例如：

stop in main
[1] stop in main
stop at 19 if x == 3
[2] stop at "hello.c":19 if x = 3
stop in func
<3> stop in func
stop g 
<4> stop g
stop in getdata {3} 
[5] stop in getdata ( count = 0, limit = 3 )

方括号 ([]) 中的数字为与断点关联的事件标识。 dbx 调试程序将事件号和每个 stop 子命令联系起来。当程序由于某个事件而停止时，该事件标识将与当前行一起显示，以指示哪个事件造成程序停止。角括号 (<>) 中的数字是延迟事件的事件标识符。延迟事件是没有任何与之关联的断点、跟踪点或观察点的事件，每当输入命令涉及当前未装入内存的符号时，将创建延迟事件。每当对应于常规事件的模块卸载时，在方括号 ([]) 中显示的常规事件也会转换为延迟事件。每当对应于延迟事件的模块装入内存时，延迟事件将转换为常规事件，并创建对应的断点、跟踪点或观察点。您创建的事件可以与用 dbx 命令创建的内部事件共存，因此事件号可能并不总是连续的。

使用 limitbp 子命令创建事件后，可以将限制与该事件相关联。要查看与事件关联的限制，可以使用 printbp 子命令。

使用 status 子命令来查看这些数字。您可以将输出从 status 重定向到文件。使用 delete 或 clear 子命令来关闭 stop 子命令，或使用 enable 或 disable 子命令。可使用 addcmd 子命令来将 dbx 子命令添加到指定的事件号，并且可使用 delcmd 子命令来从指定的事件号删除关联的 dbx 子命令。

在多线程应用程序中，所有用户线程都将在任一用户线程遇到断点时停止。除非指定条件 (如示例 9中所示) ，否则源行或函数上的断点集将被执行该行或函数的任何用户线程命中。以下别名自动指定条件：

b帖(Function， ThreadNumber)
blth(SourceLine,ThreadNumber)

ThreadNumber 是 thread 子命令所报告的符号线程名的数字部分 (例如， 5 是线程名 $t5的 ThreadNumber )。这些别名实际上是可以产生如以下示例中所示的扩展子命令的宏：

stopi at &Function if ($running_thread == ThreadNumber)
stop at SourceLine if ($running_thread == ThreadNumber)

标志

项	描述
at `SourceLine`	指定行号。
if `Condition`	指定条件，例如 true。
in `Procedure`	指定调用的过程。
在装入时 `ModuleName`	指定要监视的装入模块。

示例

要在第一个语句中停止执行main过程，请输入:
```
stop in main
```
值时停止执行x在行上更改变量12输入:
```
stop x at 12
```
在文件中的第 5 行停止执行sample.c，请输入:
```
stop at "sample.c":5
```
要检查值x每次 dbx 命令运行子例程时func1，请输入:
```
stop in func1 if x = 22
```
要检查值x每次 dbx 命令开始运行时func1，请输入:
```
stopi at &func1 if x = 22
```
要在 Variable 的值更改时停止程序，请输入：
```
stop Variable
```
要每当 Condition 求值为 true 时都停止程序，请输入：
```
stop if (x > y) and (x < 2000)
```
以下示例说明了如何显示活动的事件并将它们除去：
```
status
[1] stop in main
[2] stop at "hello.c":19 if x = 3
delete 1
status
[2] stop at "hello.c":19 if x = 3
clear 19
status
(dbx)
```
delete 命令用事件标识删除事件。 clear 命令通过行号删除了断点。
要在开始时放置断点func1仅当由线程执行时$t5，请输入下列其中一个等效命令:
```
stopi at &func1 if ($running_thread == 5)
```
或
```
bfth(func1, 5)
```
要在装入或卸载了任何模块时停止程序，请输入：
```
stop on load
```
要在装入或卸载了 Module 模块时停止程序，请输入：
```
stop on load "Module"
```
要在装入或卸载了 Module 模块的 Member 成员时停止程序，请输入：
```
stop on load "Module(Member)"
```
要在第三次调用函数 getdata 时停止程序，请输入：
```
stop in getdata {3}
```

请参阅 addcmd 子命令， clear 子命令， delete 子命令， delcmd 子命令， disable 子命令， enable 子命令， limitbp 子命令， printbp 子命令， status 子命令， stopi 子命令，和 trace 子命令。另请参阅设置和删除断点在 常规编程概念: 编写和调试程序 中。

stophwp 子命令

stophwp 地址大小

stophwp 子命令为指定的内存区域设置一个硬件观察点停止。如果区域的内容更改，那么程序将停止。

注意：

stophwp 子命令的成功之处在于硬件依赖性。此功能仅在 POWER630 和 POWER4 上可用。
由于只能设置单个观察点的硬件限制，活动观察点事件在尝试使用 stophwp 和 tracehwp创建另一个硬件观察点事件时充当冲突。同样的，以前的事件必须在创建一个新的事件之前删除。此外，由于存在活动的软件观察点（通过调用 stop 和 trace 子命令若干次来创建）会对硬件观察点的性能增益产生负面影响，因此这些类型的事件也会导致冲突，在创建硬件观察点之前必须加以删除。

示例

要在起始地址为 0x200004e8 的 4 字节内存区域的内容更改时停止程序，请输入：
```
stophwp 0x200004e8 4
```

请参阅 tracehwp 子命令。

stopi 子命令

stopi {[Address] [ at Address | in Procedure ] [ if Condition ]}

stopi 子命令在指定的位置设置一个停止点：

借助 if Condition 标志，当指定条件为 true 时，程序会停止。
借助 Address 参数，当 Address 的内容更改时，程序会停止。
借助 at Address 标志，会在指定地址处设置停止点。
借助 in Procedure 标志，当调用 Procedure 时，程序会停止。

标志

项	描述
if `Condition`	指定条件，例如 true。
in `Procedure`	指定调用的过程。
at `Address`	指定机器指令地址。

示例

要在地址处停止执行0x100020f0，请输入:
```
stopi at 0x100020f0
```
在地址内容时停止执行0x100020f0更改，输入:
```
stopi 0x100020f0
```
当线程更改地址 0x100020f0 的内容时停止执行$t1，请输入:
```
stopi 0x200020f0 if ($running_thread == 1)
```

请参阅 stop 子命令。另请参阅使用 dbx 在机器级别进行调试在 常规编程概念: 编写和调试程序 中。

thdata 子命令

thdata [ $tthreadnumber [all | key1 ...] … ] | [全部]

thdata 子命令打印特定于线程的数据，这些数据与其他通过使用 pthread_key_create¬() 函数来创建的键相关联。可以按以下方式使用 thdata 子命令。

命令	操作
thdata [全部]	打印线程特定数据，该数据与所有可用线程的全部键相关联。
thdata $t1 [全部]	打印线程特定数据，该数据与 `$t1` 线程的全部键相关联。
thdata $t1 key1 key2	打印线程特定数据，该数据与 $t1 线程的键 key1 和 key2 相关联。
THDATA $t1 key1 key2 $t2 key1	打印两项线程特定数据，其中一项与 $t1 线程的键 key1 和 key2 相关联，另一项与 $t2 线程的键 key1 相关联。

示例

要打印与具有全部可用键的当前线程相关联的数据，请输入：

(dbx) thdata $t1
Thread  :  1
	Key : 1 Data pointer : 0x200f7a28
	Key : 2  Data pointer : 0x200f7aa8
	Key : 3 Data pointer : 0x200f7ac4
(dbx)

要打印与多个线程和多个键相关联的数据，请输入：

(dbx) thdata $t1 2 3 $t2
Thread  :  1
	Key : 2  Data pointer : 0x200f7aa8
	Key : 3 Data pointer : 0x200f7ac4
Thread : 2
	Key : 2  Data pointer : 0x200f7b24
	Key : 3 Data pointer : 0x200f7ba4
(dbx)

请参阅 "常规编程概念: 编写和调试程序" 中的特定于线程的数据

thread 子命令

显示所选线程

thread {[ info ] [ - ] [ ThreadNumber ...]} | current | run | susp | term | wait

选择单个线程

thread 当前 [-] ThreadNumber

保持或释放线程

thread { hold | unhold } [-] [ ThreadNumber ...]

所显示选项的帮助

thread { 帮助}

thread 子命令显示和控制用户线程。

thread 子命令的第一种形式可以两种格式显示信息。如果 thread 子命令是 th，那么会使用第一种格式显示信息。如果 thread 子命令是 th -，那么会按照第二种格式显示信息。如果不指定参数，那么会显示所有用户线程的信息。如果指定了一个或多个 ThreadNumber 参数，那么会显示相关用户线程的信息。当 thread 子命令显示线程时，当前线程行前面有 >。如果正在运行的线程与当前线程不同，那么其行以 *开头。由 thread 子命令按照两种方式显示的信息如下。

由 thread 子命令按照第一种方式显示的信息如下所示：

项	描述
`thread`	指示用户线程的符号名称，格式为`$tThreadNumber`.
`state-k`	指示内核线程的状态（如果用户线程已连接到内核线程）。这可能是`run`,`wait`,`susp`，或`term`，用于正在运行，正在等待，已暂挂或已终止。
`wchan`	指示内核线程正在等待或者处于休眠的事件（如果用户线程已连接到内核线程）。
`state-u`	指示用户线程的状态。可能的状态为`running`,`blocked`，或`terminated`.
`k-tid`	指示内核线程标识（如果用户线程已连接到内核线程）。
`mode`	指示用户线程的停止方式（内核或用户；如果用户线程已连接到内核线程）。
`held`	指示是否已挂起用户线程。
`scope`	指示用户线程的争用作用域; 这可以是`sys`或`pro`用于系统或进程争用作用域。
`function`	指示用户线程函数的名称。

由 thread 子命令按照第二种方式显示的信息如下。按照缺省值，对于 thread 子命令 th - 参数，显示的信息是长格式。

项	描述
`thread`	指示用户线程的符号名称，格式为`$tThreadNumber`.

与内核线程相关的信息

项	描述
`tid`	指示用户线程标识（如果用户线程已连接到内核线程）。
`pri`	指示内核线程的优先级。
`sched`	指示内核线程的调度策略。对于 fifo、other 或循环调度策略，此值可以是 fif、oth 或 rr。
`state`	指示内核线程的状态（如果用户线程已连接到内核线程）。对于 running、waiting、suspended 或 zombie，此值可以是 run、wait、susp 或 zomb。

与用户线程相关的信息

项	描述
`tid`	指示用户线程标识。
`pri`	指示用户线程的优先级。
`sched`	指示用户线程的调度策略。对于 fifo、other 或循环调度策略，此值可以是 fif、oth 或 rr。
`state`	指示用户线程的状态。此值可以是 running、creating、suspended、blocked、runnable 或 terminated。
`state`	按照十六进制指示用户状态。
`flags`	按照十六进制指示 pthread 标志的值。
`wchan`	指示内核线程正在等待或者处于休眠的事件（如果用户线程已连接到内核线程）。
`mode`	指示用户线程的停止方式（内核或用户；如果用户线程已连接到内核线程）。
`held`	指示是否保持用户线程。
`scope`	指示用户线程的争用作用域；对于系统或进程争用作用域，此值可以是 sys 或 pro。
`cancelation`	`pending` 指示取消是否已暂挂。 `state` 指示取消的方式和状态。如果取消未暂挂，且状态和方式分别是已启用和已延迟，那么用 ed 表示；如果取消状态和方式是已启用和异步，那么用 ea 表示；如果方式不是已启用，那么用 d 表示。如果取消已暂挂，且取消状态和方式分别是已启用和已延迟，那么用 ED 表示；如果取消状态和方式是已启用和异步，那么用 EA 表示；如果方式不是已启用，那么用 D 表示。

项	描述
`joinable`	指示是否可以连接线程。
`boosted`	指示线程的 boosted 值。
`function`	指示用户线程函数的名称。
`cursig`	指示当前信号值。

如果设置了选项$thcomp设置，则信息以压缩形式显示，如以下示例所示。

m           mode           (k)ernel (u)ser
k           k-state        (r)unning (w)aiting (s)uspended (z)ombie
u           u-state        (r)unning (R)unnable (s)uspended (t)erminated

                           (b)locked (c)reating
h           held           (yes) (n)o
s           scope          (s)ystem (p)rocess
c           cancellation   not pending:  (e)nabled & (d)eferred,
                                         (e)nabled & (a)sync, (d)isabled
                           pending    :  (E)nabled & (D)eferred,
                                         (E)nabled & (A)sync, (D)isabled
j           joinable       (yes) (n)o
b           boosted        value of boosted field in pthread structure
plk         kernel thread  (oth)er  (fif)o  (rr)-> round-robin
            policy
plu         user thread    (oth)er  (fif)o  (rr)-> round-robin
            policy
prk         kernel thread  hex number
            policy
pru         user thread    hex number
            policy
k-tid                      kernel thread id in hex
u-tid                      pthread id in hex
fl                         value of flags field in pthread structure in hex
sta                        value of state field in pthread structure in hex
cs                         value of the current signal
wchan                      event for which thread is waiting
function                   function name

thread 子命令的第二种格式用来选择当前线程。 dbx 调试程序的 print， registers和 where 子命令都在当前线程的上下文中工作。如果当前的线程处于内核方式 registers 子命令不能显示寄存器。

thread 子命令的第三种格式用来控制线程的执行。可以使用 hold 标志保持线程，或者使用 unhold 标志释放线程。保持的线程只有在释放后才会恢复执行。

注: dbx 调试程序的 print 子命令可识别符号线程名称，并可用于显示相应对象的状态。

标志

项	描述
当前	如果不指定 `ThreadNumber` 参数，将会显示当前的线程。如果指定了 `ThreadNumber` 参数，选择指定的用户线程作为当前线程。
help	显示所有在使用 th - 命令时显示的线程选项的相关信息。
挂起	如果没有 `ThreadNumber` 参数，那么会保持和显示所有的用户线程。如果指定了一个或多个 `ThreadNumber` 参数，将会保持并显示指定用户线程。
取消挂起	如果不指定 `ThreadNumber` 参数将会释放和显示所有以前保持的用户线程。如果指定了一个或多个 `ThreadNumber` 参数，将会释放并显示指定的用户线程。
信息	如果不指定 `ThreadNumber` 参数，将显示所有用户线程的长格式列表。如果指定了一个或多个 `ThreadNumber` 参数将会显示指定用户线程的长格式列表。先前的所有标志都采用 [-] 选项。如果提供了此选项，那么显示的线程信息将采用第二种格式和长格式，除非`set $thcomp`选项已设置。
运行	显示处于以下状态的线程:`run`公开帖子，
susp	显示处于以下状态的线程:`susp`公开帖子，
期限	显示处于以下状态的线程:`term`公开帖子，
WAIT	显示处于以下状态的线程:`wait`公开帖子，

示例

要显示有关处于等待状态的线程的信息，请输入:

thread wait

输出类似于：

thread  state-k   wchan state-u   k-tid mode held scope function 
 $t1     wait            running   17381   u   no   pro  main
 $t3     wait            running    8169   u   no   pro  iothread

要显示若干给定线程的信息，请输入：

thread 1 3 4

输出类似于：

thread  state-k   wchan state-u   k-tid mode held scope function
 $t1     wait           running   17381   u   no   pro  main
 $t3     wait           running    8169   u   no   pro  iothread
>$t4     run            running    9669   u   no   pro  save_thr

要使线程 4 成为当前线程，请输入:
thread current 4
要挂起线程号 2 ，请输入:
thread hold 2

要以第二种格式显示处于等待状态的线程的信息，请输入：

thread wait -

输出类似于：

thread m k u h s c  j b  kpl  upl  kpr upr k_tid   u_tid   fl  sta wchan  function
*$t1   u r w n p ed y 0  oth  oth  61   1  0043e5  000001  51  004        main
 $t3   u r w n p ed y 0  oth  oth  61   1  001fe9  000102  51  004        iothread
>$t4   u r r n p ed y 0  oth  oth  61   1  0025c5  000203  50  064        save_thr

要按照第二种格式显示若干给定线程的信息，请输入：

thread - 1 2 3

输出类似于：

thread m k u h s c  j b  kpl  upl  kpr upr k_tid   u_tid   fl  sta wchan function
*$t1   u r w n p ed y 0  oth  oth  61   1  0043e5  000001  51  004       main
 $t3   u r w n p ed y 0  oth  oth  61   1  00fe9   000102  51  004       iothread
>$t4   u r r n p ed y 0  oth  oth  61   1  0025c5  000203  50  064       save_thr

请参阅 attribute 子命令， condition 子命令， mutex 子命令， print 子命令， registers 子命令和 where 子命令。

另请参阅 一般编程概念: 编写和调试程序中的创建线程。

tls 子命令

tls map

tls 子命令仅使用一个标志来显示每个装入的 TLS 模块的 TLS 初始化模板源和长度。

tm_status 子命令

tm_status

tm_status 子命令显示 $texasr 变量的内容（事务异常和摘要寄存器），并解释该内容以确定事务失败的原因和本质。

示例

要显示存储在 $texasr 变量中的值，并对其进行解释，请输入下列命令：

(dbx) tm_status

将显示类似于以下示例的输出：

REGISTER : TEXASR = 0x100000018C000001
Bit(s)   |Field                     |Meaning
_________________________________________________________________________________
0-7      Failure Code                TM_SIG_DELIVERED | Failed due to signal delivery
7        Failure Persistent          Failure is transient
31       Abort                       Execution of TM instruction caused Abort
32       Suspended                   Failure while in Suspended State
34-35    Privilege                   During Failure process-thread privilege state was 0
36       Failure                     Summary Failure recording has been performed
37       TFIAR (in)exact             TFIAR is exact
38       Rollback Only Transaction   non-ROT tbegin. initiated
52-63    Transaction Level           1

tnext 子命令

tnext [编号]

tnext 子命令将运行中的线程运行到下一个源行。 Number 参数指定 tnext 子命令运行的次数。如果未指定 Number 参数，那么 tnext 仅运行一次。只能对系统范围线程启动此子命令。

所有线程都在此操作期间运行。要在此操作期间捕获断点，请设置 $catchbp dbx 变量。如果设置了 $catchbp 变量，并且另一个线程达到了断点，那么 tnext 子命令不会重复剩余的次数。

示例

要继续执行正在运行的线程，直到执行至下一个源程序行，请输入：
```
tnext
```
要继续执行正在运行的线程，直到执行至当前源程序行的后面第三行，请输入：
```
tnext 3
```

请参阅 tnexti 子命令。另请参阅 "涉及多个线程的调试程序" 在 常规编程概念: 编写和调试程序 中。

tnexti 子命令

tnexti [编号]

tnexti 子命令运行正在运行的线程直到下一个指令。 Number 参数指定 tnexti 子命令运行的次数。如果未指定 Number 参数，那么 tnexti 仅运行一次。只能对系统范围线程启动此子命令。

所有线程都在此操作期间运行。要在此操作期间捕获断点，请设置 $catchbp dbx 变量。如果设置了 $catchbp 变量，并且另一个线程达到了断点，那么 tnexti 子命令不会重复剩余的次数。

示例

要继续执行正在运行的线程，直到执行至下一条机器指令，请输入：
```
tnexti
```
要继续执行正在运行的线程，直到执行至当前机器指令后面的第三条机器指令，请输入：
```
tnexti 3
```

请参阅 tnext 子命令。另请参阅 "涉及多个线程的调试程序" 在 常规编程概念: 编写和调试程序 中。

trace 子命令

程序运行时 trace 子命令打印指定过程、函数、命令行、表达式或变量的跟踪信息。 SourceLine 变量可以通过一个整数或者代表文件名的字符串后跟 :（冒号）和一个整数的方法指定。可以指定条件。 dbx 调试程序将一个数字与每个 trace 子命令相关联。使用 status 子命令来查看这些数字。使用 delete 子命令来关闭跟踪。您可以分别使用 enable 和 disable 子命令来启用和禁用跟踪。

trace 子命令可以在被调试进程装入或卸载了模块时显示跟踪信息。可选的 ModuleName 参数可指定为单个模块名称或以以下格式与成员名配对的模块名称。

ModuleName(MemberName)

如果在不使用 ModuleName 参数的情况下使用 on load 标志，那么 dbx 命令将跟踪所有模块的装入和卸载。

缺省情况下，跟踪基于进程。要进行基于线程的跟踪，请在条件中指定线程 (如示例 8中所示)。

标志

项	描述
at `SourceLine`	指定发现被跟踪的表达式的源行。
if `Condition`	指定跟踪开始的条件。跟踪仅开始 if `Condition` 为 true。
in `Procedure`	指定用来发现被跟踪的过程或者变量的过程。
on load `ModuleName`	指定要监视的装入模块。

示例

要跟踪对 printf 过程的每个调用，请输入：
```
trace printf
```
要跟踪文件 hello.c 中第 22 行的每次执行，请输入：
```
trace "hello.c":22
```
要在 main 过程中跟踪对 x 变量的更改，请输入:
```
trace x in main
```
要跟踪数据地址 0x2004000，请输入：
```
set $A=0x2004000
trace $A
```
注: tracei 子命令旨在跟踪地址。
可将源程序行的显示限制在指定的 Procedure 处于活动状态时。您也可以指定可选的 Condition 来控制何时必须产生跟踪信息。例如：
```
(dbx) trace in sub2
[1] trace in sub2
(dbx) run
trace in hellosub.c:  8  printf("%s",s);
trace in hellosub.c:  9  i = '5';
trace in hellosub.c:  10  }
```
可在每次调用或返回过程时都显示一条消息。当调用了一个过程时，该消息包括所传递参数以及调用例程的名称。在返回中，该信息包括从 Procedure 返回的值。例如：
```
(dbx) trace sub
[1] trace sub
(dbx) run
calling sub(s = "hello", a = -1, k = delete) from function main
returning "hello" from sub
```

可在程序执行到指定的源程序行时显示 Expression 的值。会显示行号和文件，但是不会显示源程序行。例如：

(dbx) trace x*17 at "hellosub.c":8 if (x > 0)
[1] trace x*17 at "hellosub.c":8 if x > 0
(dbx) run
at line 8 in file "hellosub.c": x*17 = 51
 
(dbx) trace x
[1] trace x
initially (at line 4 in "hello.c"):  x = 0
after line 17 in "hello.c":  x = 3

要跟踪线程 $t1对 x 变量所作的更改，请输入以下命令:
```
(dbx) trace x if ($running_thread == 1)
```
要跟踪所有模块的装入或卸载，请输入以下命令：
```
trace on load
```
要跟踪模块 Module 的装入或卸载，请输入以下命令：
```
trace on load "Module"
```
要跟踪模块 Module 中成员 Member 的装入或卸载，请输入以下命令：
```
trace on load "Module(Member)"
```

另请参阅 tracei 子命令。

tracehwp 子命令

tracehwp 地址大小

tracehwp 子命令为指定的内存区域设置一个硬件观察点停止。如果区域的内容发生了变化，dbx 调试程序打印跟踪信息。

注意：

tracehwp 子命令的成功之处在于硬件依赖性。此功能仅在 POWER630 和 POWER4 上可用。
由于只能设置单个观察点的硬件限制，活动观察点事件在尝试使用 stophwp 和 tracehwp创建另一个硬件观察点事件时充当冲突。同样的，以前的事件必须在创建一个新的事件之前删除。此外，由于存在活动的软件观察点（通过调用 stop 和 trace 子命令若干次来创建）会对硬件观察点的性能增益产生负面影响，因此这些类型的事件也会导致冲突，在创建硬件观察点之前必须加以删除。

示例

要在每次起始地址为 0x200004e8 的 4 字节内存区域的内容更改时进行跟踪，请输入以下命令：
```
 tracehwp 0x200004e8 4 
```

请参阅 stophwp 子命令。

tracei 子命令

tracei [[Address] [at Address | in Procedure] | Expression at Address] [if Condition]

tracei 子命令在如下情况下开启跟踪：

如果包括了 Address 标志，那么由 Address 参数指定的地址的内容会更改。
如果指定了 at Address 参数，那么将运行 Address 上的指令。
如果包含 in Procedure 标志，那么由 Procedure 指定的过程处于活动状态。
如果包含 if Condition 标志，那么 Condition 参数指定的条件为 true。

标志

项	描述
at `Address`	指定一个地址。当该地址处的指令被运行时可以启用跟踪。
if `Condition`	指定条件。当满足该条件时启用跟踪。
in `Procedure`	指定一个过程。该过程处于活动时启用跟踪。

示例

要跟踪执行的每条指令，请输入以下命令：
```
tracei
```
要在每次执行地址 0x100020f0 处的指令时进行跟踪，请输入以下命令：
```
tracei at 0x100020f0
```
要每次在 main 过程处于活动状态期间内存位置 0x20004020 的内容更改时进行跟踪，请输入以下命令：
```
tracei 0x20004020 in main
```
要在每次线程 $t4 执行地址 0x100020f0 处的指令时进行跟踪，请输入以下命令：
```
tracei at 0x100020f0 if ($running_thread == 4)
```

请参阅 trace 子命令。另请参阅 "使用 dbx 在 常规编程概念: 编写和调试程序 中在机器级别进行调试"。

tskip 子命令

tskip [编号]

tskip 子命令从当前停止点继续执行正在运行的线程。正在运行的线程会跳过用 Number 参数指定的线程级别断点数目。只能对系统范围线程启动此子命令。

所有其他线程在此操作期间都运行，并且用户指定的所有断点和观察点将被捕获。当任何线程遇到断点或观察点时，执行会停止。即使 tskip 子命令所启动的执行过程可能由于另一个线程的事件而停止，对前一个线程指定的 tskip 计数也仍处于活动状态，而且当该进程继续执行时，对于该线程而言，会忽略 tskip 计数所指定的线程级别断点数目。当线程结束时，会删除与其相关联的 tskip 计数。

使用 status 子命令可查看该线程的剩余 tskip 计数。使用 delete 子命令可删除该线程的剩余 tskip 计数。

示例

要继续执行，直至遇到从正在运行的线程的当前停止点开始的第二个线程级断点，请输入：

tskip 1

请参阅 cont 子命令。另请参阅 "涉及多个线程的调试程序" 在 常规编程概念: 编写和调试程序 中。

tstep 子命令

tstep [编号］

tstep 子命令从正在运行的线程的当前源程序行运行指定数量的源程序行。 Number 参数指定 tstep 子命令运行的次数。如果未指定 Number 参数，那么 tstep 仅运行一次。只能对系统范围线程启动此子命令。

所有线程都在此操作期间运行。如果设置了 $hold_next，那么将占用除处于运行状态的线程之外的所有其他线程。

注: 使用 set 子命令的 $stepignore 变量来控制 tstep 子命令的行为。 $stepignore 变量使 tstep 子命令能够单步执行没有可用的调试信息的大型例程。

示例

要使正在运行的线程继续执行一个源程序行，请输入：
```
tstep
```
要使正在运行的线程继续执行五个源程序行，请输入：
```
tstep 5
```
要防止 dbx 程序单步执行 printf 函数，如示例代码中所示:
```
60 printf ("hello world /n");
```
请输入：
```
set $stepignore="function"; step
```

请参阅 cont 子命令， goto 子命令， tnext 子命令， set 子命令和 tstepi 子命令。另请参阅 "涉及多个线程的调试程序" 在 常规编程概念: 编写和调试程序 中。

tstepi 子命令

tstepi [编号]

tstepi 子命令从正在运行的线程的当前指令运行指定数量的指令。 Number 参数指定 tstepi 子命令运行的次数。如果未指定 Number 参数，那么 tstepi 仅运行一次。只能对系统范围线程启动此子命令。

所有线程都在此操作期间运行。如果设置了 $hold_next，那么将占用除处于运行状态的线程之外的所有其他线程。

示例

要使正在运行的线程继续执行一条机器指令，请输入：
```
tstepi
```
要使正在运行的线程继续执行五条机器指令，请输入：
```
tstepi 5
```

请参阅 gotoi 子命令， tnexti 子命令和 tstep 子命令。另请参阅 "涉及多个线程的调试程序" 在 常规编程概念: 编写和调试程序 中。

tstop 子命令

tstop { in 过程 | [变量] at SourceLine [ if 条件 ]} [for $tthreadnumber]

tstop 子命令为线程设置源程序级断点停止，并在指定线程到达断点时停止应用程序。所指定的线程在创建事件时必须是存在的。如果不指定线程，那么将使用当前线程。当发生以下任一情况时，指定线程将停止：

将使用 if Condition 标志，并且 Condition 为 true。
将使用 in 过程标志，并调用过程。
使用了 at SourceLine 标志，并且达到了 SourceLine 行号。 SourceLine 变量可指定为整数，也可指定为后跟一个冒号 (:) 和一个整数的文件名字符串。

线程级断点只能在系统范围线程上设置。如果同时命中线程级别断点和进程级别断点，那么会处理这些断点并报告线程级别断点。当线程终止时，将删除与其相关联的事件。

标志

项	描述
at `SourceLine`	指定行号。
for $t `threadnumber`	指定线程号。
if `Condition`	指定条件（例如，`true`）。
in `Procedure`	指定调用的过程。

示例

要在运行线程 2 时在 func 过程中的第一个语句处停止执行，请输入:
```
tstop in func for $t2
```
要在 x 变量的值在执行过程的第 12 行处更改时停止当前线程的执行，请输入：
```
tstop x at 12
```

请参阅 ttrace 子命令。另请参阅 "涉及多个线程的调试程序" 在 常规编程概念: 编写和调试程序 中。

tstophwp 子命令

tstophwp 地址大小 [for $tthreadnumber]

tstophwp 子命令为指定的内存区域设置线程级硬件观察点停止。在运行指定线程时，如果区域的内容发生更改，那么程序停止。所指定的线程在创建事件时必须是存在的。如果不指定线程，那么将使用当前线程。线程级观察点事件只能对系统范围线程设置。当线程终止时，将删除与其相关联的事件。

注意：

tstophwp 子命令的成功取决于硬件。此功能仅在 POWER630 和 POWER4 上可用。
由于硬件限制 (仅允许设置单个观察点) ，活动线程观察点事件在尝试使用 tstophwp 和 ttracehwp为同一线程创建另一个硬件观察点事件时充当冲突。为避免此问题，在创建新事件前必须删除前一个事件。由于活动软件观察点 (由 stop 和 trace 子命令的某些调用创建) 的存在可以否定硬件观察点的性能增益，因此在创建硬件观察点之前还必须删除这些类型的事件以避免冲突。
当进程级别观察点存在时，没有线程级别观察点的线程将观察进程观察点位置。如果线程有线程级别观察点，那么该线程将观察线程观察点位置。
线程级硬件观察点和进程级硬件观察点可共存，并且不会相互冲突。
如果同一个地址存在进程级别观察点和线程级别观察点，那么将报告进程级别观察点事件。

标志

项	描述
for $t `threadnumber`	指定线程号。

示例

要在线程 2 正在运行、且起始地址为 0x200004e8 的 4 字节内存区域的内容更改时停止程序，请输入：

tstophwp 0x200004e8 4 for $t2

请参阅 ttracehwp 子命令。另请参阅 "涉及多个线程的调试程序" 在 常规编程概念: 编写和调试程序 中。

tstopi 子命令

tstopi { in 过程 | [地址] at 地址 [ if 条件 ]} [for $tthreadnumber]

tstopi 子命令为线程设置指令级断点停止。所指定的线程在创建事件时必须是存在的。如果不指定线程，那么将使用当前线程。当发生以下任一情况时，指定线程将停止：

将使用 if Condition 标志，并且 Condition 为 true。
将使用 in 过程标志，并调用过程。
将使用 at Address 标志，并且将到达 Address 。

标志

项	描述
at `Address`	指定机器指令地址。
for $t `threadnumber`	指定线程号。
if `Condition`	指定条件。
in `Procedure`	指定调用的过程。

示例

要在运行线程 2 时在地址 0x100020f0 处停止执行，请输入：
```
tstopi at 0x100020f0 for $t2
```
要在运行当前线程时输入 func 过程时停止执行，请输入:
```
tstopi in func
```

请参阅 ttracei 子命令。另请参阅 "涉及多个线程的调试程序" 在 常规编程概念: 编写和调试程序 中。

ttrace 子命令

ttrace {[变量] at SourceLine | 过程 } [ if 条件 ] [for $tthreadnumber]

ttrace 子命令在指定线程运行时显示指定过程、函数、源程序行和变量的跟踪信息。 SourceLine 变量可指定为整数，也可指定为后跟一个冒号 (:) 和一个整数的文件名字符串。 dbx 调试程序将一个编号与每个 ttrace 子命令相关联。使用 status 子命令来查看这些数字。使用 delete 子命令来关闭跟踪。可分别使用 enable 和 disable 子命令来启用及禁用跟踪。

如果不指定线程，那么将使用当前线程。线程级跟踪只能对系统范围线程设置。所指定的线程在创建事件时必须是存在的。当线程结束时，将删除与其相关联的事件。

标志

项	描述
at `SourceLine`	指定发现被跟踪的表达式的源行。
for $t `threadnumber`	指定线程号。
if `Condition`	指定跟踪开始的条件。仅在 Condition 为 true 时跟踪才会开始。
in `Procedure`	指定用来查找要跟踪的过程或变量的过程。

示例

要在运行线程 2 时跟踪对 printf 过程的每个调用，请输入:
```
ttrace printf for $t2
```
要在当前线程运行时跟踪文件 hello.c/ 中第 22 行的每次执行，请输入：
```
ttrace "hello.c":22
```

请参阅 ttracei 子命令。另请参阅 "涉及多个线程的调试程序" 在 常规编程概念: 编写和调试程序 中。

ttracei 子命令

ttracei [Address] at Address [if Condition]} [for $tthreadnumber]

当发生下列任何情况时， ttracei 子命令将打开对指定线程的跟踪:

包含 if Condition 标志，并且 Condition 为 true。
指定了 at Address 标志，并运行位于 Address 的指令。

标志

项	描述
at `Address`	指定一个地址。当该地址处的指令被运行时可以启用跟踪。
for $t `threadnumber`	指定线程号。
if `Condition`	指定条件。当满足该条件时启用跟踪。

示例

在线程 3 运行时，要在每次执行地址 0x100020f0 处的指令时进行跟踪，请输入：
```
tracei at 0x100020f0 for $t3
```
要在当前线程每次执行地址 0x100020f0 处的指令时进行跟踪，请输入：
```
tracei at 0x100020f0 
```

请参阅 ttrace 子命令。另请参阅 "涉及多个线程的调试程序" 在 常规编程概念: 编写和调试程序 中。

ttracehwp 子命令

ttracehwp 地址大小 [for $tthreadnumber]

ttracehwp 子命令为指定的内存区域设置线程级硬件观察点跟踪。在运行指定线程时，如果区域的内容发生更改，那么 dbx 调试程序显示跟踪信息。所指定的线程在创建事件时必须是存在的。如果不指定线程，那么将使用当前线程。线程级观察点事件只能对系统范围线程设置。当线程终止时，将删除与其相关联的事件。

注意：

ttracehwp 子命令的成功取决于硬件。此功能仅在 POWER630 和 POWER4 上可用。
由于硬件限制 (仅允许设置单个观察点) ，活动线程观察点事件在尝试使用 tstophwp 和 ttracehwp为同一线程创建另一个硬件观察点事件时充当冲突。为避免此问题，在创建新事件前必须删除前一个事件。由于活动软件观察点 (由 stop 和 trace 子命令的某些调用创建) 的存在可以否定硬件观察点的性能增益，因此在创建硬件观察点之前还必须删除这些类型的事件以避免冲突。
当进程级别观察点存在时，没有线程级别观察点的线程将观察进程观察点位置。如果线程有线程级别观察点，那么该线程将观察线程观察点位置。
线程级硬件观察点和进程级硬件观察点可共存，并且不会相互冲突。
如果同一个地址存在进程级别观察点和线程级别观察点，那么将报告进程级别观察点事件。

标志

项	描述
for $t `threadnumber`	指定线程号。

示例

在运行线程 2 时，要在起始地址为 0x200004e8 的 4 字节内存区域的内容每次发生更改时进行跟踪，请输入：

ttracehwp 0x200004e8 4 for $t2

请参阅 tstophwp 子命令。另请参阅 "涉及多个线程的调试程序" 在 常规编程概念: 编写和调试程序 中。

unalias 子命令

unalias 名称

unalias 子命令除去由 Name 参数指定的别名。

示例

除去已命名的别名printx，请输入:

unalias printx

请参阅 alias 子命令。另请参阅正在创建子命令别名在 常规编程概念: 编写和调试程序 中。

unset 子命令

unset 名称

unset 子命令将删除与 Name 参数指定的名称相关联的 dbx 调试程序变量。

示例

要删除禁止显示浮点数寄存器的变量，请输入：

unset $noflregs

请参阅 set 子命令。另请参阅使用特殊调试变量更改打印输出在 常规编程概念: 编写和调试程序 中。

up 子命令

up [ Count ]

up 子命令将当前函数上移到堆栈 Count 个级别。当前函数用来解析名称。 Count 参数的缺省值为 1。

示例

要将当前函数在堆栈中向上移动两级，请输入：
```
up 2
```
要显示堆栈上的当前函数，请输入：
```
up 0
```

请参阅 down 子命令。另请参阅 "更改当前文件或过程，显示堆栈跟踪在 常规编程概念: 编写和调试程序 中"。

使用子命令

use [{+ | Directory | '['RegularExpression = NewPath']'} ...]

use 子命令设置 dbx 调试程序寻找源文件时要搜索的目录和要应用的路径映射的列表。如果不带参数指定 use 子命令，那么会显示要搜索的目录和要应用的路径映射的当前列表。

@（符号“@”）是一个特殊目录，它指示 dbx 程序查找目标文件（如果存在）中的完整路径名信息。如果您有一个名为 @ 的相对目录要搜索，那么必须使用./@在搜索路径中。

use 子命令使用 +（加号）来向要搜索的目录列表中添加更多目录或映射。当指定为 use 子命令的输入时， + 表示目录和映射的当前列表。必须在新目录或映射之前指定 +，才能在当前列表的表尾附加目录或映射。必须在新目录或映射之后指定 +，才能在当前列表的开头添加目录。如果具有名为 + 的目录，请指定该目录的完整路径名（例如，./+ 或 /tmp/+）。

use 子命令将括在 [ 和 ]（方括号）中的包含 =（等号）的字符串解释为路径映射。这些路径映射与特殊 @ 目录配合使用。这使得用户能在编译后重新放置源文件的整个目录结构的情况下，更容易地表示源文件位置。

调试过程中尝试找到源文件时以下规则适用：

以指定的顺序评估列表中的目录。
评估列表中的目录时，会在目录中搜索指定的文件。如果该文件存在于目录中且可读，那么会使用该文件。
评估特殊 @ 目录并且指定了一个或多个路径映射时，如果路径映射的 RegularExpression 部分与对象文件中完整路径名称信息的前 n 个字符匹配，而且替换路径映射的 NewPath 部分会产生一个可读的文件，那么使用此文件。
评估特殊 @ 目录时，如果未指定任何路径映射或不存在任何匹配路径，那么将搜索对应于完整路径名称信息的目录。如果该文件存在于目录中且可读，那么会使用该文件。
如果多个路径映射生成可读文件，那么其 RegularExpression 匹配最多字符的路径映射 (1 ... n) 应用全路径名信息 (即最具体) ，并使用生成的文件。
如果多个路径映射生成一个可读文件且每个路径映射具有相同的特殊性，那么会应用最接近列表开头的路径映射并会使用生成的文件。

注: 如果特殊 @ 目录不是列表的成员，那么将忽略可能指定的任何路径映射。

示例

要更改将搜索的目录列表为当前目录 (.)、父目录 (..) 和 /tmp 目录，请输入：
```
use . .. /tmp
```
要更改将搜索的目录列表为当前目录 (.)、编译时 (@) 源文件所在的目录和 ../source 目录，请输入：
```
use . @ ../source
```
要向将搜索的目录列表添加 /tmp2 目录，请输入：
```
use + /tmp2
```
要向要搜索目录的列表开头添加 /tmp3 目录，请输入：
```
use /tmp3 +
```
要想表示其完整路径名称信息以 /home/developer 开头的源文件现在位于 /mnt 下，请输入：
```
use + [/home/developer=/mnt]
```
要指引 dbx 程序首先在 /latest 下查找其完整路径名称信息以 /home/developer 开头的文件，然后当该处不存在该文件时在 /stable 下查找该文件，请输入：
```
use + [/home/developer=/latest] [/home/developer=/stable]
```

另请参阅 edit 子命令和 list 子命令。

whatis 子命令

whatis 名称

whatis 子命令显示 Name 的声明，其中 Name 参数指定了变量、过程或者函数的名称，块名称可选。

注: 仅在运行 dbx 调试程序时使用 whatis 子命令。

示例

显示声明x变量，输入:
```
whatis x
```
显示声明main过程，请输入:
```
whatis main
```
显示声明x中的变量main函数，请输入:
```
whatis main.x
```
要打印枚举，结构或并集标记的声明，请使用$$TagName:
```
(dbx) whatis $$status
enum $$status { run, create, delete, suspend };
```

where 子命令

where [ all | $tthreadumber [(startframe endframe)] ...] [ startframe endframe ] [ >文件 ]

where 子命令显示与帧号 startframe 到 endframe 关联的活动过程和函数的列表。堆栈帧的编号起始于当前处于活动状态的函数堆栈帧（总是以 0 为编号）。如果存在 n 帧，那么 main 函数的帧编号为 n-1。通过使用>File 标志，可以将此子命令的输出重定向到指定的文件。

在多线程环境中，选项 all 会显示所有可用线程的堆栈详细信息。通过指定线程数与 where 子命令来显示单个线程的堆栈详细信息。如果不指定单个线程的开始帧和结束帧，那么将按全局的开始帧编号和结束帧编号来显示堆栈帧。不带任何选项的命令会显示当前线程的堆栈帧。

标志

项	描述
>`文件`	重定向输出到指定的文件。

请参阅 frame 子命令， up 子命令和 down 子命令。另请参阅显示堆栈跟踪在 常规编程概念: 编写和调试程序 中。

示例

要显示所有线程的堆栈详细信息，请输入：
```
where all
```
要显示线程 $t1、$t2 和 $t3 的堆栈详细信息，请输入：
```
where $t1 $t2 $t3
```
要显示具有堆栈帧 2-3 的线程 $t2 以及具有堆栈帧 1-4 的线程 $t1 和 $t3 的堆栈详细信息，请输入：
```
where $t1 $t2(2 3) $t3 1 4
```

请参阅 frame 子命令， up 子命令和 down 子命令。另请参阅显示堆栈跟踪在 常规编程概念: 编写和调试程序 中。

whereis 子命令

whereis 标识

whereis 子命令显示所有名称符合指定标识的符号的全限定。符号打印的顺序并不重要。

示例

显示所有已命名符号的限定名x，请输入:

whereis x

另请参阅 which 子命令。

该子命令

which 标识

which 子命令显示标识的完全限定。全限定包括和该标识相关的外部块的列表。

示例

显示全部资质x符号，输入:

which x

请参阅 whereis 子命令。另请参阅在 常规编程概念: 编写和调试程序 中中的名称的作用域限定。

文件

项	描述
a.out	对象文件；包含对象代码。
core	包含核心转储。
.dbxinit	包含初始命令。

调试使用事务内存的应用程序

对于使用事务内存 (TM) 的应用程序，最可靠的调试助手是事务异常和摘要注册 ($texasr)、事务失败处理程序地址注册 ($tfhar) 和事务失败指令地址寄存器 ($tfiar) 变量。

可以使用 print 子命令显示 $texasr， $tfhar和 $tfiar 变量，这类似于显示 $iar 变量。然后，您无法使用 assign 子命令对这些寄存器的值进行操作。

$tfhar 和 $tfiar 变量包含事务失败中调试文本分段上指示信息的地址。类似于 $iar 变量，将保留这两个最重要的位：$tfhar 和 $tfiar 注册变量，并且不会考虑读取这些注册变量中的地址。

注: 当您将 $tfiar 和 $tfhar 寄存器变量与 list 子命令配合使用时， dbx 命令会在从这些寄存器变量的内容中排除两个最有效的位之后访存地址。

(dbx) list at $tfiar

或

(dbx) list at $tfhar

使用 $texasr 变量能够确定事务失败的原因。 tm_status 子命令解释事务失败的原因和性质。

dbx 命令监视事务的发生情况，并通过下列一系列消息显示事物失败的原因。在运行 run 子命令、rerun 子命令或 continue 子命令后才会显示下列这些消息。

Process {PID} may have failed a transaction - $texasr, $tfiar, $tfhar are valid and may be inspected
Process {PID} may have performed a transaction - $texasr, $tfiar, $tfhar, are valid and may be inspected
此消息仅当设置了 $trace_good_transaction 内部变量时才会显示。
Process {PID} is in Transactional State – debugging efforts through dbx may result in repeated transaction failure or undefined behavior
Process {PID} is in Suspended State – debugging efforts through dbx may result in repeated transaction failure or undefined behavior

其中 PID 是调试进程的进程标识。