GDB调试简易教程.ppt
GDB调试简易教程
GDB调试简易教程GDB（GNU调试器）是一个开源的调试工具，它用于调试C、C++和其他编程语言的程序。
它允许程序员在执行过程中观察程序的内部状态，帮助找到程序中的错误并进行修复。
下面是一个简易的GDB调试教程，以帮助你入门并学会使用它。
安装GDB首先，你需要在你的系统上安装GDB。
对于大多数Linux发行版，你可以通过在终端中运行以下命令来安装它：```sudo apt-get install gdb```编译程序在使用GDB之前，你需要编译你的程序，并在编译时使用-g选项，以便生成调试信息。
例如，对于C语言程序，你可以使用以下命令来编译：```gcc -g program.c -o program```这将生成一个可执行文件program，并在目录中生成调试信息。
启动GDB在终端中使用以下命令来启动GDB并调试你的程序：```gdb program```这将启动GDB，并且你将看到GDB的命令提示符。
设置断点断点是你在程序中指定的一个位置，当程序执行到该位置时会暂停。
你可以使用断点来观察程序在这一点的状态。
要设置断点，请在GDB的命令提示符下输入以下命令：```break line_number```line_number是你想要设置断点的源代码行号。
例如，要在程序的第10行设置断点，你可以使用以下命令：```break 10```或者你也可以使用函数名作为参数来设置断点：```break function_name```开始调试一旦设置好断点，你可以开始调试你的程序了。
要开始执行程序，请输入以下命令：```run```程序将开始运行直到第一个断点处。
此时，程序会停下来并且GDB会等待你的进一步命令。
观察变量在程序运行到断点处时，你可以使用以下命令来观察程序内部的变量值：```print variable_name```variable_name是你想要观察的变量的名称。
例如，要查看变量x的值，你可以使用以下命令：```print x```你还可以通过使用其他GDB命令来观察更多的变量信息，例如观察数组、结构体等。
使用GDB进行程序调试
使用GDB进行程序调试GDB（GNU Debugger）是一个功能强大的调试工具，可以帮助程序员找到和解决程序中的错误。
它支持多种编程语言，包括C，C++，Fortran 等，并且可以在多种操作系统上运行，如Linux，MacOS和Windows。
下面是使用GDB进行程序调试的一般步骤：1. 编译程序时添加调试信息：在使用GDB进行程序调试之前，我们需要在编译程序时添加调试信息。
在GCC编译器中，可以通过使用`-g`选项来实现。
例如，`gcc -g my_program.c -o my_program`。
2. 启动GDB：以调试模式启动GDB，可以通过在终端中输入`gdb`命令来启动GDB。
然后，使用`file`命令加载要调试的可执行文件。
例如，`file my_program`。
3. 设置断点：在代码中设置断点，GDB会在断点处停止执行程序。
可以使用`break`命令来设置断点。
例如，`break main`会在程序开始执行时停止在`main`函数的第一行。
4. 运行程序：使用`run`命令来运行程序。
GDB会启动程序，并在遇到断点时停止。
可以使用`continue`命令继续执行程序。
5. 调试程序：一旦程序停止在断点处，可以使用一些GDB命令来检查变量的值，跟踪程序执行流程等。
例如，使用`print`命令来打印变量的值，使用`step`命令来单步执行程序，使用`next`命令将执行一行代码，而不会深入到函数内部。
6. 回顾栈帧：GDB允许回顾程序调用栈上的栈帧信息。
可以使用`backtrace`命令来打印当前调用栈上所有活动栈帧的信息。
使用`frame`命令可以切换到任一栈帧。
7. 调试崩溃：如果程序崩溃了，GDB将会在崩溃发生时停止程序并提供一些有关崩溃原因的信息。
通过使用`bt`命令可以获得崩溃时的调用栈信息。
8. 再次运行：如果在调试过程中发现问题已经解决，可以使用`kill`命令停止程序的执行，并使用`run`命令重新运行程序。
第7章 GDB调试器及调试方法
7.5 内存出错的gdb调试
• 有的程序可以通过编译, 但在运行时会出现Segment fault(段
错误). 这通常都是指针错误引起的. 但这不像编译错误一样会提示到文件->行, 而是没有任何信息, 使得我们的调试变得困难起来.
• 有一种办法是, 我们用gdb的step, 一步一步寻找. 这放在短小
•
调试方法 主机IP：192.168.0.33，目标板IP：192.168.0.34 1.用交叉编译器编译程序hello，并拷贝至目标板。 2.运行目标板上的gdbserver。 例：./gdbserver 192.168.0.33:6666 hello 3.运行主机上的linux-gdb，并连接目标板。 例：linux-gdb hello （gdb）target remote 192.168.0.34:6666 4.调试程序。 连接后调试方法与本地gdb调试方法相同。
3 Sept. 2008 Confidential
7.3 gdb命令
[break命令的使用] 1. 根据行号设置断点: (gdb) break linenum 2. 根据函数名设置断点: (gdb) break funcname 3. 执行非当前源文件的某行或某函数时停止执行: (gdb) break filename:linenum (gdb) break filename:funcname 4. 根据条件停止程序执行: (gdb) break linenum if expr (gdb) break funcname if expr
3 Sept. 2008 Confidential
7.6 其它调试方法
•
利用#ifdef #endif为程序添加调试信息。
3 Sept. 2008 Confidential
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调试技巧与实战
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是一个功能强大的调试器，它可以帮助开发人员定位和解决程序中的错误。
本教程将介绍如何使用GDB进行调试。
1. 安装GDB在开始使用GDB之前，首先需要在您的机器上安装它。
您可以通过在终端中运行以下命令来检查是否已安装GDB：```gdb --version```如果显示了GDB的版本信息，则表示已安装。
如果没有安装，可以通过系统包管理器或从GDB官方网站上下载安装包进行安装。
2. 编译程序在使用GDB之前，需要确保程序是以调试模式编译的。
在编译时，可以使用`-g`选项来启用调试信息的生成。
例如：```gcc -g -o myprogram myprogram.c```这样会生成一个名为`myprogram`的可执行文件，其中包含调试信息。
3. 启动GDB运行以下命令以启动GDB并加载程序：```gdb myprogram```这将启动GDB并将`myprogram`加载到调试器中。
4. 设置断点断点是GDB中的一个重要特性，它可以让您在程序执行时暂停并进行调试。
您可以使用`break`命令来设置断点。
例如，要在`main`函数的第10行设置一个断点，运行以下命令：```break main:10```当程序执行到该行时，它将暂停并等待您执行下一步操作。
5. 执行程序您可以使用`run`命令来执行程序。
例如：```run```程序将开始执行，并在遇到断点或程序结束时停止。
6. 调试命令一旦程序暂停，您可以使用各种GDB命令来查看和操作程序状态。
以下是一些常用的命令：- `next`: 执行下一行代码。
- `step`: 进入函数并执行下一行代码。
- `print <variable>`: 打印变量的值。
- `backtrace`: 打印函数调用堆栈。
- `continue`: 继续执行程序直到下一个断点或程序结束。
可以使用`help`命令来获取有关其他命令的更多信息。
7. 查看内存和寄存器GDB还可以让您查看程序的内存和寄存器状态。
gdb调试教程
gdb调试教程GDB调试教程GDB（GNU调试器）是一个用于调试程序的强大工具。
它可以用于查找程序中的错误、跟踪程序的执行过程、观察程序的变量和内存、以及进行程序的优化等。
本教程将介绍如何使用GDB进行程序调试。
1. 启动GDB要启动GDB，只需在终端中键入“gdb”命令，然后在空格后输入需要调试的可执行文件的名称。
例如：```$ gdb my_program```2. 设置断点断点是在程序中设置的一个标记，用于指示GDB在此处停止程序的执行。
要设置断点，请在GDB提示符后输入“break”命令，后跟要设置断点的代码行或函数的名称。
例如：```(gdb) break main.cpp:10```3. 运行程序在设置完断点后，可以使用“run”命令来运行程序。
例如：```(gdb) run```程序将开始执行，并在达到断点处时暂停。
4. 调试命令在程序暂停执行时，可以使用各种GDB命令来检查程序的状态。
以下是一些常用的命令：- `list`：显示当前执行点周围的源代码。
- `print`：打印程序中的变量值。
- `step`：执行当前行，并进入任何调用的函数。
如果当前行有多个函数调用，GDB将进入第一个调用的函数。
- `next`：执行当前行，但不进入任何调用的函数。
如果当前行有多个函数调用，GDB将仅执行当前行并跳过后续的函数调用。
- `continue`：继续程序的执行，直到下一个断点或程序结束。
5. 查看堆栈使用“backtrace”命令可以查看程序运行时的函数调用堆栈。
这将显示调用堆栈的所有函数和相应的行号。
```(gdb) backtrace```6. 跟踪变量和内存GDB还可以让你查看程序的变量和内存。
使用“print”命令可以在程序暂停时查看变量的值。
例如：```(gdb) print my_variable```要查看内存中的内容，可以使用“x”命令。
例如，要查看内存位置0x100的内容：```(gdb) x /x 0x100```7. 结束调试会话要结束GDB调试会话，可以使用“quit”命令。
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命令 (20)2.4 Loging输出 (20)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 程序的输入输出 (34)4.7 调试某个已运行的进程 (35)4.8 杀掉子进程 (36)4.9 多线程程序的调试 (37)4.10 多进程程序的调试 (40)5.0停止与继续 (41)摘要象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调试程序的第一步是启动程序。
在命令行中键入“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（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 使用手册简述一列文件清单二：执行程序三：显示数据四：断点(breakpoint)五．断点的管理六．变量的检查和赋值七. 单步执行八．函数的调用九．机器语言工具十．信号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为变量名)print 是gdb的一个功能很强的命令，利用它可以显示被调试的语言中任何有效的表达式。
表达式除了包含你程序中的变量外，还可以包含以下内容：对程序中函数的调用(gdb) print find_entry(1,0)数据结构和其他复杂对象(gdb) print *table_start$8={e=reference=’\000’,location=0x0,next=0x0}值的历史成分(gdb)print $1 ($1为历史记录变量,在以后可以直接引用$1 的值)人为数组人为数组提供了一种去显示存储器块（数组节或动态分配的存储区）内容的方法。
早期的调试程序没有很好的方法将任意的指针换成一个数组。
就像对待参数一样，让我们查看内存中在变量h后面的10个整数，一个动态数组的语法如下所示：base@length因此，要想显示在h后面的10个元素，可以使用h@10：(gdb)print h@10$13=(-1,345,23,-234,0,0,0,98,345,10)whatis 命令可以显示某个变量的类型(gdb) whatis ptype = int *四：断点(breakpoint)break命令（可以简写为b）可以用来在调试的程序中设置断点，该命令有如下四种形式：break line-number 使程序恰好在执行给定行之前停止。
GDB调试简明教程
GDB调试简明教程GDB调试简明教程⽬录创建GDB调试程序⼀般关闭编译优化 -o显⽰所有warnings -Wallgcc -g -Wall program.c -o programg++ -g -Wall program1.c program2.c -o program可以看到加⼊了调试的test更⼤，但事实上只是加⼊⾏号等信息，没有加⼊源代码。
因此源代码要在同⼀⽬录下root@iZwz953bcwdl9hfnde2odsZ:~/Linux/lession08# gcc test.c -o test -groot@iZwz953bcwdl9hfnde2odsZ:~/Linux/lession08# gcc test.c -o test1root@iZwz953bcwdl9hfnde2odsZ:~/Linux/lession08# lltotal 68drwxr-xr-x 2 root root 4096 Dec 14 10:07 ./drwxr-xr-x 9 root root 4096 Dec 14 09:17 ../-rw-r--r-- 1 root root 310 Dec 14 09:17 bubble.cpp-rw-r--r-- 1 root root 691 Dec 14 09:17 main.cpp-rw-r--r-- 1 root root 294 Dec 14 09:17 select.cpp-rw-r--r-- 1 root root 117 Dec 14 09:17 sort.h-rwxr-xr-x 1 root root 19736 Dec 14 10:06 test*-rwxr-xr-x 1 root root 16808 Dec 14 10:07 test1*-rw-r--r-- 1 root root 657 Dec 14 09:17 test.c启动GDB调试命令root@iZwz953bcwdl9hfnde2odsZ:~/Linux/lession08# gdb test运⾏结果For help, type "help".Type "apropos word" to search for commands related to "word"...Reading symbols from test...(gdb)退出GDB调试quit/q设置获取参数(gdb) set args 10 20(gdb) show args结果Argument list to give program being debugged when it is started is "10 20".查看当前⽂件代码从当前位置往下显⽰(gdb) l1 #include <stdio.h>2 #include <stdlib.h>34 int test(int a);56 int main(int argc, char* argv[]) {7 int a, b;8 printf("argc = %d\n", argc);910 if(argc < 3) {(gdb) l11 a = 10;12 b = 30;13 } else {14 a = atoi(argv[1]);15 b = atoi(argv[2]);16 }17 printf("a = %d, b = %d\n", a, b);18 printf("a + b = %d\n", a + b);1920 for(int i = 0; i < a; ++i) {指定⾏gdb) l 116 int main(int argc, char* argv[]) {7 int a, b;8 printf("argc = %d\n", argc);910 if(argc < 3) {11 a = 10;12 b = 30;13 } else {14 a = atoi(argv[1]);15 b = atoi(argv[2]);指定函数(gdb) l main1 #include <stdio.h>2 #include <stdlib.h>34 int test(int a);56 int main(int argc, char* argv[]) {7 int a, b;8 printf("argc = %d\n", argc);910 if(argc < 3) {查看其他⽂件代码(gdb) list test.c:1056 int main(int argc, char* argv[]) {7 int a, b;8 printf("argc = %d\n", argc);910 if(argc < 3) {11 a = 10;12 b = 30;13 } else {14 a = atoi(argv[1]);(gdb) list test.c:main1 #include <stdio.h>2 #include <stdlib.h>34 int test(int a);56 int main(int argc, char* argv[]) {7 int a, b;8 printf("argc = %d\n", argc);910 if(argc < 3) {设置显⽰⾏数(gdb) show listsizeNumber of source lines gdb will list by default is 10.(gdb) set listsize 30(gdb) show listsizeNumber of source lines gdb will list by default is 30.查看断点设置断点(gdb) break 10Breakpoint 1 at 0x14c6: file main.cpp, line 11.(gdb) break mainBreakpoint 2 at 0x1481: file main.cpp, line 6.(gdb) break bubble.cpp:10Breakpoint 3 at 0x1227: file bubble.cpp, line 10.(gdb) break bubble.cpp:bubbleSortBreakpoint 4 at 0x11e9: file bubble.cpp, line 6.(gdb) i bNum Type Disp Enb Address What1 breakpoint keep y 0x00000000000014c6 in main() at main.cpp:112 breakpoint keep y 0x0000000000001481 in main() at main.cpp:63 breakpoint keep y 0x0000000000001227 in bubbleSort(int*, int) at bubble.cpp:104 breakpoint keep y 0x00000000000011e9 in bubbleSort(int*, int) at bubble.cpp:6断点意味着 执⾏到该⾏之前删除断点info/i break/b设置⽆效/有效断点dis/disable 断点编号ena/enable 断点编号条件断点b/break 10 if i==5运⾏GDB调试的程序start 停在第⼀⾏(gdb) startTemporary breakpoint 1 at 0x1481: file main.cpp, line 6.Starting program: /root/Linux/lession08/mainTemporary breakpoint 1, main () at main.cpp:66 int main() {run 遇到断点为⽌(gdb) runThe program being debugged has been started already.Start it from the beginning? (y or n) yStarting program: /root/Linux/lession08/main冒泡排序之后的数组: 12 22 27 55 67===================================Breakpoint 2, main () at main.cpp:2121 int array1[] = {25, 47, 36, 80, 11};向下执⾏next/n 向下执⾏ 不进⼊函数体(gdb) n22 len = sizeof(array1) / sizeof(int);(gdb) n24 selectSort(array1, len);(gdb) n27 cout << "选择排序之后的数组: ";(gdb) n28 for(int i = 0; i < len; i++) {(gdb) n29 cout << array1[i] << " ";step/s 进⼊函数体 运⾏结束跳出函数体 finishBreakpoint 4, main () at main.cpp:2424 selectSort(array1, len);(gdb) sselectSort (array=0x555555555690 <__libc_csu_init>, len=32767) at select.cpp:66 void selectSort(int *array, int len) {(gdb) s8 for (int j = 0; j < len - 1; j++) {(gdb) s9 for (int i = j + 1; i < len; i++) {(gdb) s10 if (array[j] > array[i]) {(gdb) s9 for (int i = j + 1; i < len; i++) {继续运⾏遇到下⼀断点 continue/c变量操作和⾃动变量操作print/p(gdb) n8 int array[] = {12, 27, 55, 22, 67};(gdb) n9 int len = sizeof(array) / sizeof(int);(gdb) n11 bubbleSort(array, len);(gdb) print array[0]$1 = 12display undisplay info/i display(gdb) display len2: len = 5(gdb) s10 if (array[j] > array[j + 1]) {1: a = {i = {0, 1045149306}, d = 1.2904777690891933e-08} 2: len = 5(gdb)其它操作循环时 设置值set var 变量名 = 变量值until 跳出循环。
Linux开发入门：使用gdb调试C_C++入门教程PPT模板
c
2-3如何 在cpp函
数断点
e
2-5获取 所有断点
f
2-6如何 启用或禁
用断点
第2章学会设置断 点
2-7如何忽略或删除断点
202x
感谢聆听
202x
linux开发入门：使用gdb调 试c/c++入门教程
演讲人
2 0 2 x - 11 - 11
目录
01. 第1章gdb基础入门 02. 第2章学会设置断点
01 第1章gdb基础入门
第1章gdb 基础入门
01
1-1如何使 用gdb
04
1-4如何查 看程序停止 哪一行代码
02
1-2如何运 行或停止程
序
05
1-ห้องสมุดไป่ตู้如何单 步调试
03
1-3程序停 下来后、如 何继续执行
06
1-6如何查 看变量的值
第1章gdb基础入 门
1-7如何修改变量的值 1-8调试过程中如何调用函数 1-9如何从函数返回
02 第2章学会设置断点
a
2-1如何 在指定行
断点
d
2-4如何 设置临时
断点
第2章学会设置断点
b
2-2如何 在函数断
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是一个强大的命令行调试工具。
大家知道命令行的强大就是在于，其可以形成执行序列，形成脚本。
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; i7 {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，从第一行开始例出原码。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
刘鹏昊
GDB简介：
调试器(例如GDB)能让你观察一个程序在执行时的内 部活动，或者程序出错时发生了什么
GDB主要能为你做四件事情：
运行你的程序，设置所有的能影响程序运行的东西 保证你的程序在指定的条件下停止 当你程序停止时，让你检查发生了什么 改变你的程序。那样你可以试着修正某个bug引起的问题，
交叉调试环境： 目标板：gdbserver :port –attach <PROCESS-ID> 调试端：target remote ip:port
停止调试： detach
GDB下运行程序
调试一个多线程的程序:
GDB会自动提示新线程创建 thread <threadno> 各线程间进行切换 info threads 查看已经存在的线程
-symbols <文件名>(-s <文件名>) 从<文件名>中读去符号
-x <文件名> 执行gdb命令，在<文件名>指定的文件中存放着一序列的gdb
命令，就象一个批处理
-directory(-d) <路径> 指定路径。把<路径>加入到搜索源文件的路径中
常用启动参数：
-quiet (-q) 安静模式，不输出介绍和版权信息
不用退出GDB就可以执行一个shell命令
make [make-args] 使用[make-args]进行make 相当于`shell make make-args'
GDB命令
命令输入技巧：
可以把一个gdb命令缩写成开头几个字母，如果这没有二意性你可以直接回车来运行。 如果有不止一个选择的话，你还可以使用TAB键让gdb给你完成接下来的键入，或向你 显示可选择的命令
GDB命令(使用help)
help [COMMAND] 列出某个命令的使用方法
complete <ARGS > 列出所有以ARGS开头的命令
‘info’ (可以缩写为‘i’)用来显示你程序的状态。比如，你可以 使用info args 列出你程序所接受的命令行参数。使用info registers列出寄存器的状态。
`pwd' 打印输出当前目录
GDB下运行程序
调试一个已经运行的程序:
attach <PROCESS-ID> 这个命令把一个已经运行的进程(在gdb外启动)连接入gdb, 以便调试。PROCESS-ID是进程号。当然要使用 ‘attach’命令的话，你的操作系统环境必须支持进程。另 外你还要有向此进程发信号的权力。
‘show’与‘info’相反，‘show’命令用来显示gdb自身的状态 例如show version显示版本号，show copying显示版权信息
GDB下运行Байду номын сангаас序
程序编译:
当你在gdb下运行程序时，你必须先为gdb准备好 带有调试信息的可执行文档。 为了高效的调试一个程序，你需要使用编译器来产 生附带调试信息的可执行代码这些调试信息存储在 目标文件中；描述了变量数据类型和函数声明，在 源文件代码行和执行代码之间建立联系。 为产生调试信息，当你使用编译器时指定'-g'选项， 就可以为你的程序产生带有调试信息的可执行代码
GDB下运行程序
调试子进程的技巧:
正常情况下，可以在子进程运行后attach即可 如果需要调试子进程在启动过程中的问题，可以采取以下方法： 父进程启动代码：
pid = fork(); if (0 == pid)
exec(“sh” “–c” “child”);
更改为 pid = fork(); if (0 == pid)
使用help
help [class] 显示某一类命令的列表
$help status Status inquiries.
List of commands:
show -- Generic command for showing things set with "set"
info -- Generic command for printing status
无论gdb何时中断了你的程序(因为一个断点或是 一个信号)，它自动选择信号或断点发生的线程 为当前线程。gdb将用一个格式为'[Switching to SYSTAG]'的消息来向你报告。
GDB下运行程序
调试多进程:
GDB对调试使用'fork'系统调用产生新进 程的程序没有很多支持。当一个程序开始 一个新进程时，GDB将继续对父进程进行 调试，子进程将不受影响的运行。如果你 在子进程可能会执行到的地方设了断点， 那么子进程将收到'SIGTRAP'信号，如果 子进程没 有对这个信号进行处理的话那么 缺省的处理就是使子进程终止。
GDB下运行程序
Run命令:
用于启动你的程序，使用命令前必须先指定你程序的名字(用 gdb的命令行参数)或使用‘file’命令，来指定文件名
工作路径：
每次用‘run’命令来运行程序时，程序将继承gdb的当前工作目 录。而gdb的工作目录是从它的父进程继承而来的(一般是shell)。 但你可以自己使用‘cd’命令指定工作目录。 gdb的工作目录就是它去寻找某些文件或信息的途径。 `cd DIRECTORY' 把gdb的工作目录设为DIRECTORY
-x <文件名> 执行gdb命令，在<文件名>指定的文件中存放着一序列的gdb
命令，就象一个批处理
-directory(-d) <路径> 指定路径。把<路径>加入到搜索源文件的路径中
结束：
quit 直接退出gdb
detach 放弃连接
Shell命令：
shell <command string> 启动一个shell执行<command string>，
exec(“sh” “–c” “gdb child”);
子进程的main函数中使用sleep进行延时，睡眠期间attach之
断点
断点的作用是当你程序运行到断点时，无 论它在做什么都会被停止下来 可以在行上，函数上，甚至在确切的地址 上设置断点
然后继续查找另一 个bug
启动：
最通常的命令就是使用一个参数： $(m68k-linux-)gdb <可执行文档名>
你还可以同时为你的执行文件指定一个core文件： $gdb <可执行文件名> core
你也可以为你要执行的文件指定一个进程号： $gdb <可执行文件名> <进程号>
常用启动参数：