以前经常听到别人说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介绍：

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

单步进入

原文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：刷新窗口

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