GDB调试命令精粹及使用实例
gdb调试常用命令
8 9 10
删除所有断点 使断点无效 使断点有效
delete break
不需要参数
disable break <index> disable break 3：使序号为 3 的断点无效 enable break <index> enable break 3：使序号为 3 的断点有效 run：运行程序 run 12 34:带 12 和 34 两个参数运行程序 说明： run 12 34 等价于先执行 set args 12 34，然后执行 run print x:打印变量 x 的值 whatis x：打印变量 x 的类型 说明： ptype:比 whatis 的功能更强，他可以提供一个结构的定义 不需要参数 不需要参数 不需要参数 list <line1>显示程序第line1行的周围的源程序 list <line1,line2>显示第line1行到line2行之间的源代码 list <function> 显示函数名为function的函数的源程序 list 显示当前行4 15 16
打印变量值 打印变量类型 单步运行 （不进入） 单步运行（进入） 运行到断点
print <variable> whatis <variable> next step continue
17
显示源码
list
付春启 2011 年 2 月 23 日
2
gdb 调试常用命令
No. 1 功能 启动 gdb 程序 gdb 命令 用法举例（以调试程序 calc 为例） gdb：启动 gdb 调试程序 gdb ./calc：启动 gdb 调试程序，并载入 calc 文件中的符号列表 file ./calc:载入 calc 文件中的符号列表 2 载入文件符号表 打开或关闭源代码 窗口 设置程序运行参数 file <filename> 说明： gdb ./calc 等价于先执行 gdb，再执行 file ./calc 3 4 Ctrl+X+A set args 窗口切换快捷键 set args 12 34：设置程序运行参数为 12 和 34 两个参数 set args:取消先前所有参数设置 break 100：在第 100 行设置一个断点（单文件情况） break add：在 add 函数入口设置一个断点（单文件情况） 5 设置断点 break break main.cpp:100：在 main.cpp 文件的第 100 行设置一个断点（多文件 情况） break main.cpp:add ：在 main.cpp 文件中的 add 函数入口设置一个断点（ 多 文件情况） 6 7 查看断点信息 删除一个断点 info break delete break <index> 不需要参数 delete break 2:删除序号为 2 的断点
gdb调试实例
gdb调试实例1. 查看gdb命令 (2)2. 程序堆栈布局 (3)3. 调试演⽰ (5)a) 堆栈信息 (5)b) 调试多进程 (6)c) ⽆效的内存地址 (7)d) 不对齐的内存地址 (8)e) 缓冲区溢出 (9)f) 堆栈溢出 (10)4. 调试原理& 调试信息 (14)a) 调试原理 (14)b) 调试信息 (14)1. 查看gdb命令(gdb) helpList of classes of commands:STM -- STMicroelectronics specific target commandsaliases -- Aliases of other commandsbreakpoints -- Making program stop at certain pointsdata -- Examining datafiles -- Specifying and examining filesinternals -- Maintenance commandsobscure -- Obscure featuresrunning -- Running the programstack -- Examining the stackstatus -- Status inquiriessupport -- Support facilitiestracepoints -- Tracing of program execution without stopping the programuser-defined -- User-defined commandsType "help" followed by a class name for a list of commands in that class. Type "help all" for the list of all commands. Type "help" followed by command name for full documentation.Type "apropos word" to search for commands related to "word".Command name abbreviations are allowed if unambiguous.(gdb) help stackExamining the stack.The stack is made up of stack frames. Gdb assigns numbers to stack frames counting from zero for the innermost (currently executing) frame.At any time gdb identifies one frame as the "selected" frame.Variable lookups are done with respect to the selected frame.When the program being debugged stops, gdb selects the innermost frame. The commands below can be used to select other frames by number or address. List of commands:backtrace -- Print backtrace of all stack framesbt -- Print backtrace of all stack framesdown -- Select and print stack frame called by this oneframe -- Select and print a stack framereturn -- Make selected stack frame return to its callerselect-frame -- Select a stack frame without printing anythingup -- Select and print stack frame that called this oneType "help" followed by command name for full documentation.Type "apropos word" to search for commands related to "word".Command name abbreviations are allowed if unambiguous.(gdb) help btPrint backtrace of all stack frames, or innermost COUNT frames.With a negative argument, print outermost -COUNT frames.Use of the 'full' qualifier also prints the values of the local variables.(gdb) help frameSelect and print a stack frame.With no argument, print the selected stack frame. (See also "info frame").An argument specifies the frame to select.It can be a stack frame number or the address of the frame.With argument, nothing is printed if input is coming froma command file or a user-defined command.2. 程序堆栈布局frame是函数调⽤时，在堆栈上记录的数据信息，包括寄存器，局部变量，函数参数等，每个函数被调⽤都会在堆栈上记录⾃⼰的信息，于是形成了如图显⽰的frame stack:frame 的组成：在函数的⼊⼝处，⾸先保存那些在本函数⾥被使⽤的寄存器(D)，函数退出时，恢复它们，其中就包含函数调⽤的返回地址，然后给函数内的局部变量分配空间(C)，再然后给alloca 调⽤或者动态数组分配空间(B)，如果有调⽤⼦函数，⽽且⼦函数的参数个数过多，⽆法完全通过寄存器传递，那么就需要借助堆栈传递(A)。
gdb调试命令的使用及总结
gdb调试命令的使用及总结
gdb是一个功能强大的调试器，用于调试C、C++等编程语言的程序。
它提供了许多命令和功能，可以帮助开发人员诊断和修复程序中的错误。
下面我将从使用和总结两个方面来回答你的问题。
首先是gdb的使用。
要使用gdb调试程序，首先需要在编译时包含调试信息。
这意味着在使用gcc或g++编译程序时，需要添加`-g`选项。
例如：
gcc -g -o program program.c.
然后可以使用以下命令启动gdb并加载程序：
gdb program.
一旦进入gdb，可以使用一系列命令来控制程序的执行和检查程序状态。
例如，可以使用`run`命令来运行程序，`break`命令来设置断点，`step`和`next`命令来逐行执行程序等等。
此外，还可以使用`print`命令来打印变量的值，`backtrace`命令来查看函数调用栈等等。
现在来总结一下gdb的使用。
gdb是一个非常强大的调试工具，它可以帮助开发人员快速定位和修复程序中的错误。
通过设置断点、逐行执行程序、查看变量的值等操作，开发人员可以深入了解程序
的执行过程，找出其中的问题。
此外，gdb还提供了丰富的文档和
在线帮助，可以帮助开发人员更好地利用它的功能。
总的来说，gdb是一个非常有用的调试工具，它可以帮助开发
人员提高程序调试的效率和准确性。
通过学习和熟练掌握gdb的使用，开发人员可以更快地修复程序中的错误，提高自己的编程水平。
希望这个回答能够帮助你更好地了解gdb的使用和功能。
gdb调试器命令总结
gdb调试器命令总结Linux中包含有一个很有用的调试工具－－gdb(GNU Debuger)，它可以用来调试C和C++程序，功能不亚于Windows下的许多图形界面的调试工具。
和所有常用的调试工具一样，gdb提供了以下功能：# 监视程序中变量的值# 在程序中设置断点# 程序的单步执行在使用gdb前，必须先载入可执行文件，因为要进行调试，文件中就必须包含调试信息，所以在用gcc或cc编译时就需要用-g参数来打开程序的调试选项。
调试开始时，必须先载入要进行调试的程序，可以用以下两种方式：* 在启动gdb后执行以下命令：file 可执行文件路径* 在gdb启动时就载入程序：gdb可执行文件路径载入程序后，接下来就是要进行断点的设置，要监视的变量的添加等工作，下面对在这个过程中常会用到的命令逐一进行介绍：* list：显示程序中的代码，常用使用格式有：list输出从上次调用list命令开始往后的10行程序代码。
list -输出从上次调用list命令开始往前的10行程序代码。
list n输出第n行附近的10行程序代码。
list function输出函数function前后的10行程序代码。
* forward/search：从当前行向后查找匹配某个字符串的程序行。
使用格式：forward/search 字符串查找到的行号将保存在$_变量中，可以用print $_命令来查看。
* reverse-search：和forward/search相反，向前查找字符串。
使用格式同上。
* break：在程序中设置断点，当程序运行到指定行上时，会暂停执行。
使用格式：break 要设置断点的行号* tbreak：设置临时断点，在设置之后只起作用一次。
使用格式：tbreak 要设置临时断点的行号* clear：和break相反，clear用于清除断点。
使用格式：clear 要清除的断点所在的行号* run：启动程序，在run后面带上参数可以传递给正在调试的程序。
gdb调试命令的使用及总结
gdb调试命令的使用及总结GDB是GNU调试器的简称，是一个非常强大的调试工具，可用于调试C、C++等编程语言的程序。
通过GDB，开发人员可以在程序运行过程中查看变量的值、跟踪函数的执行、定位错误的原因等。
下面将介绍一些常用的GDB调试命令及其使用方法。
1. 启动GDB调试器：在命令行中输入"gdb"命令即可启动GDB调试器。
然后使用"gdb <可执行文件名>"命令加载要调试的可执行文件。
2. 设置断点：使用"break <行号>"命令在指定行号上设置断点。
可以使用"break <函数名>"命令在指定函数的入口处设置断点。
使用"info breakpoints"命令可以查看当前设置的断点。
3. 运行程序：使用"run"命令运行程序。
如果程序需要输入参数，则可以使用"run <参数1> <参数2> ..."的形式运行。
4. 单步执行：在断点处停下来后，可以使用"next"命令执行下一行代码。
使用"step"命令进入函数内部执行。
使用"finish"命令执行完当前函数并返回上一层调用。
5. 查看变量值：使用"print <变量名>"命令可以查看指定变量的值。
使用"display <变量名>"命令可以设置自动显示变量值。
6. 查看堆栈信息：使用"backtrace"命令可以查看函数调用的堆栈信息。
使用"frame <帧号>"命令可以切换到指定的堆栈帧。
7. 修改变量值：使用"set <变量名>=<新值>"命令可以修改指定变量的值。
gdb 汇编常见命令
gdb 汇编常见命令1.引言1.1 概述概述部分的内容可以简要介绍一下gdb和汇编语言的概念。
GDB是GNU Debugger的缩写，是一个功能强大的调试工具，用于帮助开发人员调试程序。
它可以与众多编程语言一起使用，包括汇编语言。
汇编语言是一种低级别的程序设计语言，用于直接操作计算机硬件。
本文将重点介绍gdb在汇编语言中的常见命令。
通过熟悉这些命令，开发人员可以更好地理解和调试汇编程序，提高程序的运行效率和稳定性。
文章后续部分将详细介绍常见的gdb命令和它们在汇编程序中的应用场景。
首先，我们将介绍常见命令1，在此命令中，我们将学习如何设置断点、单步执行程序、查看寄存器的值等。
然后，我们将进一步探讨常见命令2，该命令将介绍如何查看内存中的数据、修改内存值以及使用条件断点等。
通过本文，读者将能够掌握这些常见的gdb命令，并能够熟练运用它们进行汇编程序的调试。
最后，在结论部分，我们将对本文进行总结，并展望未来gdb在汇编语言调试中的应用前景。
接下来，我们将详细介绍2.1 常见命令1部分的内容。
1.2 文章结构文章结构部分的内容可以参考以下内容：文章结构部分介绍了整篇文章的组织结构和内容安排，旨在为读者提供一个清晰的框架和导引，使读者能够更好地理解和掌握文章内容。
在本文中，结构主要分为三个部分：引言、正文和结论。
引言部分首先对文章的主题进行了概述，简要介绍了gdb汇编调试工具的基本概念和作用。
接着，介绍了本文的结构，包括引言、正文和结论三个部分以及各个部分的内容安排。
最后，明确了本文的目的，旨在帮助读者掌握gdb汇编调试工具的常见命令。
正文部分是本文的核心内容，主要介绍了gdb汇编调试工具的常见命令。
这些命令包括但不限于断点设置、步进执行、变量查看、寄存器查看等。
每个命令都会详细解释其作用和用法，并通过实例进行演示，以便读者能够更好地理解和掌握。
结论部分对整篇文章进行总结，并展望了未来可能的研究方向和进一步探索的问题。
比较全面的gdb调试命令
比较全面的gdb调试命令用GDB调试程序GDB是一个强大的命令行调试工具。
大家知道命令行的强大就是在于，其可以形成执行序列，形成脚本。
UNIX下的软件全是命令行的，这给程序开发提代供了极大的便利，命令行软件的优势在于，它们可以非常容易的集成在一起，使用几个简单的已有工具的命令，就可以做出一个非常强大的功能。
于是UNIX下的软件比Windows下的软件更能有机地结合，各自发挥各自的长处，组合成更为强劲的功能。
而Windows下的图形软件基本上是各自为营，互相不能调用，很不利于各种软件的相互集成。
在这里并不是要和Windows做个什么比较，所谓“寸有所长，尺有所短”，图形化工具还是有不如命令行的地方。
用GDB调试程序GDB概述————GDB是GNU开源组织发布的一个强大的UNIX下的程序调试工具。
或许，各位比较喜欢那种图形界面方式的，像VC、BCB等IDE的调试，但如果你是在UNIX平台下做软件，你会发现GDB这个调试工具有比VC、BCB的图形化调试器更强大的功能。
所谓“寸有所长，尺有所短”就是这个道理。
一般来说，GDB主要帮忙你完成下面四个方面的功能：1、启动你的程序，可以按照你的自定义的要求随心所欲的运行程序。
2、可让被调试的程序在你所指定的调置的断点处停住。
（断点可以是条件表达式）3、当程序被停住时，可以检查此时你的程序中所发生的事。
4、动态的改变你程序的执行环境。
从上面看来，GDB和一般的调试工具没有什么两样，基本上也是完成这些功能，不过在细节上，你会发现GDB这个调试工具的强大，大家可能比较习惯了图形化的调试工具，但有时候，命令行的调试工具却有着图形化工具所不能完成的功能。
让我们一一看来。
一个调试示例——————源程序：tst.c1 #include23 int func(int n)4 {5 int sum=0,i;6 for(i=0; i<7; i++) {8 sum+=i;9 }10 return sum;11 }121314 main()15 {16 int i;17 long result = 0;18 for(i=1; i<=100; i++)19 {20 result += i;21 }2223 printf("result[1-100] = %d \n", result );24 printf("result[1-250] = %d \n", func(250) );25 }编译生成执行文件：（Linux下）hchen/test> cc -g tst.c -o tst使用GDB调试：hchen/test> gdb tst <---------- 启动GDBGNU gdb 5.1.1Copyright 2002 Free Software Foundation, Inc.GDB is free software, covered by the GNU General Public License, and you arewelcome to change it and/or distribute copies of it under certain conditions.Type "show copying" to see the conditions.There is absolutely no warranty for GDB. Type "show warranty" for details.This GDB was configured as "i386-suse-linux"...(gdb) l <-------------------- l命令相当于list，从第一行开始例出原码。
GDB调试技巧与实战
GDB调试技巧与实战GDB（GNU调试器）是一种强大的调试工具，广泛用于C/C++程序的调试。
它具有许多有用的功能和命令，可以帮助我们快速定位和解决程序中的bug。
在本文中，我将介绍一些GDB调试技巧和实例，帮助您更好地使用GDB进行调试工作。
1. 启动程序：要使用GDB调试程序，我们需要在启动GDB时将程序作为参数传递给它。
例如，要调试名为myprogram的可执行文件，可以使用以下命令启动GDB：```gdb myprogram```2. 设置断点：当我们想要在特定位置暂停程序执行时，可以在该位置设置断点。
使用GDB的"break"命令可以实现。
例如，要在程序的main 函数处设置断点，可以使用以下命令：```break main```我们还可以使用行号来设置断点，例如：```break file.c:10```3. 运行程序：设置了断点后，我们可以使用GDB的"run"命令来运行程序。
程序会在达到断点时暂停执行。
例如：```run```如果程序需要命令行参数，我们可以在run命令后面添加参数。
例如：```run arg1 arg2```4. 单步调试：一旦程序暂停在断点处，可以使用GDB的"step"命令逐行执行程序。
这对于理解程序的执行流程非常有用。
例如：```step```如果希望在函数内部逐行执行，可以使用"next"命令。
它会跳过函数内部的细节，直接进入下一行。
例如：```next```5. 打印变量：在调试程序时，我们经常需要查看变量的值。
GDB的"print"命令可以用于打印变量的值。
例如，要打印整型变量x的值，可以使用以下命令：```print x```我们还可以使用GDB的表达式语言来计算表达式的值。
例如，要打印变量x和y的和，可以使用以下命令：```print x + y```6. 查看堆栈：GDB可以帮助我们查看程序的堆栈跟踪信息。
gdb调试案例
gdb调试案例以gdb调试案例为题，列举以下10个案例，每个案例字数不少于80字。
1. 案例一：段错误（Segmentation fault）当程序访问了未分配给它的内存区域时，会引发段错误。
使用gdb 可以定位到导致段错误的具体代码行，帮助我们找到错误的原因。
2. 案例二：死循环（Infinite loop）当程序陷入死循环，无法正常终止时，可以使用gdb来观察程序的执行过程，找到造成死循环的原因，如循环条件错误或循环变量未正确更新等。
3. 案例三：变量值异常（Variable value abnormal）当程序输出的结果与预期不符时，可以通过gdb查看程序中关键变量的值，以确定是否存在变量赋值错误、计算错误或逻辑错误等问题。
4. 案例四：函数调用错误（Function call error）当程序出现函数调用错误，如参数传递错误、函数返回值错误或函数嵌套调用错误时，可以使用gdb跟踪函数调用栈，找到错误发生的位置。
5. 案例五：数组越界（Array out of bounds）当程序访问数组时超出了数组的有效索引范围，会导致数组越界错误。
使用gdb可以定位到越界访问的具体位置，帮助我们修复错误。
6. 案例六：内存泄漏（Memory leak）当程序中存在内存泄漏时，使用gdb可以观察程序的内存使用情况，找到未释放的内存块，并定位到引发内存泄漏的代码。
7. 案例七：多线程问题（Multithreading issues）当程序中存在多线程问题，如线程死锁、竞争条件或线程同步错误等，可以使用gdb跟踪各个线程的执行过程，帮助我们分析和解决问题。
8. 案例八：文件操作错误（File operation error）当程序对文件的读写操作出现错误时，可以使用gdb定位到文件操作的代码行，查看文件句柄、文件路径等相关信息，帮助我们修复错误。
9. 案例九：崩溃（Crash）当程序崩溃时，gdb可以生成崩溃转储文件（core dump file），通过分析转储文件，可以了解崩溃时程序的内存状态，帮助我们找到崩溃的原因。
gdb 调试函数
gdb 调试函数【实用版】目录1.GDB 简介2.GDB 调试函数的方法3.GDB 调试函数的实例4.总结正文一、GDB 简介GDB（GNU Debugger）是一个用于调试程序的强大工具，它支持 C、C++等语言。
GDB 可以帮助程序员查找代码中的错误，理解程序运行过程以及优化程序性能。
通过 GDB，程序员可以设置断点、查看变量值、单步执行代码等，从而定位问题并修复。
二、GDB 调试函数的方法在使用 GDB 调试函数时，主要可以采用以下几种方法：1.在函数入口设置断点：使用`break`命令可以在函数入口处设置断点，当程序运行到该位置时，GDB 会暂停执行并返回控制权给程序员。
2.在函数内部设置断点：使用`break`命令可以在函数内部设置断点，当程序运行到该位置时，GDB 会暂停执行并返回控制权给程序员。
3.查看函数调用关系：使用`backtrace`和`bt`命令可以查看当前函数调用关系，从而了解函数调用过程。
4.查看函数参数和局部变量：使用`print`命令可以查看函数的参数和局部变量值，便于程序员分析问题。
5.单步执行函数：使用`step`和`next`命令可以实现在函数内部单步执行，从而观察程序运行过程。
三、GDB 调试函数的实例假设有一个名为`add`的函数，其功能是计算两个整数的和，代码如下：```cint add(int a, int b) {return a + b;}```我们可以通过以下步骤使用 GDB 调试这个函数：1.编译程序：首先使用编译器编译程序，例如`gcc -g main.c -o main`，其中`-g`选项表示生成调试信息。
2.运行程序：在 GDB 中使用`run`命令运行程序，如`gdb main`。
3.设置断点：使用`break`命令在`add`函数入口处设置断点，如`break add`。
4.查看函数调用关系：使用`backtrace`和`bt`命令查看当前函数调用关系。
常用GDB调试方法
常用GDB调试方法GDB（GNU调试器）是一种常用的开源调试工具，用于在开发过程中检测和修复程序错误。
它支持多种编程语言，并且提供了许多功能强大的调试功能。
以下是常用的GDB调试方法：1.启动程序：使用GDB调试程序的第一步是启动程序。
在命令行中键入“gdb”命令，后跟要调试的程序的名称。
例如，要调试名为“my_program”的程序，可以输入“gdb my_program”。
2.设置断点：在程序中设置断点是调试过程中的重要步骤。
在GDB中，断点可以是程序的特定行、函数或地址。
使用“break”命令设置断点，可以指定行数、函数名或地址。
例如，“break fun_name”将在名为“fun_name”的函数上设置断点，“break file_name:line_number”将在指定文件的特定行上设置断点。
3.运行程序：一旦设置了断点，就可以运行程序。
在GDB中，输入“run”命令运行程序。
程序将在达到第一个断点时停止。
4.单步执行：在程序停止时，可以使用“next”命令逐行执行程序。
使用“step”命令逐步进入函数调用。
这两个命令都允许开发人员在程序执行的每一步上检查变量和执行情况。
5.检查变量：GDB允许开发人员在程序执行期间检查变量的值。
使用“print”命令可以输出变量的当前值。
例如，“print var_name”将打印名为“var_name”的变量的值。
6.显示堆栈：使用“backtrace”命令可以查看程序的函数调用堆栈。
这对于定位程序崩溃或错误的根本原因非常有用。
7.查看内存：GDB允许开发人员查看程序中的内存。
使用“x”命令可以查看指定地址的内存内容。
例如，“x/10x address”将显示从指定地址开始的10个字节的十六进制值。
8.修改变量：GDB还可以在程序运行时修改变量的值，以便进行测试和调试。
使用“set”命令可以更改变量的值。
例如，“set var_name = new_value”将将“var_name”的值设置为“new_value”。
gdb调试器的详细使用说明
GDB程序调试
实验目的:
学会GDB调试器的调试
实验要求:
编写一个应用程序, 使用gdb调试
实验器材:
RedHat虚拟机
实验步骤:
1.先用vi编辑器编写一个名为test.c的文件
2.将test.c文件编译为带有调试信息的文件test
Gcc –g test.c –o test
编译完成,出现带有调试信息的可执行文件test.
3.开始调试test文件
命令 : gdb test
4. l (list)命令
用于查看文件
5. 这里给出所有break的功能
6. 我们在17行设置断点
7. info break 可以查看所有断点
8. r (run)运行命令.
r命令默认是从首行开始的, 一般到断点处停止的
9. n (next)单步运行程序, 不进入到子函数
可以看的出,打印出了一条语句,
10. p(print) 变量名: 查看指定的变量名
当我们运行c = a这句语句后, c 的值就变成了3 11. s(step) 单步执行, 但是可以进入到子函数中去
可以看的出,当按下s后,进入到swap函数中去了12 .finish 用于运行程序, 知道当前函数解释
当finish输入时, 会到swap函数结束的.
13 .q(quit) 退出gdb
看见退出了gdb调试工具。
GDB调试技巧与实战
GDB调试技巧与实战GDB（GNU调试器）是一个功能强大的调试工具，可以帮助我们在程序执行期间发现和修复错误。
以下是一些GDB调试技巧和实战经验，帮助您更有效地使用GDB来调试您的程序。
1. 启动程序：使用GDB调试程序之前，需要首先编译并运行您的程序。
在命令行中输入`gdb <程序路径>`来启动GDB，并加载您的程序。
2. 设置断点：断点是GDB调试的关键。
您可以使用`break`命令在代码中设置断点。
例如，输入`break main`可以在程序的`main`函数处设置一个断点。
3. 运行程序：在GDB中，使用`run`命令来运行您的程序。
程序将在断点处停止。
4. 单步执行：一旦程序停止在一个断点上，您可以使用`next`命令单步执行代码。
这将逐行执行代码，让您可以逐步跟踪代码的执行。
5. 变量查看：使用`print`命令来查看变量的值。
例如，输入`print x`可以查看变量`x`的值。
6. 条件断点：您可以使用`break`命令来设置条件断点。
例如，输入`break <行号> if <条件>`可以在满足条件时设置一个断点。
7. 回溯调用栈：使用`backtrace`命令来查看当前的函数调用栈。
这将显示从程序开始到当前断点的所有函数调用。
8. 跳过代码：有时候您可能希望跳过一些代码，直接执行到下一个断点。
您可以使用`continue`命令来继续执行程序，直到下一个断点。
9. 修改变量：在GDB中，可以使用`set`命令来修改变量的值。
例如，输入`set x = 10`可以将变量`x`的值设置为10。
10. 调试多线程程序：如果您的程序是多线程的，可以使用`thread`命令在不同的线程之间切换调试。
11.调试崩溃：如果您的程序崩溃了，您可以使用GDB来查找问题所在。
当程序崩溃时，GDB会在命令行中提供一些帮助信息，例如异常原因和崩溃位置。
12. 分析内存：GDB还可以帮助您分析内存问题。
使用GDB调试器
使用GDB调试器GNU的调试器GDB提供了许多有用的特性，支持机器级程序的运行时评估和分析。
可以通过阅读GDB反汇编过来的代码，来推断出程序的行为。
有了GDB可以观察正在运行的程序，同时GDB有对程序的执行有相当的控制能力，这使得研究程序的行为变成可能。
下表中列出来GDB常用的命令：在用gdb分析程序时，通常的方法是在程序中感兴趣的地方附近设置断点，断点可以设置在函数入口后面，或者一个程序的地址处。
程序在执行过程中遇到一个断点时，程序会停下来，并将控制返回给用户。
在断点处我们能够以各种方法查看各个寄存器和内存位置。
也可以单步跟踪程序，一次只执行几条指令，或者是前进到下一个断点。
再做程序分析时除了要掌握GDB这个工具之外，还有对C语言函数调用，以及参数传递的一些约定有所了解，下面简单介绍参数传递的一些约定俗成的规则。
参数传递，当被调用函数的参数小于或者等于6个时，参数传递只使用寄存器，不使用栈来传递参数，当被调用函数参数大于6个时，多于6个的参数将使用栈来传递。
其中第一至第六个参数对应的寄存器是%rdi，%rsi，%rdx，%rcx，%r8，%r9。
另外这6个寄存器的宽度会根据参数类型来改变，例如如果参数1是64 bits，就对应%rdi，如果是32 bits就对应%edi，16 bits 对应%di，8 bits 对应%dil。
此外%r8和%r9，是x64 CPU所特有的，以%r8为例，32bits 对应%r8d，16bits 对应%r8w，8bits 对应%r8b。
函数过程中寄存器修改规则，寄存器%rbx、%rbp、%r12、%r13、%r14、和%r15是被调用者保存寄存器，当过程P调用过程Q时，Q必须保持这些寄存器的值，也就是在Q开始运行到Q返回这个，过程中，这些值保持不变，换句话说，就是P调用完Q后，这些寄存器的值就是P 放在里面的值，在Q运行的过程中，如果要使用这些寄存器，就必须要先保存这些寄存器的原值，在Q返回之前，要将原值返回到寄存器中。
gdb 多线程调试案例
gdb 多线程调试案例主题：gdb 多线程调试案例要求：介绍一个使用 gdb 进行多线程调试的案例，包括问题描述、调试过程和解决方案。
案例：问题描述：在一个多线程程序中，某个线程出现了段错误，但是无法确定是哪个线程导致的，需要使用 gdb 进行多线程调试。
调试过程：1. 编译程序时需要加上 -g 选项，以便在调试时能够获取到符号表信息。
2. 运行程序，使用 ps 命令查看程序的进程 ID。
3. 使用 gdb attach 命令附加到程序进程中，例如：gdb attach 1234。
4. 使用 info threads 命令查看程序中的所有线程，找到出现问题的线程 ID。
5. 使用 thread 命令切换到出现问题的线程上。
6. 使用 backtrace 命令查看线程的调用栈，找到导致段错误的函数。
7. 使用 break 命令在出现问题的函数上设置断点。
8. 继续运行程序，直到程序停在断点处。
9. 使用 info locals 命令查看当前函数的局部变量信息，找到导致段错误的变量。
10. 修改代码，修复问题。
解决方案：在调试过程中，需要注意以下几点：1. 确保程序编译时加上了 -g 选项，以便在调试时能够获取到符号表信息。
2. 使用 gdb attach 命令附加到程序进程中，而不是直接运行程序。
3. 使用 info threads 命令查看程序中的所有线程，找到出现问题的线程 ID。
4. 使用 thread 命令切换到出现问题的线程上，以便查看该线程的调用栈和局部变量信息。
5. 在出现问题的函数上设置断点，以便在程序运行到该函数时停下来进行调试。
6. 使用 info locals 命令查看当前函数的局部变量信息，找到导致问题的变量。
7. 修改代码，修复问题。
总结：使用 gdb 进行多线程调试需要掌握一定的技巧和经验，但是通过合理的调试方法和工具，可以快速定位和解决问题。
在实际开发中，需要注意编译选项、调试命令和调试过程中的注意事项，以提高调试效率和准确性。
gdb命令总结
今天学习使用gdb，现总结如下：关于断点的命令：awatch:awatch用来为一个表达式设置观察点，在表达式的值发生改变时，或者当表达式的值被读取的时候，程序停止执行。
awatch+表达式break:用于在程序中设置断点 break + 要设置断点的行号clear:用于清除断点 clear + 要清除断点的行号commands:用于为遇到断点之后执行特定的指令而设置的 command + 断点号如果commands 之后没有断点号，gdb会将最后一个设置的断点编号作为默认值。
condition:在满足一定的条件时才在指定的行上设置断点 condition 断点编号条件表达式delete:用于清除断点和自动显示的表达式的命令。
与clear的不同之处：clear要给出断点的行号，delete要给出断点的编号。
用clear命令清除断点时gdb会给出提示，而用delete清除断点时gdb不会给出任何提示disable:让所设断点暂时失效。
如果要让多个编号处的断点失效可将编号之间用空格隔开enable:与disable 相对ignore:这条命令在一定范围内忽略用户设定的断点 ignore N CONTtbreak:用于设置临时断点，所谓临时断点就是断点只在设置之后起作用一次。
watch:与awatch类似关于数据的命令：display:该命令用于显示表达式的值，使用了该命令后，每当程序运行到断点处都会显示表达式的值。
display 表达式如:display 5*jinfo display:用于显示当前所有要显示值的表达式的有关情况delete display:用于删除一个要显示值的表达式，调用这个命令删除一个表达式后，被删除的表达式将不被显示。
delete display 1disable display:使一个要显示的表达式暂时无效。
可有enable重新使之有效enable display:反操作disable diplayundisplay:用于结束某个表达式值的显示。
gdb调试方法说明（GDBdebugmethodinstructions）
gdb调试方法说明（GDB debug method instructions）GDB debugging essence and examplesList of column files1.List(GDB) list, Line1, line2Two: executive procedureTo run the program for debugging, you can use the run command, behind it can follow to any of the parameters of the program, including the standard input and output descriptor (< and >) and shell wildcards (* and? [[]]).If you use the run command without arguments, it is useful for GDB to use the parameters you gave to the previous run command again.Using the set args command, you can modify the parameters that are sent to the program, and you can use the show args command to see a list of its default parameters.(GDB) set args - B - x(GDB) show argsThe backtrace command provides a backward tracking function for the stack.The Backtrace command generates a list that contains the parameters that start with the recent process, so the effective procedure and the parameters that call them.Three: display dataUsing the print command, you can check the values of each variable.(GDB) print p (P is a variable name)The whatis command displays the type of a variable(GDB) whatis pType = int *Print is a powerful command of GDB that uses it to display any valid expressions in the language being debugged. In addition to containing variables in your program, expressions can include the following:L calls to functions in a program(GDB) print find_entry (1,0)L data structures and other complex objects(GDB) print *table_start$8={e=reference= '\000', location=0x0, next=0x0}Historical components of L values(GDB) print $1 ($1 is a history variable, which can be referenced directly later on $1)L artificial arrayA human array provides a way to display the contents of a memory block (array, section, or dynamically allocated storage). The early debugger didn't have a good way of changing any pointer to an array. Just as with arguments, let's look at the 10 integers in memory after the variable H, and the syntax of a dynamic array, as shown below:Base@lengthTherefore, you can use h@10 to display the 10 elements behind h:(GDB) print h@10$13= (-1345,23, -234,0,0,0,98345,10)Four: breakpoint (breakpoint)The break command, which can be abbreviated as B, can be used to set breakpoints in the debugger, which has the following four forms:L break line-number stops the program just before executing agiven row.The L break function-name stops the program just before entering the specified function.L break line-or-function if condition, if condition (condition) is true, the program stops when it arrives at the specified row or function.L break routine-name sets the breakpoint at the entrance of the specified routineIf the program is made up of many original files, you can set breakpoints in each of the original files instead of setting breakpoints in the current original file:(GDB) break filename:line-number(GDB) break filename:function-nameTo set a conditional breakpoint, you can use the break if command as follows:(GDB) break, line-or-function, if, exprCases:(GDB) break 46, if, testsize==100Continue running from breakpoint: countinue commandFive. Breakpoint management1. displays the breakpoint information for the current gdb:(GDB) info breakHe displays all breakpoint information in the form as follows:Num, Type, Disp, Enb, Address, What"Breakpoint keep y 0x000028bc in init_random at qsort2.c:155""Breakpoint keep y 0x0000291c in init_organ at qsort2.c:168"(GDB)2. deletes a specified breakpoint:(GDB) delete breakpoint 1该命令将会删除编号为1的断点, 如果不带编号参数, 将删除所有的断点Delete breakpoint (GDB)3.禁止使用某个断点(GDB) disable breakpoint 1该命令将禁止断点 1, 同时断点信息的 (ENB) 域将变为 n4.允许使用某个断点(GDB) enable breakpoint 1该命令将允许断点 1, 同时断点信息的 (ENB) 域将变为 y 5.清除原文件中某一代码行上的所有断点The clean number (GDB)注: number 为原文件的某个代码行的行号六.变量的检查和赋值L: 识别数组或变量的类型 WhatisL ptype: 比whatis的功能更强, 他可以提供一个结构的定义L set variable: 将值赋予变量L print 除了显示一个变量的值外, 还可以用来赋值七.单步执行L next不进入的单步执行L step进入的单步执行如果已经进入了某函数, 而想退出该函数返回到它的调用函数中, 可使用命令finish八.函数的调用L call name 调用和执行一个函数(GDB) call Gen _ and _ sork (1234,1,0)(GDB) call printf ("ABCD")$1 = 4L finish 结束执行当前函数, 显示其返回值 (如果有的话)九.机器语言工具有一组专用的gdb变量可以用来检查和修改计算机的通用寄存器, gdb提供了目前每一台计算机中实际使用的4个寄存器的标准名字:L $PC: 程序计数器L $FP: 帧指针 (当前堆栈帧)L $SP: 栈指针L $PS: 处理器状态十.信号Gdb通常可以捕捉到发送给它的大多数信号, 通过捕捉信号, 它就可决定对于正在运行的进程要做些什么工作.例如, 按ctrl - c将中断信号发送给gdb, 通常就会终止gdb.但是你或许不想中断gdb, 真正的目的是要中断gdb正在运行的程序, 因此, gdb要抓住该信号并停止它正在运行的程序, 这样就可以执行某些调试操作.Handle命令可控制信号的处理, 他有两个参数, 一个是信号名, 另一个是接受到信号时该作什么.几种可能的参数是:L Nostop 接收到信号时, 不要将它发送给程序, 也不要停止程序.L stop 接受到信号时停止程序的执行, 从而允许程序调试; 显示一条表示已接受到信号的消息 (禁止使用消息除外)L print 接受到信号时显示一条消息L noprint 接受到信号时不要显示消息 (而且隐含着不停止程序运行)L pass 将信号发送给程序, 从而允许你的程序去处理它、停止运行或采取别的动作.L nopass 停止程序运行, 但不要将信号发送给程序.例如, 假定你截获sigpipe信号, 以防止正在调试的程序接受到该信号, 而且只要该信号一到达, 就要求该程序停止, 并通知你.要完成这一任务, 可利用如下命令:(GDB) handle SIGPIPE stop print请注意, 你可以用信号编号替代信号名 unix的信号名总是采用大写字母!如果你的程序要执行任何信号处理操作, 就需要能够测试其信号处理程序, 为此, 就需要一种能将信号发送给程序的简便方法, 这就是signal命令的任务.该命令的参数是一个数字或者一个名字, 如sigint.假定你的程序已将一个专用的sigint (键盘输入, 或ctrl - C;Signal 2) the signal handler is programmed to take a cleanup action. If you want to test the signal handler, you can set a breakpoint and use the following command:(GDB) signal 2Continuing, with, signal, SIGINT (2)The program continues, but immediately transmits the signal, and the handler starts runningEleven. Search for original filesSearch text:, this command can be displayed in the current file, including the next line of the text string.Reverse-search text:, this command displays the previous line containing text.Twelve.UNIX interfaceThe shell command starts the UNIX shell, and the CTRL-D exits the shell and returns to gdb.Thirteen. The history of commandTo allow the use of historical commands, use the set history expansion on command(GDB) set, history, expansion, onSummary: common GDB commandsThe backtrace displays the current location in the program and the stack trace indicating how to reach the current location (synonyms: where)Breakpoint sets a breakpoint in the programCD changes the current working directoryClear deletes the breakpoint at the stop just nowWhen the commands hits the breakpoint, list the commands that will be executedContinue starts from breakpoint and continues executionDelete deletes a breakpoint or monitoring point; it can also be used with other commandsWhen the display program stops, variables and expressions are displayedDown moves down the stack frame so that another function becomes the current functionFrame selects the frame for the next continue commandInfo displays various information related to the programJump starts running at another point in the source programKill abort the program running under GDB controlList lists the contents of the original file corresponding to the program being executedNext executes the next source line, thus executing a function in its entiretyPrint displays the value of a variable or expressionPWD displays the current working directoryPype displays the content of a data structure, such as a structure or C++ classQuit quit GDBReverse-search searches the source file in reverse for regular expressionsRun executes the programSearch searches for regular expressions in source filesSet variable assign values to variablesSignal sends a signal to a running processStep executes the next source line and, if necessary, goes to the next functionUndisplay display command counter command, do not display the expressionUntil ends the current loopUp moves up the stack frame so that another function becomes the current functionWatch sets up a monitoring point (i.e., data breakpoint) in the programWhatis displays variables or function types****************************************************The debugger for GNU, called GDB, is an interactive tool that works in character mode. In the X Window system, there is a GDB front end graphical tool called xxgdb. GDB is a powerful debugger that performs the following debugging tasks:* setting breakpoints;* monitoring the value of program variables;* a single step of the program;* modify the value of a variable.Before you can use the GDB debugger, you must compile the source file using the -g option. You can define the CFLAGS variable in makefile as follows:CFLAGS = -gWhen running the GDB debugger, you use the following command:GDB prognameTyping help at the GDB prompt lists the categories of commands, and the main categories are:* aliases: Command alias* breakpoints: breakpoint definition;* data: data view;* files: specify and view files;* internals: maintenance command;* running: program execution;* stack: call stack view;* statu: status view;* tracepoints: trace program execution.Type the category name of the help followed by the command to obtain a detailed list of the class commands.Common commands for GDBCommand explanationBreak NUM sets breakpoints on the specified row.BT shows all the call stack frames. This command can be used to display the order in which the function is called.Clear deletes a breakpoint set on a particular source file or a particular line. Its usage is clear FILENAME:NUMContinue continues executing the program being debugged. This command is used when the program stops operating because of processing signals or breakpoints.Display EXPR displays the value of the expression every time the program stops. Expressions are made up of variables that are defined by the program.File FILE loads the specified executable file for debugging.Help NAME displays help information for the specified command.Info break displays the current breakpoint list, including the number of times the breakpoint is reached.Info files displays detailed information about the debugged files.Info func displays all the function names.Info local displays local variable information when functions are used.Info prog displays the execution state of the debugger.Info var displays all global and static variable names.Kill terminates the program being debugged.List displays the source code segment.Make runs the make tool without exiting the gdb.Next performs a single line of source code without stepping into other functions.Print EXPR displays the value of the expression EXPR.The example uses ******gdb ************************Round and roundListing 1 a C source with error bugging.cCode:Round and round1, I, ncludeTwo3, static, char, buff, [256];4 static char* string;5 int main (){67 printf ("Please input a string:");8 gets (string);9 printf (\nYour, string,%s\n, is:, string);10}Round and roundThe program above is very simple, the purpose is to accept user input, and then print out the user's input. The program usesan uninitialized string address string, so after compiling and running, there will be a Segment Fault error:$GCC, -o, bugging, -g, bugging.c$./buggingPlease, input, a, string:, ASFDSegmentation fault (core dumped)To find the problems in the program, we use GDB and follow these steps:1. run the GDB bugging command and load the bugging executable file;2. execute the loaded bugging command run;3. use the where command to see where the program went wrong;4. use the list command to view the code that calls the gets function;5. the only factor that can cause errors in the gets function is the variable string. View the value of string with the print command;6. in GDB, we can directly modify the value of a variable, as long as you take a valid pointer value from string, and for this reason, we set breakpoint break 8 at the eighth line;7., the program rerun to stop at the eighth line, then we can use the set variable command to modify the value of string;8., and then continue to run, will see the correct program operation results.。
gdb调试命令的使用及总结
gdb调试命令的使⽤及总结1）进⼊GDB #gdb test test是要调试的程序，由gcc test.c -g -o test⽣成。
进⼊后提⽰符变为(gdb) 。
2）查看源码 (gdb) l 源码会进⾏⾏号提⽰。
如果需要查看在其他⽂件中定义的函数，在l后加上函数名即可定位到这个函数的定义及查看附近的其他源码。
或者：使⽤断点或单步运⾏，到某个函数处使⽤s进⼊这个函数。
3）设置断点 (gdb) b 6 这样会在运⾏到源码第6⾏时停⽌，可以查看变量的值、堆栈情况等；这个⾏号是gdb的⾏号。
4）查看断点处情况 (gdb) info b 可以键⼊"info b"来查看断点处情况，可以设置多个断点；5）运⾏代码 (gdb) r6）显⽰变量值 (gdb) p n 在程序暂停时，键⼊"p 变量名"(print)即可； GDB在显⽰变量值时都会在对应值之前加上"$N"标记，它是当前变量值的引⽤标记，以后若想再次引⽤此变量，就可以直接写作"$N"，⽽⽆需写冗长的变量名；7）观察变量 (gdb) watch n在某⼀循环处，往往希望能够观察⼀个变量的变化情况，这时就可以键⼊命令"watch"来观察变量的变化情况，GDB在"n"设置了观察点；8）单步运⾏ (gdb) n9）程序继续运⾏ (gdb) c 使程序继续往下运⾏，直到再次遇到断点或程序结束；10）退出GDB (gdb) q命令格式 例⼦ 作⽤break + 设置断点的⾏号 break n 在n⾏处设置断点tbreak + ⾏号或函数名 tbreak n/func 设置临时断点，到达后被⾃动删除break + filename + ⾏号 break main.c:10 ⽤于在指定⽂件对应⾏设置断点break + <0x...> break 0x3400a ⽤于在内存某⼀位置处暂停break + ⾏号 + if + 条件 break 10 if i==3 ⽤于设置条件断点，在循环中使⽤⾮常⽅便info breakpoints/watchpoints [n] info break n表⽰断点号，查看断点/观察点的情况clear + 要清除的断点⾏号 clear 10 ⽤于清除对应⾏的断点，要给出断点的⾏号，清除时GDB会给出提⽰delete + 要清除的断点编号 delete 3 ⽤于清除断点和⾃动显⽰的表达式的命令，要给出断点的编号，清除时GDB 不会给出任何提⽰disable/enable + 断点编号 disable 3 让所设断点暂时失效/使能，如果要让多个编号处的断点失效/使能，可将编号之间⽤空格隔开awatch/watch + 变量 awatch/watch i 设置⼀个观察点，当变量被读出或写⼊时程序被暂停rwatch + 变量 rwatch i 设置⼀个观察点，当变量被读出时，程序被暂停catch 设置捕捉点来补捉程序运⾏时的⼀些事件。
GDB调试从基础到精通实例
GDB调试从基础到精通实例⽤GDB调试程序GDB概述————GDB是GNU开源组织发布的⼀个强⼤的UNIX下的程序调试⼯具。
或许，各位⽐较喜欢那种图形界⾯⽅式的，像VC、BCB等IDE的调试，但如果你是在UNIX平台下做软件，你会发现GDB这个调试⼯具有⼀般来说，GDB主要帮忙你完成下⾯四个⽅⾯的功能：1、启动你的程序，可以按照你的⾃定义的要求随⼼所欲的运⾏程序。
2、可让被调试的程序在你所指定的调置的断点处停住。
（断点可以是条件表达式）3、当程序被停住时，可以检查此时你的程序中所发⽣的事。
4、动态的改变你程序的执⾏环境。
从上⾯看来，GDB和⼀般的调试⼯具没有什么两样，基本上也是完成这些功能，不过在细节上，你会发现GDB这个调试⼯具的强⼤，⼤家可能⽐较习惯了图形化的调试⼯具，但有时候，命令⾏的调试⼯使⽤GDB————⼀般来说GDB主要调试的是C/C++的程序。
要调试C/C++的程序，⾸先在编译时，我们必须要把调试信息加到可执⾏⽂件中。
使⽤编译器（cc/gcc/g++）的 -g 参数可以做到这⼀点。
如：> cc -g hello.c -o hello> g++ -g hello.cpp -o hello如果没有-g，你将看不见程序的函数名、变量名，所代替的全是运⾏时的内存地址。
当你⽤-g把调试信息加⼊之后，并成功编译⽬标代码以后，让我们来看看如何⽤gdb来调试他。
启动GDB的⽅法有以下⼏种：1、gdb <program>program也就是你的执⾏⽂件，⼀般在当然⽬录下。
2、gdb <program> core⽤gdb同时调试⼀个运⾏程序和core⽂件，core是程序⾮法执⾏后core dump后产⽣的⽂件。
3、gdb <program> <PID>如果你的程序是⼀个服务程序，那么你可以指定这个服务程序运⾏时的进程ID。
gdb会⾃动attach上去，并调试他。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
GDB调试命令精粹及应用实例一：列文件清单List(gdb) list line1,line2二：执行程序要想运行准备调试的程序，可使用run命令，在它后面可以跟随发给该程序的任何参数，包括标准输入和标准输出说明符(<和>)和外壳通配符（*、？、[、]）在内。
如果你使用不带参数的run命令，gdb就再次使用你给予前一条run命令的参数，这是很有用的。
利用set args 命令就可以修改发送给程序的参数，而使用show args 命令就可以查看其缺省参数的列表。
（gdb）set args b x (gdb) show argsbacktrace命令为堆栈提供向后跟踪功能。
Backtrace 命令产生一张列表，包含着从最近的过程开始的所以有效过程和调用这些过程的参数。
三：显示数据利用print 命令可以检查各个变量的值。
(gdb) print p (p为变量名)whatis 命令可以显示某个变量的类型(gdb) whatis ptype = int *print 是gdb的一个功能很强的命令，利用它可以显示被调试的语言中任何有效的表达式。
表达式除了包含你程序中的变量外，还可以包含以下内容：l 对程序中函数的调用(gdb) print find_entry(1,0)l 数据结构和其他复杂对象(gdb) print *table_start$8={e=reference=’\000’,location=0x0,next=0x0}l 值的历史成分(gdb)print $1 ($1为历史记录变量,在以后可以直接引用$1 的值)l 人为数组人为数组提供了一种去显示存储器块（数组节或动态分配的存储区）内容的方法。
早期的调试程序没有很好的方法将任意的指针换成一个数组。
就像对待参数一样，让我们查看内存中在变量h后面的10个整数，一个动态数组的语法如下所示：base@length因此，要想显示在h后面的10个元素，可以使用h@10：(gdb)print h@10$13=(-1,345,23,-234,0,0,0,98,345,10)四：断点(breakpoint)break命令（可以简写为b）可以用来在调试的程序中设置断点，该命令有如下四种形式：l break line-number 使程序恰好在执行给定行之前停止。
l break function-name 使程序恰好在进入指定的函数之前停止。
l break line-or-function if condition 如果condition（条件）是真，程序到达指定行或函数时停止。
l break routine-name 在指定例程的入口处设置断点如果该程序是由很多原文件构成的，你可以在各个原文件中设置断点，而不是在当前的原文件中设置断点，其方法如下：(gdb) break filename:line-number(gdb) break filename:function-name要想设置一个条件断点，可以利用break if命令，如下所示：(gdb) break line-or-function if expr例：(gdb) break 46 if testsize==100从断点继续运行：countinue 命令五．断点的管理1．显示当前gdb的断点信息：(gdb) info break他会以如下的形式显示所有的断点信息：Num Type Disp Enb Address What1 breakpoint keep y 0x000028bc in init_random at qsort2.c:1552 breakpoint keep y 0x0000291c in init_organ at qsort2.c:168(gdb)2.删除指定的某个断点：(gdb) delete breakpoint 1该命令将会删除编号为1的断点，如果不带编号参数，将删除所有的断点(gdb) delete breakpoint3.禁止使用某个断点(gdb) disable breakpoint 1该命令将禁止断点1,同时断点信息的(Enb)域将变为n4．允许使用某个断点(gdb) enable breakpoint 1该命令将允许断点1,同时断点信息的(Enb)域将变为y5．清除原文件中某一代码行上的所有断点(gdb)clean number注：number 为原文件的某个代码行的行号六．变量的检查和赋值l whatis:识别数组或变量的类型l ptype:比whatis的功能更强，他可以提供一个结构的定义l set variable:将值赋予变量l print 除了显示一个变量的值外，还可以用来赋值七．单步执行l next不进入的单步执行l step进入的单步执行如果已经进入了某函数，而想退出该函数返回到它的调用函数中，可使用命令finish八．函数的调用l call name 调用和执行一个函数(gdb) call gen_and_sork( 1234,1,0 )(gdb) call printf(“abcd”)$1=4l finish 结束执行当前函数，显示其返回值（如果有的话）九．机器语言工具有一组专用的gdb变量可以用来检查和修改计算机的通用寄存器，gdb提供了目前每一台计算机中实际使用的4个寄存器的标准名字：l $pc ：程序计数器l $fp ：帧指针（当前堆栈帧）l $sp ：栈指针l $ps ：处理器状态十．信号gdb通常可以捕捉到发送给它的大多数信号，通过捕捉信号，它就可决定对于正在运行的进程要做些什么工作。
例如，按CTRL-C将中断信号发送给gdb，通常就会终止gdb。
但是你或许不想中断gdb，真正的目的是要中断gdb正在运行的程序，因此，gdb要抓住该信号并停止它正在运行的程序，这样就可以执行某些调试操作。
Handle命令可控制信号的处理，他有两个参数，一个是信号名，另一个是接受到信号时该作什么。
几种可能的参数是：l nostop 接收到信号时，不要将它发送给程序，也不要停止程序。
l stop 接受到信号时停止程序的执行，从而允许程序调试；显示一条表示已接受到信号的消息（禁止使用消息除外）l print 接受到信号时显示一条消息l noprint 接受到信号时不要显示消息（而且隐含着不停止程序运行）l pass 将信号发送给程序，从而允许你的程序去处理它、停止运行或采取别的动作。
l nopass 停止程序运行，但不要将信号发送给程序。
例如，假定你截获SIGPIPE信号，以防止正在调试的程序接受到该信号，而且只要该信号一到达，就要求该程序停止，并通知你。
要完成这一任务，可利用如下命令：(gdb) handle SIGPIPE stop print请注意，UNIX的信号名总是采用大写字母！你可以用信号编号替代信号名如果你的程序要执行任何信号处理操作，就需要能够测试其信号处理程序，为此，就需要一种能将信号发送给程序的简便方法，这就是signal命令的任务。
该命令的参数是一个数字或者一个名字，如SIGINT。
假定你的程序已将一个专用的SIGINT（键盘输入，或CTRL-C；信号2）信号处理程序设置成采取某个清理动作，要想测试该信号处理程序，你可以设置一个断点并使用如下命令：（gdb）signal 2continuing with signal SIGINT(2)该程序继续执行，但是立即传输该信号，而且处理程序开始运行.十一. 原文件的搜索search text:该命令可显示在当前文件中包含text串的下一行。
Reverse-search text:该命令可以显示包含text 的前一行。
十二.UNIX接口shell 命令可启动UNIX外壳，CTRL-D退出外壳，返回到gdb.十三.命令的历史为了允许使用历史命令，可使用set history expansion on 命令(gdb) set history expansion on小结：常用的gdb命令backtrace 显示程序中的当前位置和表示如何到达当前位置的栈跟踪（同义词：w here）breakpoint 在程序中设置一个断点cd 改变当前工作目录clear 删除刚才停止处的断点commands 命中断点时，列出将要执行的命令continue 从断点开始继续执行delete 删除一个断点或监测点；也可与其他命令一起使用display 程序停止时显示变量和表达时down 下移栈帧，使得另一个函数成为当前函数frame 选择下一条continue命令的帧info 显示与该程序有关的各种信息jump 在源程序中的另一点开始运行kill 异常终止在gdb 控制下运行的程序list 列出相应于正在执行的程序的原文件内容next 执行下一个源程序行，从而执行其整体中的一个函数print 显示变量或表达式的值pwd 显示当前工作目录pype 显示一个数据结构（如一个结构或C++类）的内容quit 退出gdbreverse-search 在源文件中反向搜索正规表达式run 执行该程序search 在源文件中搜索正规表达式set variable 给变量赋值signal 将一个信号发送到正在运行的进程step 执行下一个源程序行，必要时进入下一个函数undisplay display命令的反命令，不要显示表达式until 结束当前循环up 上移栈帧，使另一函数成为当前函数watch 在程序中设置一个监测点（即数据断点）whatis 显示变量或函数类型****************************************************GNU的调试器称为gdb，该程序是一个交互式工具，工作在字符模式。
在X Window 系统中，有一个gdb的前端图形工具，称为xxgdb。
gdb 是功能强大的调试程序，可完成如下的调试任务：* 设置断点；* 监视程序变量的值；* 程序的单步执行；* 修改变量的值。
在可以使用gdb 调试程序之前，必须使用-g 选项编译源文件。
可在make file 中如下定义CFLAGS 变量：CFLAGS = -g运行gdb 调试程序时通常使用如下的命令：gdb progname在gdb 提示符处键入help，将列出命令的分类，主要的分类有：* aliases：命令别名* breakpoints：断点定义；* data：数据查看；* files：指定并查看文件；* internals：维护命令；* running：程序执行；* stack：调用栈查看；* statu：状态查看；* tracepoints：跟踪程序执行。
键入help 后跟命令的分类名，可获得该类命令的详细清单。