《调用GDB调试器的几种方式》一节中提到，借助 next 命令可以控制 GDB 单步执行程序。所谓单步调试，就是通过一行一行的执行程序，观察整个程序的执行流程，进而尝试发现一些存在的异常或者 Bug。

根据实际场景的需要，GDB 调试器共提供了 3 种可实现单步调试程序的方法，即使用 next、step 和 until 命令。换句话说，这 3 个命令都可以控制 GDB 调试器每次仅执行 1 行代码，但除此之外，它们各自还有不同的功能。

本节就来一一给大家讲解这 3 个命令的功能和用法。讲解过程中，将以调试如下 C 语言程序为例：

  1. #include <stdio.h>
  3. // print函数
  4. int print(int num) {
  5.     int ret = num * num;
  6.     return ret;
  7. }
  9. // myfunc函数
  10. int myfunc(int num){
  11.     int i = 1;
  12.     int sum = 0;
  13.     while(i <= num){
  14.         sum += print(i);
  15.         i++;
  16.     }
  17.     return sum;
  18. }
  20. // main函数
  21. int main() {
  22.     int num =0;
  23.     scanf("%d", &num);
  24.     int result = myfunc(num);
  25.     printf("%d", result);
  26.     return 0;
  27. }

此程序存储在 ~/demo/main.c源文件中（~ 表示当前用户的主目录），功能是根据用户输入的 num 值，输出 12+22+…+num2 的值。

GDB next 命令

next 是最常用来进行单步调试的命令，其最大的特点是当遇到包含调用函数的语句时，无论函数内部包含多少行代码，next 指令都会一步执行完。也就是说，对于调用的函数来说，**next** 命令只会将其视作一行代码。

next 命令可以缩写为 n 命令，使用方法也很简单，语法格式如下：

  1. (gdb) next count

参数 count 表示单步执行多少行代码，默认为 1 行。

举个例子：

  1. (gdb) b 16
  2. Breakpoint 2 at 0x40058b: file main.c, line 16.
  3. (gdb) r
  4. Starting program: /root/demo/main.exe
  6. Breakpoint 2, main () at main.c:16
  7. 16     int num =0;
  8. (gdb) n 2                               <-- 单步执行 2 次
  9. 3
  10. 18     int result = myfunc(num);
  11. (gdb) n
  12. 19     printf("%d", result);
  13. (gdb) n
  14. 20     return 0;
  15. (gdb)

可以看到，当程序单步执行第 18 行时，继续执行 next 指令，下一次将要执行的是第 19 行代码，而非 myfunc() 函数内部的代码。

GDB step命令

通常情况下，step 命令和 next 命令的功能相同，都是单步执行程序。不同之处在于，当 **step** 命令所执行的代码行中包含函数时，会进入该函数内部，并在函数第一行代码处停止执行。

step 命令可以缩写为 s 命令，用法和 next 命令相同，语法格式如下：

  1. (gdb) step count

参数 count 表示一次执行的行数，默认为 1 行。

仍以 main.exe 为例

  1. (gdb) b 18
  2. Breakpoint 1 at 0x4005ab: file main.c, line 18.
  3. (gdb) r
  4. Starting program: ~/demo/main.exe
  5. Breakpoint 1, main () at main.c:18
  6. 18     int result = myfunc(num);
  7. (gdb) step                                         <-- step 命令进入 myfunc() 函数内部执行
  8. myfunc (num=0) at main.c:7
  9. 7     int i = 1;

可以看到，当程序暂停到包含 mufunc() 函数的代码行处时（此时该行代码尚未执行），如果使用 step 命令，则 GDB 在执行该函数代码的同时，会进入 mufunc() 函数内部，并暂停在函数内部的第一行代码处。反之如果使用 next 命令，则程序下一次会执行第 19 行代码，而不是第 7 行，这就是它们最大的不同之处。

GDB until命令

until 命令可以简写为 u 命令，有 2 种语法格式，如下所示：

  1. (gdb) until                        # 格式1
  2. (gdb) until location            # 格式2

其中，参数 location 为某一行代码的行号。

不带参数的 until 命令，可以使 GDB 调试器快速运行完当前的循环体，并运行至循环体外停止。注意，until 命令并非任何情况下都会发挥这个作用，只有当执行至循环体尾部（最后一行代码）时，until命令才会发生此作用；反之，until 命令和 next 命令的功能一样，只是单步执行程序。

以 main.exe 中 myfunc() 函数的循环为例：

  1. (gdb) b 17
  2. Breakpoint 1 at 0x1201: file main.c, line 17.
  3. (gdb) r
  4. Starting program: ~/demo/main.exe
  6. Breakpoint 1, main () at main.c:17
  7. 17     scanf("%d", &num);
  8. (gdb) u
  9. 3
  10. 18     int result = myfunc(num);
  11. (gdb) step
  12. myfunc (num=3) at main.c:7
  13. 7     int i = 1;
  14. (gdb) u
  15. 8     int sum = 0;
  16. (gdb) u
  17. 9     while(i <= num){
  18. (gdb) u
  19. 10         sum += print(i);
  20. (gdb) u
  21. 11         i++;
  22. (gdb) u                                 <-- 执行 i++ 操作
  23. 9     while(i <= num){
  24. (gdb) u                                 <-- 快速执行完循环体
  25. 13     return sum;
  26. (gdb) p sum
  27. $1 = 14

可以看到，这里当程序单步执行完第 11 行代码时，借助 until 命令快速执行完了整个循环体，并在第 13 行代码处停止执行。根据 p 命令输出的 num 变量的值可以确认，整个循环过程确定完整地执行完了。

until 命令还可以后跟某行代码的行号，以指示 GDB 调试器直接执行至指定位置后停止。举个例子：

  1. (gdb) r
  2. Starting program:~/demo/main.exe
  4. Breakpoint 1, main () at main.c:17
  5. 17     scanf("%d", &num);
  6. (gdb) until 19                                    <-- 执行至第 19 行停止
  7. 3
  8. main () at main.c:19
  9. 19     printf("%d", result);
  10. (gdb) p result
  11. $3 = 14

可以看到，通过执行 until 19 命令，GDB 调试器直接从第 17 行代码处执行至指定的第 19 行。