利用GDB调试器调试C程序详细图解
GDB调试简易教程
设置断点(break point)
`break ... if COND` 条件断点，当表达式COND非零时程序在断 点停止 例如`break 253 if i=10` `tbreak …` 设置一个只会停止一次的断点
设置观察点(watch point)
`watch EXPR` 为EXPR设置一个观察点，一旦EXPR被写入并发生变化，程 序停止 `rwatch EXPR` EXPR被读取时，程序停止 `awatch EXPR` EXPR被读取或者被写入时，程序停止 当程序运行到EXPR作用域以外的地方时，GDB将会自动删 除此观察点，如果想继续观察，必须重新设置观察点。
启动：
最通常的命令就是使用一个参数： $(m68k-linux-)gdb <可执行文档名> 你还可以同时为你的执行文件指定一个core文件： $gdb <可执行文件名> core 你也可以为你要执行的文件指定一个进程号：
$gdb <可执行文件名> <进程号>
常用启动参数：
-symbols <文件名>(-s <文件名>) 从<文件名>中读去符号 -x <文件名> 执行gdb命令，在<文件名>指定的文件中存放着一序列的gdb 命令，就象一个批处理 -directory(-d) <路径> 指定路径。把<路径>加入到搜索源文件的路径中
程序的恢复与单步调试
finish 运行程序，直到当前函数完成并返回，打印函数返回时的堆 栈地址和返回值及参数值等信息 until [location] 简写为u，继续运行程序直至跳出当前正在单步调试的循环体； 加参数表示继续运行到代码的location处或者当前stack frame返回
实例—使用gdb调试器
2.4 实例—使用gdb调试器1．编写实例程序gcctest.c，见2.2小节的开头部分2．编译3．启动GDB，执行程序启动gdb，进入gdb调试环境，可以使用gdb的命令对程序进行调试。
[root@localhost gdbtest txt]# gdb //启动gdbGNU gdb Fedora (6.8-27.el5)Copyright (C) 2008 Free Software Foundation, Inc.License GPLv3+: GNU GPL version 3 or later </licenses/gpl.html>This is free software: you are free to change and redistribute it.There is NO WARRANTY, to the extent permitted by law. Type "show copying"and "show warranty" for details.This GDB was configured as "i386-redhat-linux-gnu".(gdb) run gcctest //在gdb中，运行程序使用r或是run命令，注意，gcctest没有调试信息Starting program: gcctestNo executable file specified.Use the "file" or "exec-file" command. //要使用file或exec-file命令指出要运行的程序(gdb) file gcctest //使用file命令指出要运行的程序gcctest，注意，对gdb命令也可以使用Tab gcctest gcctest.c gcctestg(gdb) file gcctest //使用file命令指出要运行的程序gcctestReading symbols from /root/Desktop/gdbtest txt/gcctest...(no debugging symbols found)...done.(gdb) r //在gdb中，运行程序使用r或是run命令Starting program: /root/Desktop/gdbtest txt/gcctest gcctest(no debugging symbols found)(no debugging symbols found)(no debugging symbols found)hello in mainhello 1hello 2sum=54125560035401396161080590579269632.000000Program exited with code 057.(gdb) file gcctestg //使用file命令指出要运行的程序gcctestgReading symbols from /root/Desktop/gdbtest txt/gcctestg...done.(gdb) r //在gdb中，运行程序使用r或是run命令Starting program: /root/Desktop/gdbtest txt/gcctestg gcctesthello in mainhello 1hello 2sum=54125560035401396161080590579269632.000000Program exited with code 057.(gdb) q //使用q或是quit命令退出gdb[root@localhost gdbtest txt]#4．GDB命令简介support -- 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 files //使用help <class>命令查看files类中的命令Specifying and examining files.List of commands:add-shared-symbol-files -- Load the symbols from shared objects in the dynamic linker's link mapadd-symbol-file -- Load symbols from FILEadd-symbol-file-from-memory -- Load the symbols out of memory from a dynamically loaded object filecd -- Set working directory to DIR for debugger and program being debuggedcore-file -- Use FILE as core dump for examining memory and registersdirectory -- Add directory DIR to beginning of search path for source filesedit -- Edit specified file or functionexec-file -- Use FILE as program for getting contents of pure memoryfile -- Use FILE as program to be debuggedforward-search -- Search for regular expression (see regex(3)) from last line listedgenerate-core-file -- Save a core file with the current state of the debugged processlist -- List specified function or lineload -- Dynamically load FILE into the running programnosharedlibrary -- Unload all shared object library symbolspath -- Add directory DIR(s) to beginning of search path for object filespwd -- Print working directoryremote -- Manipulate files on the remote systemremote delete -- Delete a remote fileremote get -- Copy a remote file to the local systemremote put -- Copy a local file to the remote system---Type <return> to continue, or q <return> to quit--- //一屏显示不完，敲回车键显示后面的内容reverse-search -- Search backward for regular expression (see regex(3)) from last line listedsearch -- Search for regular expression (see regex(3)) from last line listedsection -- Change the base address of section SECTION of the exec file to ADDRsharedlibrary -- Load shared object library symbols for files matching REGEXPsymbol-file -- Load symbol table from executable file FILEType "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)5．显示源代码(gdb) file gcctestg //使用file命令指出要运行的程序gcctestgLoad new symbol table from "/root/Desktop/gdbtest txt/gcctestg"? (y or n) yReading symbols from /root/Desktop/gdbtest txt/gcctestg...done.(gdb) list //显示当前行后面的源程序1 #include <stdio.h>23 void print_hello1(char *p_str);4 void print_hello2(char *p_str);56 int main(int argc,char **argv)7 {8 double i,sum=0;9 char *pstr="hello in main";10 int arr[]={1,2,3,4,5};(gdb) list //显示当前行后面的源程序11 printf("%s\n",pstr);12 print_hello1("hello 1");13 print_hello2("hello 2");1415 for(i=1; i<=1020000020.01*1020000020.01*10100020.01*10100020.00202; i=i*1.0000016)16 sum=sum/1.0201809902203*1.000102101203*1.00006605+i*10.01016/1.0005;17 printf("sum=%f\n",sum);18 }1920 void print_hello1(char *p_str)(gdb) //敲回车键，继续执行list命令，显示当前行后面的源程序21 {22 printf("%s\n",p_str);23 }2425 void print_hello2(char *p_str)26 {27 printf("%s\n",p_str);28 }(gdb) list 8 //显示程序第8行的周围的源程序3 void print_hello1(char *p_str);4 void print_hello2(char *p_str);56 int main(int argc,char **argv)7 {8 double i,sum=0;9 char *pstr="hello in main";10 int arr[]={1,2,3,4,5};11 printf("%s\n",pstr);12 print_hello1("hello 1");(gdb) list 6,10 //显示程序第6-10行的源程序6 int main(int argc,char **argv)7 {8 double i,sum=0;9 char *pstr="hello in main";10 int arr[]={1,2,3,4,5};(gdb)gdb可以显示调试程序（编译程序时一定要加上-g参数，把源程序信息编译到执行文件中）的源代码。
多进程 多线程调试方法 GDB调试 .
[root@tivf09 root]# ps -ef|grep -i vnc
root 19609 1 0 Jun05 ?
00:08:46 Xvnc :1 -desktop
tivf09:1 (root)
-httpd /usr/share/vnc/classes -auth /root/.Xauthority
-geometry 1024x768
-depth 16 -rfbwait 30000 -rfbauth /root/.vnc/passwd -rfbport
5901 -pn
root 19627 1 0 Jun05 ?
00:00:00 vncconfig
-iconic
root 12714 10599 0 01:23 pts/0 00:00:00 grep -i vnc
Attach 子进程
众所周知，GDB 有附着（attach）到正在运行的进程的功能，即 attach <pid>命令。因此我们可以利用该命令 attach 到子进程然后进行调试。
例如我们要调试某个进程 RIM_Oracle_Agent.9i，首先得到该进程的 pid
[root@tivf09 tianq]# ps -ef|grep RIM_Oracle_Agent.9i
3、GDB wrapper 方法：专用于 fork+exec 模式，不用添加额外代码， 但需要 X 环境支持（xterm/VNC）这种方式没有使用过，一般对于企业 开发的话是不是很多都没有 x 环境支持的吧（猜测:)）
follow-fork-mode 方式比较简单，通过 set follow-fork-mode child | parent 来觉得跟踪 child 还是 parent，然后可以设置断点跟踪了
gdb调试案例
gdb调试案例以GDB调试案例为题，我将列举以下10个案例，每个案例将描述GDB的使用场景、调试目标、具体步骤和调试结果，以帮助读者更好地理解和掌握GDB调试工具。
案例一：查看程序崩溃的原因场景：当程序崩溃时，我们需要找出崩溃的原因，以便修复程序中的bug。
目标：在程序崩溃时，使用GDB查看崩溃的原因。
步骤：1. 使用-g选项编译程序，以包含调试信息。
2. 执行gdb命令，加载可执行文件。
3. 在GDB中运行程序，当程序崩溃时，GDB会自动停止程序的执行。
4. 使用backtrace命令查看调用栈，找出导致崩溃的函数和行号。
5. 使用print命令查看变量的值，以便进一步分析崩溃原因。
结果：通过查看调用栈和变量的值，我们可以定位到导致程序崩溃的具体代码行，并进行修复。
案例二：设置断点并跟踪程序执行场景：当程序运行过程中出现问题，我们需要跟踪程序的执行过程，以便找出问题所在。
目标：使用GDB设置断点并跟踪程序执行。
步骤：1. 使用-g选项编译程序，以包含调试信息。
2. 执行gdb命令，加载可执行文件。
3. 使用break命令设置断点，可以选择在特定函数或行号上设置断点。
4. 运行程序，GDB会在断点处停止程序的执行。
5. 使用step命令逐行执行程序，并查看变量的值。
6. 使用continue命令继续程序的执行，直到下一个断点或程序结束。
结果：通过设置断点和逐行执行程序，我们可以跟踪程序的执行过程，找出问题所在。
案例三：查看内存信息场景：当程序出现内存相关的问题时，我们需要查看程序的内存使用情况，以便分析问题所在。
目标：使用GDB查看程序的内存信息。
步骤：1. 使用-g选项编译程序，以包含调试信息。
2. 执行gdb命令，加载可执行文件。
3. 运行程序，GDB会自动停止程序的执行。
4. 使用info breakpoints命令查看已设置的断点。
5. 使用info registers命令查看寄存器的值。
经典的GDB调试命令，包括查看变量，查看内存
经典的GDB调试命令，包括查看变量，查看内存经典的GDB调试命令，包括查看变量，查看内存在你调试程序时，当程序被停住时，你可以使⽤print命令（简写命令为p），或是同义命令inspect来查看当前程序的运⾏数据。
print命令的格式是：printprint /是表达式，是你所调试的程序的语⾔的表达式（GDB可以调试多种编程语⾔），是输出的格式，⽐如，如果要把表达式按16进制的格式输出，那么就是/x。
⼀、表达式print和许多GDB的命令⼀样，可以接受⼀个表达式，GDB会根据当前的程序运⾏的数据来计算这个表达式，既然是表达式，那么就可以是当前程序运⾏中的const常量、变量、函数等内容。
可惜的是GDB不能使⽤你在程序中所定义的宏。
表达式的语法应该是当前所调试的语⾔的语法，由于C/C++是⼀种⼤众型的语⾔，所以，本⽂中的例⼦都是关于C/C++的。
（⽽关于⽤GDB 调试其它语⾔的章节，我将在后⾯介绍）在表达式中，有⼏种GDB所⽀持的操作符，它们可以⽤在任何⼀种语⾔中。
@是⼀个和数组有关的操作符，在后⾯会有更详细的说明。
::指定⼀个在⽂件或是⼀个函数中的变量。
{}表⽰⼀个指向内存地址的类型为type的⼀个对象。
⼆、程序变量在GDB中，你可以随时查看以下三种变量的值：1. 全局变量（所有⽂件可见的）2. 静态全局变量（当前⽂件可见的）3. 局部变量（当前Scope可见的）如果你的局部变量和全局变量发⽣冲突（也就是重名），⼀般情况下是局部变量会隐藏全局变量，也就是说，如果⼀个全局变量和⼀个函数中的局部变量同名时，如果当前停⽌点在函数中，⽤print显⽰出的变量的值会是函数中的局部变量的值。
如果此时你想查看全局变量的值时，你可以使⽤::操作符：file::variablefunction::variable可以通过这种形式指定你所想查看的变量，是哪个⽂件中的或是哪个函数中的。
例如，查看⽂件f2.c中的全局变量x的值：gdb) p 'f2.c'::x当然，::操作符会和C++中的发⽣冲突，GDB能⾃动识别::是否C++的操作符，所以你不必担⼼在调试C++程序时会出现异常。
GDB单步调试程序
GDB单步调试程序GDB单步调试程序单步调试，就是通过⼀⾏⼀⾏的执⾏程序，观察整个程序的执⾏流程，进⽽尝试发现⼀些存在的异常或者 Bug。
借助 next 命令可以控制GDB 单步执⾏程序。
GDB 调试器共提供了 3 种可实现单步调试程序的⽅法，即使⽤ next、step 和 until 命令。
这 3 个命令都可以控制 GDB 调试器每次仅执⾏ 1 ⾏代码，但除此之外，它们各⾃还有不同的功能。
下⾯以⼀个C程序来分别介绍三个命令，功能是根据⽤户输⼊的 num 值，输出 12+22+...+num2的值。
代码如下：#include <stdio.h>int print(int num){int ret = num * num;return ret;}int myfunc(int num){int i = 1;int sum = 0;while(i <= num){sum += print(i);i++;}return sum;}int main(){int num =0;scanf("%d", &num);int result = myfunc(num);printf("%d", result);return0;}GDB next命令next 是最常⽤来进⾏单步调试的命令，其最⼤的特点是当遇到包含调⽤函数的语句时，⽆论函数内部包含多少⾏代码，next 指令都会⼀步执⾏完。
也就是说，对于调⽤的函数来说，next 命令只会将其视作⼀⾏代码。
next 命令可以缩写为 n 命令，使⽤⽅法也很简单，语法格式如下：(gdb) next count参数 count 表⽰单步执⾏多少⾏代码，默认为 1 ⾏。
⽰例：可以看到，当程序单步执⾏第 18 ⾏时，继续执⾏ next 指令，下⼀次将要执⾏的是第 19 ⾏代码，⽽⾮ myfunc() 函数内部的代码。
(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 命令分类详解一:列文件清单。
python import gdb用法
python import gdb用法在Python中，gdb通常是指GNU调试器（GNU Debugger），它是一种强大的调试工具，可以用来调试C、C++等程序。
Python中的gdb模块允许你使用Python来控制GDB，从而实现对C/C++程序的调试。
要使用Python的gdb模块，你需要在运行Python代码之前先安装GDB。
安装GDB的方法取决于你的操作系统。
以下是一个简单的示例，展示如何使用Python的gdb模块来调试一个C 程序：首先，编写一个简单的C程序。
例如，创建一个名为example.c的文件，并输入以下代码：c#include <stdio.h>int main() {int a = 5;int b = 0;int c = a / b;printf("The result is %d\n", c);return 0;}接下来，打开终端，编译这个C程序，并使用GDB启动它：gcc example.c -g -o example # 编译C程序，并启用调试信息gdb example # 启动GDB在GDB中，使用以下命令加载Python解释器：(gdb) python import gdb然后，你可以使用Python代码来控制GDB。
例如，你可以设置断点：python(gdb) python gdb.Breakpoints().set_break(0, 3) # 在第3行设置断点接下来，使用GDB的命令来开始执行程序：(gdb) run # 开始执行程序，当到达断点时会停止现在，你可以使用Python代码来检查变量的值、打印输出等：python(gdb) python print(c) # 打印变量c的值最后，使用GDB的命令来继续执行程序：(gdb) continue # 继续执行程序，直到下一个断点或程序结束。
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（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调试方法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”。
linux系统调试工具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使用说明1、简介GDB（GNU调试器）是一个功能强大的开源调试工具，用于调试C、C++、Fortran等编程语言的程序。
本文档将提供详细的GDB使用说明，包括安装、启动、基本命令以及高级功能的介绍。
2、安装a) 在Linux上安装GDB：在终端中运行以下命令安装GDB：```sudo apt-get install gdb```b) 在Windows上安装GDB：从GDB官方网站最新的Windows 安装包，并按照安装向导进行安装。
3、启动GDBa) 在Linux上启动GDB：在终端中运行以下命令启动GDB：```gdb [可执行文件名]```b) 在Windows上启动GDB：在命令提示符中切换到GDB的安装目录，然后执行以下命令启动GDB：```gdb：exe [可执行文件名]```4、基本命令a) 运行程序- `run`：开始执行程序。
- `r`：运行程序的简写形式。
b) 设置断点- `break [行号]`：在指定行号设置断点。
- `b [行号]`：设置断点的简写形式。
- `break [函数名]`：在指定函数设置断点。
- `b [函数名]`：设置断点的简写形式。
c) 单步执行- `next`：执行下一行语句。
- `n`：`next`命令的简写形式。
- `step`：进入函数内部执行。
- `s`：`step`命令的简写形式。
d) 打印变量- `print [变量名]`：打印指定变量的值。
- `p [变量名]`：`print`命令的简写形式。
e) 查看栈信息- `bt`：查看完整的栈回溯信息。
- `backtrace`：`bt`命令的完整形式。
f) 调试多线程程序- `info threads`：查看线程信息。
- `thread [线程号]`：切换到指定线程。
5、高级功能a) 控制程序的执行- `continue`：从当前位置继续执行程序。
- `c`：`continue`命令的简写形式。
gdb编译和调试命令
编译和调试是软件开发过程中的重要步骤，尤其是在使用GDB （GNU调试器）时。
以下是一些基本的GDB编译和调试命令：1.编译：2.1.使用gcc编译器进行编译。
例如，如果你有一个名为main.c的源文件，你可以使用以下命令进行编译：复制代码`gcc -g main.c -o main`1.-g选项告诉编译器生成调试信息。
3.启动GDB并加载程序：4.1.使用GDB启动程序：复制代码`gdb ./main`5.设置断点：6.1.在函数或代码行上设置断点，以便在程序执行到该点时停止：复制代码css`break main.c:10`7.运行程序：8.1.使用run命令启动程序：复制代码`run`9.查看变量值：10.1.在程序暂停时，使用print命令查看变量的值：复制代码`print variable_name`11.步进：12.1.执行下一行代码：复制代码css`next`或`n`1.进入函数或子例程：复制代码css`step`或`s`13.跳过函数：14.1.跳过当前函数并执行下一行代码：复制代码css`finish`或`f`15.继续执行直到下一个断点：16.1.使用continue或c命令。
如果你想在到达断点之前停止程序，可以使用until命令。
17.查看调用栈：18.•使用where或简写的w命令查看调用栈。
这显示了当前位置的函数调用序列。
1.退出GDB：使用quit命令退出GDB。
也可以使用简写形式q。
2.查看源代码：在GDB中，可以使用list命令（简写为l)查看当前行的前后代码。
也可以使用文件名和行号来查看特定代码的上下文。
例如，要查看main.c文件的第10行代码，可以使用以下命令：kotlin复制代码list main.c:10。
gdb调试命令
gdb调试命令 gdb是⼀个在UNIX环境下的命令⾏调试⼯具。
如果需要使⽤gdb调试程序，请在gcc时加上-g选项。
下⾯的命令部分是简化版，⽐如使⽤l代替list等等。
1.基本命令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 设置捕捉点来补捉程序运⾏时的⼀些事件。
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.。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
利用GDB调试器调试C程序详细图解
一、利用GDB调试器对C程序进行调试。
1、在Linux终端下，利用命令行将当前目录切换到/usr、并在此路径下新建文件夹gdb_src，在目录/usr/gdb_src下编辑C语言源程序GDB_test.c，具体指令如图1：
图1
2、C语言源程序GDB_test.c内容如图2：
图2
3、在程序编译时加入调试选项-g，表明使用GDB调试器对上述程序进行调试，命令如图3：
图3
4、启动GDB，开始程序的调试，命令如图4：
图4
5、使用指令“list”显示源代码，l相当于list指令，如图5：
图5
6、在源程序中第10行设置断点，如图6：
图6
7、在源程序中print函数处设置断点，如图7：
图7
8、使用“info”指令显示断点信息，如图8：
图8
9、使用“run”指令运行程序，r相当于run指令，如图8：
图9
10、程序在第一个断点处停止，使用“next”指令单步运行程序，n相当于next 指令，如图10：
图10
11、再使用“next”指令单步运行程序，如图11：
图11
12、使用“print”指令输出变量i的值，如图12：
图12
13、使用“continue”指令让程序继续执行，c相当于continue，如图13：
图13
14、再使用“continue”指令让程序继续执行，程序运行结束，如图13：
图14
15、退出GDB调试器，如图15：
图15
二、利用GDB调试器对下列程序进行调试，找出程序错误之处，
并改正、运行，在屏幕上显示出正确结果，要求将在Linux 的终端中的调试过程屏幕截图以供验收。
1、原程序指令如图1：
图1
参考资料：
1、Linux包含一个叫GDB的GNU调试程序，GDB是一个用来调试C和C++语言程
序的调试器，并能在程序运行时观察程序的内部结构和内存的使用情况，具体GDB基本命令见文档“GDB基本命令集”；
2、一般来说，GDB提供如下功能：
（1） 启动程序，按照程序员自定义的要求运行程序；
（2） 单步执行、设置断点，以使程序在指定的断点代码上停止执行；
（3） 监视程序中变量的值和其他发生的事情；
（4） 动态改变程序的执行环境。
3、可以通过help <command>来查看某个命令的具体信息。