gdb调试手册
GDB使用手册
在执行 symbol-file 一次之后，如果按下回车键，它并不会重复执行。
When GDB is configured for a particular environment, it understands debugging information in whatever format is the standard generated for that environment; you may use either a GNU compiler, or other compilers that adhere to the local conventions. Best results are usually obtained from GNU compilers; for example, using gcc you can generate debugging information for optimized code.
从 filename 中读符号表信息。同样地根据需要查找 PATH。使用 file 命令从同一文件得到符号表和要运行的程序。
symbol-file with no argument clears out GDB information on your program's symbol table.
symbol-file 没有参数时，清除 GDB 中的程序的符号表信息。
The symbol-file command causes GDB to forget the contents of some breakpoints and auto-display expressions. This is because they may contain pointers to the internal data recording symbols and data types, which are part of the old symbol table data being discarded inside GDB.
gdb技术手册(中文版)
gdb技术手册（中文版）2-12008-11-13 19:20:59| 分类：学习资料| 标签：|字号大中小订阅gdb技术手册（中文版）2 (2008-10-29 20:34:21)标签：杂谈一、查看源程序一、显示源代码GDB可以打印出所调试程序的源代码，当然，在程序编译时一定要加上-g的参数，把源程序信息编译到执行文件中。
不然就看不到源程序了。
当程序停下来以后，GDB会报告程序停在了那个文件的第几行上。
你可以用list命令来打印程序的源代码。
还是来看一看查看源代码的GDB命令吧。
list<linenum>;显示程序第linenum行的周围的源程序。
list<function>;显示函数名为function的函数的源程序。
list显示当前行后面的源程序。
list -显示当前行前面的源程序一般是打印当前行的上5行和下5行，如果显示函数是是上2行下8行，默认是10行，当然，你也可以定制显示的范围，使用下面命令可以设置一次显示源程序的行数。
set listsize <count>;设置一次显示源代码的行数。
show listsize查看当前listsize的设置。
list命令还有下面的用法：list<first>;,<last>;显示从first行到last行之间的源代码。
list ,<last>;显示从当前行到last行之间的源代码。
list +往后显示源代码。
一般来说在list后面可以跟以下这们的参数：<linenum>; 行号。
<+offset>; 当前行号的正偏移量。
<-offset>; 当前行号的负偏移量。
<filename:linenum>; 哪个文件的哪一行。
<function>; 函数名。
<filename:function>;哪个文件中的哪个函数。
GDB手册中文版
GDB用户手册目录目录 (1)摘要 (2)自由软件 (2)自由软件急需自由文档 (2)GDB的贡献者们 (4)1．一个简单的GDB会话 (8)2．征服GDB的进与出 (13)2.1调用GDB (13)2.1.1 选择文件 (14)2.1.2 选择模式 (16)2.1.3 启动期间，GDB做了什么 (19)2.2 退出GDB (20)2.3 Shell命令 (21)2.4 Loging输出 (21)3．GDB命令 (22)3.1命令语法 (22)3.2命令完成 (23)3.3获得帮助 (25)4．在GDB下运行程序 (29)4.1 适合调试的编译 (29)4.2 启动程序 (30)4.3 程序的参数 (32)4.4 程序的环境 (32)4.5 程序的工作目录 (34)4.6 程序的输入输出 (35)4.7 调试某个已运行的进程 (36)4.8 杀掉子进程 (37)4.9 多线程程序的调试 (37)4.10 多进程程序的调试 (40)5.0停止与继续 (42)摘要象GDB这样的调试程序，目的就是让你可以查看其它程序的内部运行过程，或者是在它崩溃的那一时刻它在做什么。
GDB能做4件事（这些还需附加其他的一些事），帮助你捕获在场的错误：·启动程序，设定任何可以影响它行为的东西。
·在特定的条件下使程序停止。
·当程序停止时，分析发生了什么。
·改变程序里的一些东西，进行一个由于bug所导致的结果的矫正性试验，同时继续了解另外一个bug。
可以使用GDB调试用C和C++编写的程序，更多信息参见支持的语言，及C与C++。
部分支持Modula-2，Modula-2的更多信息参见Modula-2。
在调试使用sets、subranges、file variables或嵌套函数的Pascal程序时，目前不能工作。
GDB不支持entering expressions、printing values或者类似特性的Pascal语法。
gdb使用教程
gdb使用教程GDB是GNU调试器的缩写，是一个功能强大的命令行调试工具，用于帮助开发人员在调试过程中定位和修复程序中的错误。
以下是GDB的使用教程：1. 编译程序时添加调试信息：在使用GDB进行调试之前，需要确保程序在编译时包含了调试信息。
可以通过在编译命令中添加`-g`选项来实现。
例如：`gcc -g main.c -o main`。
2. 启动GDB：在命令行中输入`gdb`命令，然后输入可执行文件的路径作为参数。
例如：`gdb ./main`。
3. 设置断点：断点是在程序执行到指定位置时停下来的标记。
可以使用`break`命令来设置断点。
例如：`break main`可以在`main`函数的开头设置一个断点。
4. 开始执行程序：使用`run`命令来运行程序。
例如：`run`。
5. 执行程序并停在断点处：当程序开始运行后，会在达到断点处停下来等待输入。
此时可以使用一些GDB命令来检查程序的状态，如查看变量的值、栈帧等。
6. 单步执行：使用`next`命令来逐行执行程序。
例如：`next`。
7. 跳出函数：使用`finish`命令可以跳出当前正在执行的函数，并停在调用该函数的上一个函数中。
8. 继续执行：使用`continue`命令可以接着执行程序直到下一个断点或程序结束。
9. 查看变量的值：使用`print`或简写的`p`命令可以查看变量的值。
例如：`print i`可以查看变量`i`的值。
10. 修改变量的值：使用`set`命令可以修改变量的值。
例如：`set i = 10`可以将变量`i`的值修改为10。
11. 查看函数调用栈：使用`backtrace`或简写的`bt`命令可以查看函数调用栈。
12. 退出GDB：使用`quit`命令可以退出GDB。
以上是一些常用的GDB命令，使用GDB进行调试时还有很多其他的功能和命令可以使用，可以通过阅读GDB的文档来更详细地了解。
gdb 调试函数
gdb 调试函数
要调试一个函数，你需要以下步骤：1. 使用`gdb` 命令行工具启动你的程序：`gdb <executable>`，其中`<executable>` 是你要调试的可执行文件。
2. 设置断点：使用`break` 命令在你要调试的函数的位置设置断点。
例如，如果你要调试的函数是`my_function()`，可以使用`break my_function` 来设置断点。
3. 启动程序：使用`run` 命令启动程序，然后程序将在断点处停止执行。
4. 执行程序：使用`next` 命令按行执行代码，或使用`step` 命令进入函数内部执行。
5. 在调试过程中查看变量的值：使用`print` 命令来查看变量的值。
例如，可以使用`print variable_name` 来查看变量`variable_name` 的值。
6. 继续执行程序：使用`continue` 命令继续执行程序，直到下一个断点或程序结束。
7. 在调试结束后退出`gdb`：使用`quit` 命令退出`gdb`。
这些是基本的
`gdb` 调试函数的使用方法。
你还可以使用其他命令来查看堆栈信息、设置条件断点、跳到指定行等。
可以使用`help` 命令来获取更多有关`gdb` 命令的信息。
GDB用户指南说明书
Table of ContentsAbout1 Chapter 1: Getting started with GDB2 Remarks2 Examples2 What is GDB?2 Starting GDB2 Working with a Core File3 Credits5AboutYou can share this PDF with anyone you feel could benefit from it, downloaded the latest version from: gdbIt is an unofficial and free GDB ebook created for educational purposes. All the content is extracted from Stack Overflow Documentation, which is written by many hardworking individuals at Stack Overflow. It is neither affiliated with Stack Overflow nor official GDB.The content is released under Creative Commons BY-SA, and the list of contributors to each chapter are provided in the credits section at the end of this book. Images may be copyright of their respective owners unless otherwise specified. All trademarks and registered trademarks are the property of their respective company owners.Use the content presented in this book at your own risk; it is not guaranteed to be correct nor accurate, please send your feedback and corrections to ********************Chapter 1: Getting started with GDBRemarksGDB (GNU Project debugger) is a command line base debugger that is good at analyzing running and cored programs. According to the user manual GDB supports C, C++, D, Go, Objective-C, Fortran, Java, OpenCL C, Pascal, Rust, assembly, Modula-2, and Ada.GDB has the same feature set as most debuggers but is different from most that I have used in that is all based on typing commands instead of clicking on GUI elements. Some of these features include:•Setting break points•Printing the value of variables.•Setting the value of variables to test things out.•Viewing the stackExamplesWhat is GDB?GDB, short for GNU Debugger, is the most popular debugger for UNIX systems to debug C and C++ programs. GNU Debugger, which is also called gdb, is the most popular debugger for UNIX systems to debug C and C++ programs.GNU Debugger helps you in getting information about the following:•If a core dump happened, then what statement or expression did the program crash on?•If an error occurs while executing a function, what line of theprogram contains the call to that function, and what are theparameters?•What are the values of program variables at a particular point during execution of theprogram?•What is the result of a particular expression in a program?Starting GDBTo start GDB, in the terminal,gdb <executable name>For the above example with a program named main, the command becomesgdb mainSetting BreakpointsYou'll probably want you program to stop at some point so that you can review the condition of your program. The line at which you want the program to temporarily stop is called the breakpoint. break <source code line number>Running your programTo run your program, the command is, as you guessed,runOpening a coregdb -c coreFile pathToExecutableWorking with a Core FileCreated this really bad program#include <stdio.h>#include <ctype.h>// forward declarationsvoid bad_function(){int *test = 5;free(test);}int main(int argc, char *argv[]){bad_function();return 0;}gcc -g ex1.c./a.out //or whatever gcc createsSegmentation fault (core dumped)gdb -c core a.outCore was generated by `./a.out'.Program terminated with signal SIGSEGV, Segmentation fault. #0 __GI___libc_free (mem=0x5) at malloc.c:2929 2929 malloc.c: No such file or directory.(gdb) where#0 __GI___libc_free (mem=0x5) at malloc.c:2929 #1 0x0000000000400549 in bad_function () at ex1.c:12 #2 0x0000000000400564 in main (argc=1, argv=0x7fffb825bd68) at ex1.c:19Since I compiled with -g you can see that calling where tells me that it didn't like the code on line 12 of bad_function()Then I can examine the test variable that I tried to free(gdb) up#1 0x0000000000400549 in bad_function () at ex1.c:12 12 free(test);(gdb) print test$1 = (int *) 0x5(gdb) print *testCannot access memory at address 0x5In this case the bug is pretty obvious I tried to free a pointer that was just assigned the address 5 which wasn't created by malloc so free has no idea what to do with it.Read Getting started with GDB online: https:///gdb/topic/4964/getting-started-with-gdbCredits。
(2021年整理)GDB调试命令手册.
(完整版)GDB调试命令手册.编辑整理：尊敬的读者朋友们：这里是精品文档编辑中心，本文档内容是由我和我的同事精心编辑整理后发布的，发布之前我们对文中内容进行仔细校对，但是难免会有疏漏的地方，但是任然希望（(完整版)GDB调试命令手册.）的内容能够给您的工作和学习带来便利。
同时也真诚的希望收到您的建议和反馈，这将是我们进步的源泉，前进的动力。
本文可编辑可修改，如果觉得对您有帮助请收藏以便随时查阅，最后祝您生活愉快业绩进步，以下为(完整版)GDB调试命令手册.的全部内容。
(完整版)GDB调试命令手册.编辑整理：张嬗雒老师尊敬的读者朋友们：这里是精品文档编辑中心,本文档内容是由我和我的同事精心编辑整理后发布到文库，发布之前我们对文中内容进行仔细校对,但是难免会有疏漏的地方，但是我们任然希望 (完整版)GDB调试命令手册。
这篇文档能够给您的工作和学习带来便利。
同时我们也真诚的希望收到您的建议和反馈到下面的留言区，这将是我们进步的源泉，前进的动力。
本文可编辑可修改，如果觉得对您有帮助请下载收藏以便随时查阅,最后祝您生活愉快业绩进步，以下为〈（完整版）GDB调试命令手册。
> 这篇文档的全部内容。
常用的 gdb 命令backtrace 显示程序中的当前位置和表示如何到达当前位置的栈跟踪（同义词：where 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 显示变量或函数类型GDB 命令分类详解一:列文件清单。
gdb使用手册
gdb使用手册摘要：一、GDB 简介1.GDB 的定义2.GDB 的作用二、GDB 的安装与配置1.安装GDB2.配置GDB三、GDB 的基本使用1.启动GDB2.调试程序3.控制程序执行4.查看程序状态四、GDB 的高级功能1.断点调试2.单步执行3.查看变量值4.修改变量值5.控制台输出6.退出GDB正文：GDB（GNU Debugger）是一个用于调试程序的强大工具。
它支持C、C++等语言，可以通过命令行或图形界面进行操作。
GDB 可以帮助程序员找到程序中的错误，并能够对程序进行调试、测试和优化。
一、GDB 简介GDB 是一个功能强大的调试器，主要用于调试C、C++等语言编写的程序。
它可以让程序员在程序运行过程中观察程序的内部状态，设置断点，单步执行代码等，以便找到程序中的错误。
二、GDB 的安装与配置1.安装GDB：GDB 通常与编译器一起安装，例如，使用GCC 编译器时，可以通过以下命令安装GDB：`sudo apt-get install gdb`。
2.配置GDB：在使用GDB 之前，可能需要对GDB 进行一些配置，例如设置编译器的路径、添加新的调试符号等。
可以使用`gdb-config`命令进行配置。
三、GDB 的基本使用1.启动GDB：使用`gdb`命令启动GDB，并指定要调试的程序。
例如：`gdb my_program`。
2.调试程序：在GDB 中，可以使用`run`命令开始运行程序。
程序将暂停在第一个断点处，此时可以查看程序的状态，例如变量值、内存地址等。
3.控制程序执行：在GDB 中，可以使用`next`、`step`、`continue`等命令控制程序的执行。
`next`命令会执行当前行的下一行代码，`step`命令会执行当前行的所有代码，`continue`命令会继续执行程序，直到遇到断点或程序结束。
4.查看程序状态：在GDB 中，可以使用`print`、`display`、`backtrace`等命令查看程序的状态。
GDB调试命令手册
常用的gdb命令backtrace 显示程序中的当前位置和表示如何到达当前位置的栈跟踪（同义词：where）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 显示变量或函数类型GDB命令分类详解一：列文件清单 (2)二：执行程序 (2)三：显示数据 (2)四：断点(breakpoint) (3)五．断点的管理 (3)六．变量的检查和赋值 (4)七．单步执行 (4)八．函数的调用 (4)九．机器语言工具 (4)十．信号 (4)十一.原文件的搜索 (5)十二. UNIX接口 (5)十三. 命令的历史 (5)十四. GDB帮助 (5)十五. GDB多线程 (6)十六. GDB使用范例 (7)一：列文件清单1．List(gdb) list line1,line2二：执行程序要想运行准备调试的程序，可使用run命令，在它后面可以跟随发给该程序的任何参数，包括标准输入和标准输出说明符(<和>)和外壳通配符（*、？、[、]）在内。
GDB中文手册
GDB中文手册/****************************************************/GDB 用调试程序GDB 2概述GDB 5使用GDB UNIX shell 8中运行的程序GDB 8在中运行程序 9调试已运行的程序两种方法： / 9暂停恢复程序运行BreakPoint 9一、设置断点（）WatchPoint 10二、设置观察点（）CatchPoint 10三、设置捕捉点（） 11四、维护停止点 12五、停止条件维护 12六、为停止点设定运行命令 13七、断点菜单 13八、恢复程序运行和单步调试Signals 14九、信号（）Thread Stops 15十、线程（） 16查看栈信息 18查看源程序 18一、显示源代码 19二、搜索源代码 19三、指定源文件的路径 20四、源代码的内存 21查看运行时数据 21一、表达式 21二、程序变量 22三、数组 23四、输出格式 23五、查看内存 24六、自动显示 25七、设置显示选项GDB 25中关于显示的选项比较多，这里我只例举大多数常用的选项。
27八、历史记录GDB 28九、环境变量 28十、查看寄存器 29改变程序的执行 29一、修改变量值 29二、跳转执行 30三、产生信号量 30四、强制函数返回 30五、强制调用函数GDB 31在不同语言中使用 32后记 1 第页GDB概述是开源组织发布的一个强大的下的程序调试工具。
或许，各位比较喜欢那种GDB GNU UNIX图形界面方式的，像、等的调试，但如果你是在平台下做软件，你会发现VC BCB IDE UNIX这个调试工具有比、的图形化调试器更强大的功能。
所谓寸有所长，尺有所短GDB VC BCB“”就是这个道理。
一般来说，主要帮忙你完成下面四个方面的功能：GDB1、启动你的程序，可以按照你的自定义的要求随心所欲的运行程序。
2、可让被调试的程序在你所指定的调置的断点处停住。
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启动GDB的方法有以下几种：1、gdb programprogram也就是你的执行文件，一般在当然目录下。
2、gdb program core用gdb同时调试一个运行程序和core文件，core是程序非法执行后core dump后产生的文件。
3、gdb pid如果你的程序是一个服务程序，那么你可以指定这个服务程序运行时的进程ID。
gdb会自动attach上去，并调试他。
program应该在PATH环境变量中搜索得到。
GDB启动时，可以加上一些GDB的启动开关，详细的开关可以用gdb -help查看。
我在下面只例举一些比较常用的参数：参数说明-symbols [file](-s)读取文件中的符号表-exec [file] (-e)调试一个可执行文件-se [file]上二者的缩写-core [file](-c)读入一个core dump文件-pid number (-p)启动attach模式，除错一个执行中的行程。
number 是目标行程的pid-directory [directory] (-d)将directory加入原始码的搜寻路行-readnow (-r)一次读取完所有的符号表，这会让启动gdb的时间变长，但在执行往后的除错动作会较快速。
下列还有部分选择性的参数，我列出几个目前用的到的：-quiet -silent -q安静模式，启动时gdb将不会显示版权页。
常用GDB调试方法
常用GDB调试方法GDB（GNU调试器）是一个命令行调试工具，用于在开发和调试过程中定位和修复程序中的错误。
它具有丰富的功能，如设置断点、单步执行、查看变量和内存、跟踪程序执行流等。
下面是一些常用的GDB调试方法。
1.启动程序调试：要在GDB中调试一个程序，需要先启动GDB并加载要调试的可执行文件。
在命令行中输入“gdb [executable]”来启动GDB，并将可执行文件作为参数传递给它。
2.设置断点：断点是程序执行过程中的一个停止点，用于跟踪程序执行流和查看变量的值。
使用“break [line number]”命令在指定行上设置断点。
例如，“break main”将在程序的主函数上设置一个断点。
3.启动程序：在GDB中使用“run”命令来启动程序的执行。
程序将在遇到断点或程序结束时停止。
4.单步执行：使用“step”命令可以按照程序的执行流，在函数调用之间进行单步执行。
这将进入函数并执行函数内部的代码。
5.继续执行：使用“continue”命令可以让程序继续执行，直到遇到下一个断点或程序结束。
6.查看变量：使用“print [variable]”命令可以查看变量的值。
也可以使用“display [variable]”命令在每次停止时自动显示变量的值。
7.修改变量的值：使用“set [variable]=[value]”命令可以修改变量的值。
这在调试过程中有时很有用。
8.查看函数调用栈：使用“backtrace”命令可以查看函数调用栈。
这将显示当前函数和调用它的函数。
9.查看堆栈帧：使用“frame [n]”命令可以查看调用栈中的特定堆栈帧。
这将显示该堆栈帧中的函数和局部变量。
10.观察程序的执行流：使用“next”命令可以按照程序的执行流在语句之间执行。
这不会进入函数调用。
11.跟踪程序的执行流：使用“trace”命令可以跟踪程序的执行流。
这将显示程序执行的每一步。
12.设置条件断点：使用“break [line number] if [condition]”命令可以在满足特定条件时设置断点。
gdb跟踪调试程序的方法
gdb跟踪调试程序的方法嘿，朋友们！今天咱来聊聊 gdb 跟踪调试程序的那些事儿。
这就好比你在一个神秘的代码世界里探险，而 gdb 就是你手中的神奇魔杖！首先呢，你得把 gdb 这个小工具准备好。
就像战士上战场得有趁手的兵器一样，gdb 就是咱程序员的得力助手。
然后，当你要调试一个程序的时候，就像打开一扇通往奇妙世界的大门。
你可以用 gdb 去加载这个程序，这感觉就像是你进入了一个满是代码宝藏的洞穴。
在这个过程中，你可以设置断点。
哎呀呀，这断点可太重要啦！就好比你在代码的道路上放置了一个个小标记，当程序运行到这里的时候，就会停下来，等你去查看。
这多方便呀，就像你在路上走，突然看到一个有趣的地方，就停下来好好瞧瞧。
还有哦，你可以查看变量的值。
这就像你在这个代码世界里，能清楚地看到每个宝藏的具体模样。
你可以知道这个变量现在是什么状态，是不是符合你的预期。
当程序暂停在断点处时，你可以一步步地执行代码。
这感觉就像是你小心翼翼地在代码的小道上往前走，每一步都看得清清楚楚。
你可以看到每一行代码是怎么影响程序的运行的。
你想想，这多神奇呀！就好像你能掌控整个代码的运行过程，让它按照你的意愿来走。
如果程序出了问题，你就能像侦探一样，通过 gdb 找到问题的根源。
比如说，程序突然崩溃了，别着急，用 gdb 来跟踪呀！看看是在哪一行代码出了岔子，是哪个变量的值变得不对劲了。
这不就像是在黑暗中找到了那一丝光亮吗？而且哦，gdb 还能帮你查看函数的调用栈。
这就像是你能看到整个程序的运行轨迹，从一个函数跳到另一个函数，就像在一个复杂的迷宫中找到正确的路径。
总之呢，gdb 跟踪调试程序就像是一场刺激的冒险。
你要勇敢地面对代码世界里的各种挑战，利用好 gdb 这个神奇的工具。
所以呀，朋友们，别害怕遇到程序中的问题，拿起 gdb 这个法宝，大胆地去探索吧！让我们在代码的海洋里畅游，找到那些隐藏的宝藏，解决那些看似棘手的问题。
相信我，一旦你掌握了 gdb 跟踪调试程序的方法，你就会发现编程变得更加有趣，更加有成就感啦！。
GDB使用手册
GDB使用手册《GDB 使用手册详解》一、引言（一）GDB 的简介（二）GDB 的主要功能（三）使用 GDB 的好处二、安装与配置 GDB （一）GDB 的安装方法（二）配置 GDB 的环境变量（三）启动 GDB三、GDB 的基本命令（一）设置断点（二）查看变量（三）单步调试（四）继续执行（五）查看调用栈（六）修改变量的值四、调试多线程程序（一）查看线程信息（二）切换线程（三）设置线程断点（四）处理线程竞争五、调试内存问题（一）检查内存泄漏（二）查看内存布局（三）分析内存访问错误六、调试核心转储文件（一）生成核心转储文件（二）使用 GDB 分析核心转储文件（三）查找导致崩溃的原因七、GDB 的高级功能（一）条件断点（二）监视点（三）远程调试（四）脚本化调试八、GDB 与其他工具的集成（一）与编译器集成（二）与版本控制系统集成（三）与调试器前端集成九、实际案例分析（一）使用 GDB 调试一个简单的程序（二）调试一个多线程程序（三）调试一个内存泄漏问题（四）调试一个核心转储文件十、GDB 的常见问题与解决方法（一）无法启动 GDB（二）断点不起作用（三）调试信息不完整（四）其他常见问题十一、GDB 的最佳实践（一）合理使用断点（二）注意调试的效率（三）结合其他工具进行调试（四）及时清理调试环境十二、GDB 的未来发展（一）GDB 的发展趋势（二）对开发者的影响十三、附录（一）GDB 的命令参考（二）相关资源链接（三）常见问题解答以上是根据 GDB 使用手册编写的文章大纲，你可以根据实际情况进行具体内容的填充和扩展，确保文章不少于 2500 字。
GDB使用说明
GDB使用说明文档一、简介：GDB能让你观察一个程序在执行时的内部活动，或程序出错时发生了什么。
GDB主要能为你做以下四件事，帮助你找出程序中的错误。
1.运行你的程序，设置所有的能影响程序运行的东西。
2.保证你的程序在指定的条件下停止。
3.当你程序停止时，让你检查发生了什么。
4.改变你的程序。
那样你可以试着修正某个bug引起的问题，然后继续查找另一个bug.二、GDB运行方式1.通常的调试可执行程序：gdb <可执行文档名>2.调试执行文件指定一个core文件：gdb <可执行文件名> core3.为执行的文件指定一个进程号：gdb <可执行文件名> <进程号>三、GDB常用命令下面先说明GDB的基本指令：（大部分命令使用时只要输入第一个字母就好了，同时支持TAB的自动补全，与shell相类似）1.help：查看帮助2.file：指定一个可执行文件进行调试，gdb将读取些文件的调试信息3.list：列出程序源文件4.run：装载完要调试的可执行文件后，可以用run命令运行可执行文件5.break：设置断点breakpoint，如b 25，则在源程序的第25行设置一个断点，当程序执行到第25行时，就会产生中断；也可以使用b funcname，funcname为函数的名称，当程序调用些函数时，则产生中断6.continue：c命令可以使中断的程序继续执行，直到下一个中断点或程序结束7.print：输入某个变量的值，如程序定义了一个int aa的就是，p aa就会输出aa的当前值8.next：程序执行到断点时中断执行，可以用n指令进行单步执行9.step：程序执行到断点时中断执行，可以用s指令进行单步执行进某一函数，如果已经进入了某函数，而想退出该函数返回到它的调用函数中，可使用命令finish10.attach：命令为attach PROCESS-ID，这个命令把一个已经运行的进程(在gdb外启动)连接入gdb,以便调试。
最新GDB 单步调试
G D B单步调试GDB 单步调试1、首先需要用gcc(g++)对源文件进行编译生成可执行文件，并且在编译时加上选项-g，把调试信息加到目标文件中。
2、假设生成的可执行文件为test，那么gdb test可以用gdb打开test 文件，然后通过break linenum设置断点。
可以输入list查看源文件和行号，方便设置断点。
断点设置好后就可以run命令运行到断点处了。
下面是转载一、初始化输入gdb进入gdb调试环境。
或者直接输入gdb+progfile来加载文件。
注意该文件是使用gcc(或g++)编译得到的。
为了使gdb正常工作,必须使你的程序在编译时包含调试信息，编译时必须使用-g参数来。
或者进入gdb环境后，通过命令file+progfile来加载需要调试的可执行文件文件。
查看源代码：list[函数名][行数]设置程序运行参数：set args二、暂停程序gdb可以使用几种方式来暂停程序：断点，观察点，捕捉点，信号，线程停止。
当程序被暂停后，可以使用continue、next、step来继续执行程序。
continue执行到下一暂停点或程序结束。
next执行一行源代码但不进入函数内部。
step执行一行源代码而且进入函数内部。
1、设置断点：a、break+[源代码行号][源代码函数名][内存地址]b、break.if condition.可以是上述任一参数，condition条件。
例如在循环体中可以设置break.if i=100来设置循环次数。
2、设置观察点：a、watch+[变量][表达式]当变量或表达式值改变时即停住程序。
b、rwatch+[变量][表达式]当变量或表达式被读时，停住程序。
c、awatch+[变量][表达式]当变量或表达式被读或被写时，停住程序。
3、设置捕捉点：catch+event当event发生时，停住程序。
event可以是下面的内容：1)、throw一个C++抛出的异常。
常用GDB调试方法
1.什么是GDBGDB是GNU开源组织发布的一个强大的UNIX下的C/C++程序调试工具。
虽然GDB自身并没有Windows上大多数IDE的调试工具的高可视化和图形化功能，但命令行式调试也具有其很大的优点，如果希望在GDB上提升可视化功能，可以使用vim的gdb插件对gdb进行加强。
顺便提一下调试程序的几大功能：a)自定义方式启动程序；b)可以设置断点，使程序在指定的断点处停住；c)当程序停住时，可以查看程序的运行时数据；d)可以修改程序的运行时数据；2.GDB与编译器的-g和-ggdb参数cc/gcc/g++使用-g参数可以在编译时利用操作系统的“原生格式（native format）”生成调试信息。
这些信息GDB可以直接利用，当然其它的调试工具也能够直接利用。
-g参数是分级别的：a) -g2使用-g的默认的级别，此时产生的调试信息包括扩展的符号表、行号、局部或外部变量信息。
如果不使用，则只有内存地址信息，没有响应的标识信息；b）-g3包含级别-g2中的所有调试信息，以及源代码中定义的宏；c）-g1级别1（-g1）不包含局部变量和与行号有关的调试信息，因此只能够用于回溯跟踪和堆栈转储之用。
回溯跟踪指的是监视程序在运行过程中的函数调用历史，堆栈转储则是一种以原始的十六进制格式保存程序执行环境的方法，两者都是经常用到的调试手段。
-ggdb参数能够为GDB生成更为丰富的调试信息，与-g相同，也有3个级别，如果希望调试宏，则可以使用-ggdb3。
但与-g不同的是，-ggdb生成的信息只能被GDB使用，而不能被其它调试工具使用。
3.使用GDB启动调试使用GDB启动调试的方法有一下几种（只是关联上调试目标程序，并没有开始运行目标程序）：a)gdb <program><program>也就是你的执行文件，要在PATH环境变量下能搜索到，一般在当前目录下；b)gdb <program> core_file用gdb同时调试一个运行程序和core文件，core是程序非法执行后core dump后产生的文件。
gdb调试流程
gdb调试流程
Gdb调试是一种基于命令行的调试工具，可以帮助程序员在程序运行时查找和解决错误。
下面是Gdb调试的一般流程：
1.编译程序时加上-g选项，生成可调试的二进制文件。
2.运行Gdb，使用file命令加载要调试的程序。
3.使用break命令设置断点，可以在某一行代码处暂停程序执行。
4.运行程序，在断点处停止。
5.使用print命令查看变量的值，可以帮助找出错误。
6.使用step命令逐行执行程序，可以查看程序的执行流程。
7.使用continue命令让程序继续执行，直到下一个断点处停止。
8.使用backtrace命令查看函数调用栈，可以了解程序执行路径。
9.使用watch命令监视变量的值，在变量值改变时自动停止程序。
10.使用quit命令退出Gdb调试。
Gdb调试流程可以帮助程序员快速定位和解决程序错误，提高程序的稳定性和可靠性。
- 1 -。
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调试命令的使⽤及总结gdb调试命令的使⽤及总结gdb是⼀个在UNIX环境下的命令⾏调试⼯具。
如果需要使⽤gdb调试程序，请在gcc时加上-g选项。
下⾯的命令部分是简化版，⽐如使⽤l代替list等等。
1.基本命令命令描述backtrace（或bt）查看各级函数调⽤及参数finish连续运⾏到当前函数返回为⽌，然后停下来等待命令frame（或f）帧编号选择栈帧info（或i） locals查看当前栈帧局部变量的值list（或l）列出源代码，接着上次的位置往下列，每次列10⾏list ⾏号列出从第⼏⾏开始的源代码list 函数名列出某个函数的源代码next（或n）执⾏下⼀⾏语句print（或p）打印表达式的值，通过表达式可以修改变量的值或者调⽤函数quit（或q）退出gdb调试环境set var修改变量的值start开始执⾏程序，停在main函数第⼀⾏语句前⾯等待命令step（或s）执⾏下⼀⾏语句，如果有函数调⽤则进⼊到函数中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) q2.断点调试命令格式 例⼦ 作⽤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 设置捕捉点来补捉程序运⾏时的⼀些事件。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
GDB调试器使用手册使用GDB:本文描述GDB,GNU的原代码调试器。
(这是4.12版1994年一月，GDB版本4。
16)* 目录：* 摘要： GDB的摘要* 实例：一个使用实例* 入门：进入和退出GDB* 命令： GDB 的命令* 运行：在GDB下运行程序* 停止：暂停和继续执行* 栈：检查堆栈* 原文件：检查原文件* 数据：检查数据* 语言：用不同的语言来使用GDB* 符号：检查符号表* 更改：更改执行* GDB的文件文件* 对象指定调试对象* 控制GDB 控制* 执行序列：执行一序列命令* Emacs: 使GDB和Emacs一起工作* GDB的bug:* 命令行编辑：行编辑* 使用历史记录交互：* 格式化文档：如何格式化和打印GDB文档* 索引：GDB简介：**************调试器(比如象GDB)能让你观察另一个程序在执行时的内部活动，或程序出错时发生了什么。
GDB主要能为你做四件事(包括为了完成这些事而附加的功能)，帮助你找出程序中的错误。
* 运行你的程序，设置所有的能影响程序运行的东西。
* 保证你的程序在指定的条件下停止。
* 当你程序停止时，让你检查发生了什么。
* 改变你的程序。
那样你可以试着修正某个bug引起的问题，然后继续查找另一个bug.你可以用GDB来调试C和C++写的程序。
(参考 *C 和C++)调试Pascal程序时，有一些功能还不能使用。
GDB还可以用来调试FORTRAN程序，尽管现在还不支持表达式的输入，输出变量，或类FORTRAN的词法。
* GDB是"free software"，大家都可以免费拷贝。
也可以为GDB增加新的功能，不过可要遵守GNU的许可协议幺。
反正我认为GNU还是比较不错的：-)就这句话：Fundamentally, the General Public License is a license which says that you have these freedoms and that you cannot take these freedoms away from anyone else.GDB的作者：Richard Stallman是GDB的始作俑者,另外还有许多别的GNU的成员。
许多人为此作出了贡献。
(都是老外不提也罢，但愿他们不要来找我麻烦：-))这里是GDB的一个例子：原文中是使用一个叫m4的程序。
但很遗憾我找不到这个程序的原代码，所以没有办法来按照原文来说明。
不过反正是个例子，我就拿一个操作系统的进程调度原码来说明把，原代码我会附在后面。
首先这个程序叫os.c是一个模拟进程调度的原程序(也许是个老古董了：-))。
先说明一下如何取得包括原代码符号的可执行代码。
大家有心的话可以去看一下gcc的man文件(在shell下打man gcc)。
gcc -g <原文件.c> -o <要生成的文件名> -g 的意思是生成带原代码调试符号的可执行文件。
-o 的意思是指定可执行文件名。
(gcc 的命令行参数有一大堆，有兴趣可以自己去看看。
)反正在linux下把os.c用以上方法编译连接以后就产生了可供gdb使用的可执行文件。
我用gcc -g os.c -o os，产生的可执行文档叫os.然后打gdb os,就可进入gdb，屏幕提示：GDB is free software and you are welcome to distribute copiesof it under certain conditions; type "show copying" to seethe conditions.There is absolutely no warranty for GDB; type "show warranty" for details.GDB 4.16, Copyright 1995 Free Software Foundation, Inc... (gdb)(gdb)是提示符，在这提示符下可以输入命令，直到退出。
(退出命令是q/Q) 为了尽量和原文档说明的命令相符，即使在本例子中没用的命令我也将演示。
首先我们可以设置gdb的屏幕大小。
键入：(gdb)set width 70就是把标准屏幕设为70列。
然后让我们来设置断点。
设置方法很简单:break或简单打b后面加行号或函数名比如我们可以在main 函数上设断点：(gdb)break main或(gdb)b main系统提示：Breakpoint 1 at 0x8049552: file os.c, line 455.然后我们可以运行这个程序，当程序运行到main函数时程序就会停止返回到gdb 的提示符下。
运行的命令是run或r(gdb中有不少alias,可以看一下help,在gdb 下打help)run 后面可以跟参数，就是为程序指定命令行参数。
比如r abcd，则程序就会abcd以作为参数。
(这里要说明的是可以用set args 来指定参数)。
打入r或run后，程序就开始运行直到进入main的入口停止，显示：Starting program: <路径>/osBreakpoint 1, main () at os.c:455455 Initial();这里455 Initial();是将要执行的命令或函数。
gdb提供两种方式：1.单步进入,step into就是跟踪到函数内啦。
命令是step 或s2.单步，next，就是简单的单步，不会进入函数。
命令是next或n这两个命令还有别的用法以后再说。
我们用n命令，键入:(gdb)nSuccess forking process# 1 ,pid is 31474Success forking process# 2 ,pid is 31475Success forking process# 3 ,pid is 31476Success forking process# 5 ,pid is 31478Success forking process# 6 ,pid is 31479Dispatching Algorithm : FIFO********************************************************************* ***********PCB# PID Priority PC State1 31474 24 0 WAITING2 31475 19 0 WAITING3 31476 16 0 WAITING4 31477 23 0 WAITING5 31478 22 0 WAITING6 31479 20 0 WAITING********************************************************************* *********CPU : NO process runningIO : No processWaiting CPU!!! 31474 31475 31476 31477 31478 31479 Waiting IO NONE456 State=WAITING;最后的一行就是下一句要执行的命令。
我们现在在另一个函数上加断点。
注意我们可以用l/list命令来显示原代码。
这里我们键入(gdb)l451 main()452 {453 int message;454455 Initial();456 State=WAITING;457 printf("Use Control-C to halt \n");458 signal(SIGALRM,AlarmMessage);459 signal(SIGINT,InteruptMessage);460 signal(SIGUSR2,IoMessage);(gdb) l461 alarm(TimeSlot);462 for(;;)463 {464 message=GetMessage();465 switch(message)466 {468 break;469 caseCHILD_IO: WaitingIo();470 break;显示了原代码，现在在AlarmMessage上加断点。
(gdb) b AlarmMessageBreakpoint 2 at 0x8048ee3: file os.c, line 259.(gdb)然后我们继续运行程序。
(gdb)cc或continue命令让我们继续被中断的程序。
显示：Continuing.Use Control-C to haltBreakpoint 2, AlarmMessage () at os.c:259259 ClearSignal();注意我们下一句语句就是ClearSignal();我们用s/step跟踪进入这个函数看看它是干什么的。
(gdb) sClearSignal () at os.c:227227 signal(SIGINT,SIG_IGN);用l命令列出原代码：(gdb) l222 }223224225 void ClearSignal() /* Clear other signals */226 {227 signal(SIGINT,SIG_IGN);228 signal(SIGALRM,SIG_IGN);229 signal(SIGUSR2,SIG_IGN);230 }231(gdb)我们可以用s命令继续跟踪。
现在让我们来试试bt或backtrace命令。
这个命令可以显示栈中的内容。
(gdb) bt#0 ClearSignal () at os.c:227#1 0x8048ee8 in AlarmMessage () at os.c:259#2 0xbffffaec in ?? ()#3 0x80486ae in ___crt_dummy__ ()(gdb)大家一定能看懂显示的意思。
栈顶是AlarmMessage，接下来的函数没有名字--就是没有原代码符号。
这显示了函数调用的嵌套。
好了，我们跟踪了半天还没有检查过变量的值呢。
检查表达式的值的命令是p或print格式是p <表达式>444444让我们来找一个变量来看看。
：-)(gdb)l 1还记得l的作用吗？l或list显示原代码符号，l或list加<行号>就显示从<行号>开始的原代码。
好了找到一个让我们来看看WaitingQueue的内容(gdb) p WaitingQueue$1 = {1, 2, 3, 4, 5, 6, 0}(gdb)WaitingQueue是一个数组，gdb还支持结构的显示，(gdb) p Pcb$2 = {{Pid = 0, State = 0, Prior = 0, pc = 0}, {Pid = 31474, State = 2, Prior = 24, pc = 0}, {Pid = 31475, State = 2, Prior = 19, pc = 0}, {Pid = 31476, State = 2, Prior = 16, pc = 0}, {Pid = 31477, State = 2,Prior = 23, pc = 0}, {Pid = 31478, State = 2, Prior = 22, pc = 0}, {Pid = 31479, State = 2, Prior = 20, pc = 0}}(gdb)这里可以对照原程序看看。