精华内容
下载资源
问答
  • gdb调试

    万次阅读 2017-04-03 22:02:18
    以前经常听到别人说gdb调试,很高大尚。在日常的开发中,gdb确实很有用。gdb调试博大精深,非三言两语能说透,我们还是先从基础开始学起吧。 #include void test(int key) { int a=key; int b=a+1; int *p=NULL;...

           以前经常听到别人说gdb调试,很高大尚。在日常的开发中,gdb确实很有用。gdb调试博大精深,非三言两语能说透,我们还是先从基础开始学起吧。

     

    #include<stdio.h>
    
    void test(int key)
    {
          int a=key;
          int b=a+1;
          int *p=NULL;
          *p=5;
          printf("%d,%d",a,b);
    }
    
    int main()
    {
          int key=2;
          test(key);
          
          return 0;
    }
    
    
    

    要生成调试信息必须加上 -g 选项,不加上 -g 选项生成的core都无法调试。之前我调试core没加 -g 选项把自己坑了,所以这里一定要注意。

    生成core的2个条件:

    1.ulimit -c unlimited

    2.gcc/g++ -g

     

    bt:查看堆栈信息

    i locals:查看当前程序栈的局部变量

    i args:查看当前程序栈的参数

    i catch:查看当前程序中战帧的异常处理器

    p a:打印变量的值

    i register:查看当前寄存器的值。这个这里没有演示

    quit:退出

     

    l(list):查看程序源代码

    r(run):从运行程序至第一个断点,没有断点则一直运行完

    start:开始执行程序,停留在main函数第一行语句前等待命令

     

    s(step):执行下一条语句,有函数则进入函数中

    n(next):单步执行,不进入函数内部

     

    set var:改变变量的值

     

    finish:运行到当前函数为止,可以用来结束循环

     

    参考地址:

    http://blog.csdn.net/stpeace/article/details/51040073

    http://www.cnblogs.com/hankers/archive/2012/12/07/2806836.html

     

    展开全文
  • GDB调试

    2019-02-26 13:42:16
    2:在可以使用GDB调试程序之前,必须只用-g选项编译源文件。可在makefile中定义 CFLAGS变量: CFLAGS=-g 二:GDB使用文件的生成: 1:为了能够对程序进行调试,需要在编译的执行文件包含调试信息,在编译时候需要...

    一:GDB介绍:

    1:GDB完成的的调试任务:

    1:设置断点;

    2:监视程序变量的值;

    3:程序的单步执行;

    4:修改变量的值;

    2:在可以使用GDB调试程序之前,必须只用-g选项编译源文件。可在makefile中定义

    CFLAGS变量: CFLAGS=-g

    二:GDB使用文件的生成:

    1:为了能够对程序进行调试,需要在编译的执行文件包含调试信息,在编译时候需要指定[-g]参数;

    命令格式:cc -g -o execfile sourcefile

    例如: cc -g -o gdbtest gdbtest.c

    三:GDB程序调试:

    1:命令格式:

    gdb [options] [execfile] [corefile/processid]

    2:程序调试:

    gdb execfile processid

    (= gdb execfile + attatch processid)

    (= gdb + file execfile + attatch processid)

    3:异常调试:

    gdb execfile corefile

    (= gdb execfile + core corefile)

    (= gdb + file execfile + core corefile)

    四:GDB命令介绍:

    1:运行GDB调试程序时通常使用如下的命令:

    gdb progname

    2:在gdb提示符处键入help,将列出命令的分类,主要的分类有:

    aliases: 命令别名

    breakpoints: 断点定义

    data: 数据查看

    files: 指定并查看文件

    internals: 维护命令

    running: 程序执行

    stack: 调用栈查看

    statu: 状态查看

    tracepoints: 跟踪程序执行

    3:键入help后跟命令的分类名,可获得该类命令的详细清单:

    1:GDB程序调试(运行程序)

    RUN: 运行已加载的程序

    kill: 结束正运行的程序

    Step: 单步调试正运行的程序,运行一行源程序并进入函数内部。

    Next: 单步调试正运行的程序,运行一行源程序但不进入函数内部

    Jump: 在指定处继续运行程序

    Continue: 继续运行程序

    Finish: 运行至当前函数尾并返回

    Until: 运行至下一个地址大于当前地址的源程序行或一个指定源程序行

    2:GDB程序调试(查看栈内容)

    bt: 显示所有栈内容

    frame: 选择一栈地址并显示其中的内容

    down: 选择被当前栈所调用的栈地址并显示其中内容

    up: 选择调用当前栈得栈地址并显示其中内容

    return: 返回调用当前栈的栈地址

    3:GDB程序调试(查看数据)

    print: 显示表达式值

    set: 设置变量值

    diaplay: 在每次程序运行停止时显示表达式值

    delete display: 消除表达式显示

    x: 显示指定内存内容

    4:GDB程序调试(查看源文件)

    list:显示源文件

    dir: 定义调试程序的源文件Path

    5:GDB程序调试(设置删除断点)

    break: 设置断点

    clear: 清除断点

    watch: 设置表达式监视对象

    ignore: 设置无效的断点号

    delete: 删除断点(指定断点号)

    #info break 查看全部断点(id)

    6:GDB程序调试(查看程序环境及状态)

    cd: 改变工作目录

    shell: 执行shell命令

    pwd: 显示工作目录

    search: 在源文件中查找字符串

    info: 查看debug状态

    7:GDB程序调试(终止)

    在gdb调试环境中键入quit或ctrl-d可终止gdb调试

    注:键入ctrl-c只能终当前gdb命令返回gdb命令行

    总结:

    1、file <文件名>

    加载被调试的可执行程序文件。因为一般都在被调试程序所在目录下执行GDB,因而文本名不需要带路径。

    示例:(gdb) file gdb-sample

    2、r

    Run的简写,运行被调试的程序。如果此前没有下过断点,则执行完整个程序;如果有断点,则程序暂停在第一个可用断点处。

    示例:(gdb) r

    3、c

    Continue的简写,继续执行被调试程序,直至下一个断点或程序结束。

    示例:(gdb) c

    4、b <行号>

    b <函数名称>

    b *<函数名称>

    b *<代码地址>

    b: Breakpoint的简写,设置断点。两可以使用“行号”“函数名称”“执行地址”等方式指定断点位置。

    其中在函数名称前面加“*”符号表示将断点设置在“由编译器生成的prolog代码处”。如果不了解汇编,可以不予理会此用法。

    5、set args [parameter]

    gdb调试的时候,设置命令行参数。

    6、bt

    bt可以去查看堆栈信息。down和up和一个一个打印堆栈信息。bt直接打印全部堆栈信息。

    7、n

    单步调试

    8、s

    单步进入

    展开全文
  • gdb 调试

    千次阅读 2018-02-27 21:29:10
    GDB是一个由GNU开源组织发布的、UNIX/LINUX操作系统下的、基于命令行的、功能强大的程序调试工具。 对于一名Linux下工作的c++程序员,gdb是必不可少的工具; 1.1. 启动gdb 对C/C++程序的调试,需要在...

    原文http://linuxtools-rst.readthedocs.io/zh_CN/latest/tool/gdb.html

    **1. gdb 调试利器**
    GDB是一个由GNU开源组织发布的、UNIX/LINUX操作系统下的、基于命令行的、功能强大的程序调试工具。 对于一名Linux下工作的c++程序员,gdb是必不可少的工具;
    
    1.1. 启动gdb
    对C/C++程序的调试,需要在编译前就加上-g选项:
    
    $g++ -g hello.cpp -o hello
    调试可执行文件:
    
    $gdb <program>
    program也就是你的执行文件,一般在当前目录下。
    
    调试core文件(core是程序非法执行后core dump后产生的文件):
    
    $gdb <program> <core dump file>
    $gdb program core.11127
    调试服务程序:
    
    $gdb <program> <PID>
    $gdb hello 11127
    如果你的程序是一个服务程序,那么你可以指定这个服务程序运行时的进程ID。gdb会自动attach上去,并调试他。program应该在PATH环境变量中搜索得到。
    
    1.2. gdb交互命令
    启动gdb后,进入到交互模式,通过以下命令完成对程序的调试;注意高频使用的命令一般都会有缩写,熟练使用这些缩写命令能提高调试的效率;
    
    运行
    run:简记为 r ,其作用是运行程序,当遇到断点后,程序会在断点处停止运行,等待用户输入下一步的命令。
    continue (简写c ):继续执行,到下一个断点处(或运行结束)
    next:(简写 n),单步跟踪程序,当遇到函数调用时,也不进入此函数体;此命令同 step 的主要区别是,step 遇到用户自定义的函数,将步进到函数中去运行,而 next 则直接调用函数,不会进入到函数体内。
    step (简写s):单步调试如果有函数调用,则进入函数;与命令n不同,n是不进入调用的函数的
    until:当你厌倦了在一个循环体内单步跟踪时,这个命令可以运行程序直到退出循环体。
    until+行号: 运行至某行,不仅仅用来跳出循环
    finish: 运行程序,直到当前函数完成返回,并打印函数返回时的堆栈地址和返回值及参数值等信息。
    call 函数(参数):调用程序中可见的函数,并传递“参数”,如:call gdb_test(55)
    quit:简记为 q ,退出gdb
    设置断点
    break n (简写b n):在第n行处设置断点
    (可以带上代码路径和代码名称: b OAGUPDATE.cpp:578)
    b fn1 if a>b:条件断点设置
    break func(break缩写为b):在函数func()的入口处设置断点,如:break cb_button
    delete 断点号n:删除第n个断点
    disable 断点号n:暂停第n个断点
    enable 断点号n:开启第n个断点
    clear 行号n:清除第n行的断点
    info b (info breakpoints) :显示当前程序的断点设置情况
    delete breakpoints:清除所有断点:
    查看源代码
    list :简记为 l ,其作用就是列出程序的源代码,默认每次显示10行。
    list 行号:将显示当前文件以“行号”为中心的前后10行代码,如:list 12
    list 函数名:将显示“函数名”所在函数的源代码,如:list main
    list :不带参数,将接着上一次 list 命令的,输出下边的内容。
    打印表达式
    print 表达式:简记为 p ,其中“表达式”可以是任何当前正在被测试程序的有效表达式,比如当前正在调试C语言的程序,那么“表达式”可以是任何C语言的有效表达式,包括数字,变量甚至是函数调用。
    print a:将显示整数 a 的值
    print ++a:将把 a 中的值加1,并显示出来
    print name:将显示字符串 name 的值
    print gdb_test(22):将以整数22作为参数调用 gdb_test() 函数
    print gdb_test(a):将以变量 a 作为参数调用 gdb_test() 函数
    display 表达式:在单步运行时将非常有用,使用display命令设置一个表达式后,它将在每次单步进行指令后,紧接着输出被设置的表达式及值。如: display a
    watch 表达式:设置一个监视点,一旦被监视的“表达式”的值改变,gdb将强行终止正在被调试的程序。如: watch a
    whatis :查询变量或函数
    info function: 查询函数
    扩展info locals: 显示当前堆栈页的所有变量
    查询运行信息
    where/bt :当前运行的堆栈列表;
    bt backtrace 显示当前调用堆栈
    up/down 改变堆栈显示的深度
    set args 参数:指定运行时的参数
    show args:查看设置好的参数
    info program: 来查看程序的是否在运行,进程号,被暂停的原因。
    分割窗口
    layout:用于分割窗口,可以一边查看代码,一边测试:
    layout src:显示源代码窗口
    layout asm:显示反汇编窗口
    layout regs:显示源代码/反汇编和CPU寄存器窗口
    layout split:显示源代码和反汇编窗口
    Ctrl + L:刷新窗口
    展开全文
  • gdb调试的基本使用

    万次阅读 多人点赞 2018-04-27 00:19:27
    GDB调试 启动程序准备调试 GDB yourpram 或者 先输入GDB 然后输入 file yourpram 然后使用run或者r命令开始程序的执行,也可以使用 run parameter将参数传递给该程序 参数列表 命令 ...

    https://www.cnblogs.com/HKUI/p/8955443.html

    GDB调试
    启动程序准备调试
    GDB yourpram
    或者
    先输入GDB
    然后输入 file yourpram

    然后使用run或者r命令开始程序的执行,也可以使用 run parameter将参数传递给该程序

    参数列表

    命令

    命令缩写

    命令说明

    list

    l

    显示多行源代码

    break

    b

    设置断点,程序运行到断点的位置会停下来

    info

    i

    描述程序的状态

    run

    r

    开始运行程序

    display

    disp

    跟踪查看某个变量,每次停下来都显示它的值

    step

    s

    执行下一条语句,如果该语句为函数调用,则进入函数执行其中的第一条语句

    next

    n

    执行下一条语句,如果该语句为函数调用,不会进入函数内部执行(即不会一步步地调试函数内部语句)

    print

    p

    打印内部变量值

    continue

    c

    继续程序的运行,直到遇到下一个断点

    set var name=v

     

    设置变量的值

    start

    st

    开始执行程序,main函数的第一条语句前面停下来

    file

     

    装入需要调试的程序

    kill

    k

    终止正在调试的程序

    watch

     

    监视变量值的变化

    backtrace

    bt

    产看函数调用信息(堆栈)

    frame

    f

    查看栈帧

    quit

    q

    退出GDB环境

     

      

    复制代码
    //e.c
     #include <stdio.h>
    void debug(char *str)
    {
        printf("debug info :%s\n",str );
    }
    main(int argc,char *argv[]){
        int i,j;
        j=0;
        for(i=0;i<10;i++){
            j+=5;
            printf("now a=%d\n", j);
        }
    }
    复制代码

    gcc -g -o e e.c
    调试gdb e
    或者输入gdb
    然后 file e

    list 命令用法

    list命令显示多行源代码,从上次的位置开始显示,默认情况下,一次显示10行,第一次使用时,从代码其实位置显示

    复制代码
    gdb) list
    1    #include <stdio.h>
    2    void debug(char *str)
    3    {
    4        printf("debug info :%s\n",str );
    5    }
    6    main(int argc,char *argv[]){
    7        int i,j;
    8        j=0;
    9        for(i=0;i<10;i++){
    10            j+=5;
    (gdb) 
    复制代码

    list n显示已第n行未中心的10行代码

    复制代码
    (gdb) list 8
    3    {
    4        printf("debug info :%s\n",str );
    5    }
    6    main(int argc,char *argv[]){
    7        int i,j;
    8        j=0;
    9        for(i=0;i<10;i++){
    10            j+=5;
    11            printf("now a=%d\n", j);
    12        }
    (gdb) 
    复制代码

    list functionname显示以functionname的函数为中心的10行代码

    复制代码
    (gdb) list main
    1    #include <stdio.h>
    2    void debug(char *str)
    3    {
    4        printf("debug info :%s\n",str );
    5    }
    6    main(int argc,char *argv[]){
    7        int i,j;
    8        j=0;
    9        for(i=0;i<10;i++){
    10            j+=5;
    (gdb) 
    复制代码

    list - 显示刚才打印过的源代码之前的代码

    复制代码
    (gdb) list 10
    5    }
    6    main(int argc,char *argv[]){
    7        int i,j;
    8        j=0;
    9        for(i=0;i<10;i++){
    10            j+=5;
    11            printf("now a=%d\n", j);
    12        }
    13    }(gdb) list -
    1    #include <stdio.h>
    2    void debug(char *str)
    3    {
    4        printf("debug info :%s\n",str );
    (gdb) 
    复制代码

    断点命令break
    break location:在location位置设置断点,改位置可以为某一行,某函数名或者其它结构的地址
    GDB会在执行该位置的代码之前停下来

    复制代码
    gdb) list
    1    #include <stdio.h>
    2    void debug(char *str)
    3    {
    4        printf("debug info :%s\n",str );
    5    }
    6    main(int argc,char *argv[]){
    7        int i,j;
    8        j=0;
    9        for(i=0;i<10;i++){
    10            j+=5;
    (gdb) 
    11            printf("now a=%d\n", j);
    12        }
    13    }(gdb) break 10
    Breakpoint 1 at 0x40050a: file e.c, line 10.
    (gdb) r
    Starting program: /mnt/hgfs/www/c/gcc/e 
    
    Breakpoint 1, main (argc=1, argv=0x7fffffffe548) at e.c:10
    10            j+=5;
    (gdb) c
    Continuing.
    now a=5
    
    Breakpoint 1, main (argc=1, argv=0x7fffffffe548) at e.c:10
    10            j+=5;
    (gdb) c
    Continuing.
    now a=10
    
    Breakpoint 1, main (argc=1, argv=0x7fffffffe548) at e.c:10
    10            j+=5;
    (gdb) 
    复制代码

    使用delete breakpoints 断点号 删除断点
    这里的断点号表示的是第几个断点,刚才执行break 10返回 reakpoint 1 at 0x40050a: file e.c, line 10.
    中的1表示该断点的标号,因此使用 delete breakpoints 1表示删除第10行所定义的断点
    clear n表示清除第n行的断点,因此clear 10等同于delete breakpoints 1
    disable/enable n表示使得编号为n的断点暂时失效或有效
    可使用info查看断点相关的信息
    info breakpoints

    复制代码
    gdb) info breakpoints
    No breakpoints or watchpoints.
    (gdb) break 10
    Breakpoint 2 at 0x40050a: file e.c, line 10.
    (gdb) break 9
    Breakpoint 3 at 0x400501: file e.c, line 9.
    (gdb) info breakpoints
    Num     Type           Disp Enb Address            What
    2       breakpoint     keep y   0x000000000040050a in main at e.c:10
    3       breakpoint     keep y   0x0000000000400501 in main at e.c:9
    复制代码

    display命令
    查看参数的值

    复制代码
    (gdb) break 10
    Breakpoint 1 at 0x40050a: file e.c, line 10.
    (gdb) r
    Starting program: /mnt/hgfs/www/c/gcc/e 
    
    Breakpoint 1, main (argc=1, argv=0x7fffffffe548) at e.c:10
    10            j+=5;
    (gdb) display j
    1: j = 0
    (gdb) c
    Continuing.
    now a=5
    
    Breakpoint 1, main (argc=1, argv=0x7fffffffe548) at e.c:10
    10            j+=5;
    1: j = 5
    (gdb) display
    1: j = 5
    (gdb) display i
    2: i = 1
    (gdb) display j
    3: j = 5
    (gdb) display j*2
    4: j*2 = 10
    (gdb) info display
    Auto-display expressions now in effect:
    Num Enb Expression
    4:   y  j*2
    3:   y  j
    2:   y  i
    1:   y  j
    复制代码

    也可以使用disable,enable,delete,info命令修改及查看其状态,用法与对断点的一样

    step及next命令
    step可使得程序逐条执行,即执行完一条语句然后在吓一跳语句前停下来,等待用户的命令
    一般使用step命令是,可使用display或者watch命令查看变量的变化,从而判断程序行为是否符合要求
    当下一条指令为函数时,s进入函数内部,在其第一条语句前停下来
    step n,next n 表示连续但不执行n条指令,如果期间遇到断点,则停下来

    复制代码
    (gdb) list
    1    #include <stdio.h>
    2    void debug(char *str)
    3    {
    4        printf("debug info :%s\n",str );
    5    }
    6    
    7    main(int argc,char *argv[]){
    8        int i,j;
    9        j=0;
    10        for(i=0;i<10;i++){
    (gdb) 
    11            j+=5;
    12            printf("now j=%d\n", j);
    13            debug("x=======x");
    14        }
    15    }(gdb) 
    Line number 16 out of range; e.c has 15 lines.
    (gdb) break 11
    Breakpoint 1 at 0x40050a: file e.c, line 11.
    (gdb) r
    Starting program: /mnt/hgfs/www/c/gcc/e1 
    
    Breakpoint 1, main (argc=1, argv=0x7fffffffe538) at e.c:11
    11            j+=5;
    (gdb) s
    12            printf("now j=%d\n", j);
    (gdb) s
    __printf (format=0x400648 "now j=%d\n") at printf.c:30
    30    {
    (gdb) bt
    #0  __printf (format=0x400648 "now j=%d\n") at printf.c:30
    #1  0x0000000000400525 in main (argc=1, argv=0x7fffffffe538) at e.c:12
    (gdb) n
    34      va_start (arg, format);
    (gdb) n
    35      done = vfprintf (stdout, format, arg);
    (gdb) n
    now j=5
    39    }
    (gdb) bt
    #0  __printf (format=<value optimized out>) at printf.c:39
    #1  0x0000000000400525 in main (argc=1, argv=0x7fffffffe538) at e.c:12
    (gdb) n
    main (argc=1, argv=0x7fffffffe538) at e.c:13
    13            debug("x=======x");
    (gdb) n
    debug info :x=======x
    10        for(i=0;i<10;i++){
    (gdb) s
    
    Breakpoint 1, main (argc=1, argv=0x7fffffffe538) at e.c:11
    11            j+=5;
    (gdb) s
    12            printf("now j=%d\n", j);
    (gdb) n
    now j=10
    13            debug("x=======x");
    (gdb) n
    debug info :x=======x
    10        for(i=0;i<10;i++){
    (gdb) 
    复制代码

    watch
    watch可设置观察点(watchpoint)。使用观察点可以使得当某表达式的值发生变化时,程序暂停执行。
    执行该命令前,必须保证程序已经运行

    复制代码
    (gdb) list 
    1    #include <stdio.h>
    2    void debug(char *str)
    3    {
    4        printf("debug info :%s\n",str );
    5    }
    6    
    7    main(int argc,char *argv[]){
    8        int i,j;
    9        j=0;
    10        for(i=0;i<10;i++){
    (gdb) 
    11            j+=5;
    12            printf("now j=%d\n", j);
    13            debug("x=======x");
    14        }
    15    }(gdb) 
    Line number 16 out of range; e.c has 15 lines.
    (gdb) b main
    Breakpoint 1 at 0x4004fa: file e.c, line 9.
    (gdb) r
    Starting program: /mnt/hgfs/www/c/gcc/e1 
    
    Breakpoint 1, main (argc=1, argv=0x7fffffffe538) at e.c:9
    9        j=0;
    (gdb) watch j
    Hardware watchpoint 2: j
    (gdb) c
    Continuing.
    Hardware watchpoint 2: j
    
    Old value = 0
    New value = 5
    main (argc=1, argv=0x7fffffffe538) at e.c:12
    12            printf("now j=%d\n", j);
    (gdb) c
    Continuing.
    now j=5
    debug info :x=======x
    Hardware watchpoint 2: j
    
    Old value = 5
    New value = 10
    main (argc=1, argv=0x7fffffffe538) at e.c:12
    12            printf("now j=%d\n", j);
    复制代码

    print命令

    复制代码
    (gdb) list
    1    #include <stdio.h>
    2    void debug(char *str)
    3    {
    4        printf("debug info :%s\n",str );
    5    }
    6    
    7    main(int argc,char *argv[]){
    8        int i,j;
    9        j=0;
    10        for(i=0;i<10;i++){
    (gdb) 
    11            j+=5;
    12            printf("now j=%d\n", j);
    13            debug("x=======x");
    14        }
    15    }(gdb) 
    Line number 16 out of range; e.c has 15 lines.
    (gdb) break 12
    Breakpoint 1 at 0x40050e: file e.c, line 12.
    (gdb) r
    Starting program: /mnt/hgfs/www/c/gcc/e1 
    
    Breakpoint 1, main (argc=1, argv=0x7fffffffe538) at e.c:12
    12            printf("now j=%d\n", j);
    (gdb) p j
    $1 = 5
    (gdb) c
    Continuing.
    now j=5
    debug info :x=======x
    
    Breakpoint 1, main (argc=1, argv=0x7fffffffe538) at e.c:12
    12            printf("now j=%d\n", j);
    (gdb) p i,j
    $2 = 10
    (gdb) p j
    $3 = 10
    (gdb) 
    复制代码

    set var name=value
    在程序运行中动态改变变量的值

    复制代码
    (gdb) list
    1    #include <stdio.h>
    2    void debug(char *str)
    3    {
    4        printf("debug info :%s\n",str );
    5    }
    6    
    7    main(int argc,char *argv[]){
    8        int i,j;
    9        j=0;
    10        for(i=0;i<10;i++){
    (gdb) 
    11            j+=5;
    12            printf("now j=%d\n", j);
    13            debug("x=======x");
    14        }
    15    }(gdb) 
    Line number 16 out of range; e.c has 15 lines.
    (gdb) break main
    Breakpoint 1 at 0x4004fa: file e.c, line 9.
    (gdb) r
    Starting program: /mnt/hgfs/www/c/gcc/e1 
    
    Breakpoint 1, main (argc=1, argv=0x7fffffffe538) at e.c:9
    9        j=0;
    (gdb) watch i
    Hardware watchpoint 2: i
    (gdb) watch j
    Hardware watchpoint 3: j
    (gdb) c
    Continuing.
    Hardware watchpoint 3: j
    
    Old value = 0
    New value = 5
    main (argc=1, argv=0x7fffffffe538) at e.c:12
    12            printf("now j=%d\n", j);
    (gdb) c
    Continuing.
    now j=5
    debug info :x=======x
    Hardware watchpoint 2: i
    
    Old value = 0
    New value = 1
    0x0000000000400533 in main (argc=1, argv=0x7fffffffe538) at e.c:10
    10        for(i=0;i<10;i++){
    (gdb) c
    Continuing.
    Hardware watchpoint 3: j
    
    Old value = 5
    New value = 10
    main (argc=1, argv=0x7fffffffe538) at e.c:12
    12            printf("now j=%d\n", j);
    (gdb) c
    Continuing.
    now j=10
    debug info :x=======x
    Hardware watchpoint 2: i
    
    Old value = 1
    New value = 2
    0x0000000000400533 in main (argc=1, argv=0x7fffffffe538) at e.c:10
    10        for(i=0;i<10;i++){
    (gdb) c
    Continuing.
    Hardware watchpoint 3: j
    
    Old value = 10
    New value = 15
    main (argc=1, argv=0x7fffffffe538) at e.c:12
    12            printf("now j=%d\n", j);
    (gdb) c
    Continuing.
    now j=15
    debug info :x=======x
    Hardware watchpoint 2: i
    
    Old value = 2
    New value = 3
    0x0000000000400533 in main (argc=1, argv=0x7fffffffe538) at e.c:10
    10        for(i=0;i<10;i++){
    (gdb) c
    Continuing.
    Hardware watchpoint 3: j
    
    Old value = 15
    New value = 20
    main (argc=1, argv=0x7fffffffe538) at e.c:12
    12            printf("now j=%d\n", j);
    (gdb) c
    Continuing.
    now j=20
    debug info :x=======x
    Hardware watchpoint 2: i
    
    Old value = 3
    New value = 4
    0x0000000000400533 in main (argc=1, argv=0x7fffffffe538) at e.c:10
    10        for(i=0;i<10;i++){
    (gdb) set var i=8
    (gdb) c
    Continuing.
    Hardware watchpoint 3: j
    
    Old value = 20
    New value = 25
    main (argc=1, argv=0x7fffffffe538) at e.c:12
    12            printf("now j=%d\n", j);
    (gdb) c
    Continuing.
    now j=25
    debug info :x=======x
    Hardware watchpoint 2: i
    
    Old value = 8
    New value = 9
    0x0000000000400533 in main (argc=1, argv=0x7fffffffe538) at e.c:10
    10        for(i=0;i<10;i++){
    (gdb) c
    Continuing.
    Hardware watchpoint 3: j
    
    Old value = 25
    New value = 30
    main (argc=1, argv=0x7fffffffe538) at e.c:12
    12            printf("now j=%d\n", j);
    (gdb) c
    Continuing.
    now j=30
    debug info :x=======x
    Hardware watchpoint 2: i
    
    Old value = 9
    New value = 10
    0x0000000000400533 in main (argc=1, argv=0x7fffffffe538) at e.c:10
    10        for(i=0;i<10;i++){
    (gdb) c
    Continuing.
    
    Watchpoint 2 deleted because the program has left the block in
    which its expression is valid.
    
    Watchpoint 3 deleted because the program has left the block in
    which its expression is valid.
    __libc_start_main (main=0x4004eb <main>, argc=1, ubp_av=0x7fffffffe538, init=<value optimized out>, fini=<value optimized out>, rtld_fini=<value optimized out>, 
        stack_end=0x7fffffffe528) at libc-start.c:258
    258      exit (result);
    (gdb) c
    Continuing.
    
    Program exited with code 026.
    复制代码

    函数调用相关的
    backtrace
    可使用frame 查看堆栈中某一帧的信息

    复制代码
    (gdb) list
    1    #include <stdio.h>
    2    void debug(char *str)
    3    {
    4        printf("debug info :%s\n",str );
    5    }
    6    
    7    main(int argc,char *argv[]){
    8        int i,j;
    9        j=0;
    10        for(i=0;i<10;i++){
    (gdb) 
    11            j+=5;
    12            printf("now j=%d\n", j);
    13            debug("x=======x");
    14        }
    15    }(gdb) 
    Line number 16 out of range; e.c has 15 lines.
    (gdb) b 13
    Breakpoint 1 at 0x400525: file e.c, line 13.
    (gdb) r
    Starting program: /mnt/hgfs/www/c/gcc/e1 
    now j=5
    
    Breakpoint 1, main (argc=1, argv=0x7fffffffe538) at e.c:13
    13            debug("x=======x");
    (gdb) s
    debug (str=0x400652 "x=======x") at e.c:4
    4        printf("debug info :%s\n",str );
    (gdb) bt
    #0  debug (str=0x400652 "x=======x") at e.c:4
    #1  0x000000000040052f in main (argc=1, argv=0x7fffffffe538) at e.c:13
    (gdb) s
    __printf (format=0x400638 "debug info :%s\n") at printf.c:30
    30    {
    (gdb) bt
    #0  __printf (format=0x400638 "debug info :%s\n") at printf.c:30
    #1  0x00000000004004e9 in debug (str=0x400652 "x=======x") at e.c:4
    #2  0x000000000040052f in main (argc=1, argv=0x7fffffffe538) at e.c:13
    (gdb) s
    34      va_start (arg, format);
    (gdb) bt
    #0  __printf (format=0x400638 "debug info :%s\n") at printf.c:34
    #1  0x00000000004004e9 in debug (str=0x400652 "x=======x") at e.c:4
    #2  0x000000000040052f in main (argc=1, argv=0x7fffffffe538) at e.c:13
    (gdb) s
    35      done = vfprintf (stdout, format, arg);
    (gdb) s
    _IO_vfprintf_internal (s=0x333a58f040, format=0x400638 "debug info :%s\n", ap=0x7fffffffe330) at vfprintf.c:236
    236      int save_errno = errno;
    (gdb) bt
    #0  _IO_vfprintf_internal (s=0x333a58f040, format=0x400638 "debug info :%s\n", ap=0x7fffffffe330) at vfprintf.c:236
    #1  0x000000333a24effa in __printf (format=<value optimized out>) at printf.c:35
    #2  0x00000000004004e9 in debug (str=0x400652 "x=======x") at e.c:4
    #3  0x000000000040052f in main (argc=1, argv=0x7fffffffe538) at e.c:13
    (gdb) c
    Continuing.
    debug info :x=======x
    now j=10
    
    Breakpoint 1, main (argc=1, argv=0x7fffffffe538) at e.c:13
    13            debug("x=======x");
    (gdb) bt
    #0  main (argc=1, argv=0x7fffffffe538) at e.c:13
    复制代码

    展开全文
  • GDB 调试

    2017-10-20 13:50:01
    GDB 是一个功能强大的调试器,也是 Linux 系统中默认的调试器。GDB 主要提供以下四种功能,这些功能可以方便我们定位程序的 BUG。 启动程序 设置断点 检查程序运行状态,例如查看变量的值 修改程序运行状态,例如...
  • GDB调试入门

    万次阅读 2017-12-01 17:47:09
    gdb -q:不显示开始的提示信息可以在.bashrc中加入alias gdb="gdb -q -tui"开始调试执行run(需要提前设置断点),也可以在调试过程中重新运行调试的程序,run后可以跟随发给该程序的任何参数。常用命令 命令 功能...
  • 最近使用多线程,老是出现未知错误,比如程序死锁,或者线程突然挂掉,由于是多线程编程,单纯使用cout找不到出错点,只有学好gdb调试才能解决问题. 首先参考https://blog.csdn.net/liigo/article/details/582231 ...
  • gdb调试详解

    2019-05-04 19:04:58
    一、gdb调试coredump文件 二、gdb调试多线程       【Note】:

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 24,296
精华内容 9,718
关键字:

gdb调试