GDB on 夜云泊

DEBUG 原理

Sun, 14 Aug 2022 14:17:26 +0000

了解调试原理时看到了一个质量比较高的视频，【蛋饼嵌入式】一起探究调试原理。UP 通俗，形象地讲解了 DEBUG 的一些原理，值得反复观看，但是视频不如文字查阅效率高，遂记录了以下文稿内容。

什么是 JTAG

1985 年，几家半导体厂商为了解决板级测试的问题，成立了 Joint Test Action Group（JTAG）联合测试行动小组，他们希望将测试点和测试电路集成在芯片内部引脚处。同时，留出一个统一协议的接口，大家都能通过这个接口来访问芯片的输入与输出状态。这样就省去了板级测试是的物理接触，同时还能进行逻辑性调试。后来 IEEE 组织，将这个方案制定成了标准 IEEE 1149.1，这就是现在我们常听到的 JTAG 调试。

边界扫描技术

实现 JTAG 调试最重要的一个技术就是边界扫描技术，核心思想是给芯片的每一个输入输出引脚，添加一个移位寄存器单元，也称为边界扫描单元（Boundary Scan Cell，BSC）。通过它一边可以实现对芯片输出数据的截取，另一边可以完成对输入数据的替代。正常运行状态下，这些寄存器又是透明般的存在。

Responsive Image

这些位于引脚边界的移位寄存器，还可以串在一起，形成一条边界扫描链，以串行的方式从外部更新扫描单元上的数据，以及对外输出边界扫描单元捕获的数据。如果板上有多个这样的芯片，他们还能以菊花链的形式串联在一起，这样就大大方便了测试的过程。

Responsive Image

要实现对内部移位寄存器单元或者说对整个扫描链的访问和操作，便依赖于 JTAG 调试协议和相应的物理接口。JTAG 标准接口包括以下几个部分：

TDI(Test Data In)
TDO(Test Data Out)
TCLK(Test Clock)
TMS(Test Mode Select)
TRST(Test Reset)：可选，用于复位

Responsive Image

调试逻辑的实现，是通过芯片内部的 TAP（Test Access Port）来完成的。模式状态信号 TMS 配合测试时钟信号 TCLK，以一定的时序进入到 TAP 控制器后，由 TAP 控制器内部的状态机转化为相应的控制动作。从而完成数据的移位，引脚状态的捕获和更新。

设备 ID 寄存器构成的扫描链，板卡一连上调试器，通过对这条扫描链的访问，就能够识别到被调试芯片的信号。存放调试机制相关配置的数据寄存器，所构成的扫描链，后面断点和单步调试时就会用到。以及移位的 BYPASS 寄存器，当调试链路上有多个芯片连接时，来减少总调试链路的长度。

以上都属于数据寄存器构成扫描链，因为想要在他们之间进行切换，需要引入另外的指令寄存器，以及对应的扫描链，这样调试主机将不同的调试命令写到指令寄存器中，就可以选通需要调试的数据链路。数据与指令寄存器两种链路的切换，就通过 TAP 控制器完成。

补充：如果芯片支持 JTAG 调试，那么芯片上就必须有上述的四个接口，TDI，TDO，TCLK，TMS。 Responsive Image

芯片外有个 Adapter 与之 Pin to Pin 连接，负责协议转换，把 USB 的 JTAG 控制信息按 JTAG 协议转换输出，满足协议定义的电气特性。 Adapter 与 Host 连接，Host 可以是我们的 PC，也可以是另一个嵌入式调试器。 Host 上通常需要运行一些软件，如 OpenOCD，负责把 GDB 的高级别命令转换成 JTAG 命令，并通过特定 Adapter 的要求进行打包，调用 OS 提供的 USB/ETH/PCI 驱动发送出去。 GDB 与 OpenOCD 通过一些远程协议，如 TCP/IP，进行通信。这样就能够调试 Chip。

断点是如何实现的？

通过以上 JTAG 调试接口，我们已经能够测试引脚的输入输出了，同时也获得了观察和改变芯片内部数据的机会，那么接下来我们如何进行调试呢？比如打个断点？

断点作为一种干预性调试，根据调试行为的不同，分为监控模式和中止模式。

监控模式（软件断点）：会触发异常，交由相应的软件程序来处理，处理器仍然处于运行状态。
中止模式（硬件断点），使处理器进入非正常运行的调试状态。

以 ARM 架构来说，最初工程师想到的办法是插入一条指令集中没有定义的无效指令，来替换掉希望打断指令处的源指令。这样内核运行到这条指令时，就会进入到无效指令的服务程序，在这个异常的服务程序中，我们再去做想要的调试操作，操作完成后，还原当时被替换的指令。并继续执行。

后来 ARMv5 开始引入专门用于调试的BKPT指令，类似与 X86 指令集的INT3指令，但不管是不是专用指令，他们都属于软件中断。这意味着我想要实时地添加这种断点，就要求能够随时地更改程序，插入断点指令，而一般只有程序运行在 RAM 上，才方便这样操作。那如果直接从 FLASH 上取址运行的程序，因为 FLASH 先擦后写的物理特性，是无法通过随意插入指令来实现断点的。更不要说从只读存储器上运行的程序，比如说固化在 BIOS 中上电自检 POST 程序，面对这种情况，需要的就是硬件断点。

硬件断点顾名思义，需要额外的硬件逻辑支持，主要起的作用就是暂存和比较，我们把这种实现特定逻辑的组合电路，称为宏单元（Macro Cell）。

还记得我们前面说过 JTAG 协议，支持自定义扩展扫描链吗？硬件断点宏单元的控制和比较两种数据寄存器，就可以作为两条拓展扫描链，加入到 JTAG 调试框架中。

你在调试软件中按下一个按钮，对应的那行代码地址，就会通过上述扫描链，被记录到断点宏单元相应的寄存器中，当然，调试器能够知道某行代码的地址，是依赖于编译时生成的 ELF 文件中的符号表信息。而当程序正常运行取址时，如果宏单元的寄存器，发现了总线上出现了记录过的地址，比较器就会发出调试状态信号，CPU 接收到这个信号后暂停运行，进入调试模式或者异常。

因为每打一个断点，都需要宏单元相应的寄存器来保存地址信息。而寄存器数量是有限的，所以调试软件一旦和芯片建立起了连接，就会通过上述的另外一条控制寄存器获得该硬件断点宏单元所支持的最大断点数，这样你在调试过程中如果断点打多了，调试器就会报错。

为什么调试器能够烧录程序呢？

正常情况下，CPU 内核通过内部的系统总线，从 FLASH 或者 RAM 中获取运行的指令，交换数据，并在一定的驱动程序下，实现对 FLASH 的擦除和写入操作。为了把指令和数据直接给 CPU 内核，我们还需要定义一条扫描链，这条扫描链直接在系统总线上开了一个口子，通过上位机的调试信号，把相关的操作指令直接传到总线上，供 CPU 内核取用。

Responsive Image

那么整个调试器的下载过程是这样的：

第一，通过调试器使得 CPU 进入调试模式；
第二，通过总线扫描链将 FLASH 编程算法与即将被下载的用户程序放到 RAM 中；
第三，将 CPU 的 PC 指针指向刚刚搬运完成的 RAM 地址起始处，并退出调试状态；
第四，CPU 将在正常状态下运行 RAM 中的 FLASH 编程算法。将用户代码烧录到确定位置上，执行完成后回到调试状态。

如果 RAM 空间不够大，以上操作还需要重复多次执行。

需要注意的是，在第二步操作 RAM 时，是处于调试状态下，而调试时钟的速率是无法满足 RAM 或者 FLASH 的访问速率要求的，所以在这一过程中，CPU 会频繁的在系统时钟与调试时钟之间切换

调试时钟下，总线扫描链先传递来要写入的数据和 RAM 地址，CPU 先分别暂存在内部通用寄存器中，接着扫描链传递写入指令，并切换为系统时钟。CPU 在正常状态下执行搬运指令，往 RAM 里写入数据，执行完成后回到调试状态，继续通过扫描链传递后面要写入的值，

OpenOCD (Open On-Chip Debugger)

OpenOCD（Open On-Chip Debugger）开源片上调试器，是一款开源软件，最初是由 Dominic Rath 同学还在大学期间发起的（2005 年）项目。OpenOCD 旨在提供针对嵌入式设备的调试、系统编程和边界扫描功能。

参考资料

【蛋饼嵌入式】饮茶先？DEBUG 先！一起探究调试原理_哔哩哔哩_bilibili 浅谈 RISC-V 的 DEBUG 系统及其仿真 - 知乎 ESP32 JTAG Debug 01: JTAG 接口简介_哔哩哔哩_bilibili+

CSAPPLAB-Bomb Lab

Sun, 29 Aug 2021 18:40:16 +0000

Tips

缩写注释

CSAPP：Computer Systems A Programmer’s Perspective（深入理解计算机操作系统）。CSAPP（C：P166，O：P278）表示书本的中文版第 166 页，英文原版第 278 页。

寄存器信息

了解寄存器的基本用途，看到一个汇编代码，可以大概了解这个寄存器是在栈中使用的，还是保存参数的，是调用者保存，还是被调用者保存。 Responsive Image

GDB

调试过程用到的 GDB 命令可以先参考GDB 调试入门这篇文章。文中所用例子也是摘自与 BombLab 的源码，更容易理解如何使用。还有一定比较重要的是，如何使用 gdb 带参数调试。为了不用每次运行bomb程序都需要重新输入答案，bomb程序可以读取文本信息，在文本文件中写入答案即可免去手动输入。

phase_1

拆弹专家已上线，开干！！！！！！！！！！！！！


(gdb) b phase_1
(gdb) b explode_bomb
(gdb) disas phase_1
Dump of assembler code for function phase_1:'
   0x0000000000400ee0 <+0>: sub    $0x8,%rsp
   0x0000000000400ee4 <+4>: mov    $0x402400,%esi
   0x0000000000400ee9 <+9>: callq  0x401338 <strings_not_equal>
   0x0000000000400eee <+14>: test   %eax,%eax
   0x0000000000400ef0 <+16>: je     0x400ef7 <phase_1+23>
   0x0000000000400ef2 <+18>: callq  0x40143a <explode_bomb>
   0x0000000000400ef7 <+23>: add    $0x8,%rsp
   0x0000000000400efb <+27>: retq   
End of assembler dump.

3：将栈指针rsp减去 8 个字节，也就是申请 8 个字节的栈空间
4：将一个立即数存到寄存器esi中
5：调用函数strings_not_equal，该函数第一条语句的地址为0x401338。callq指令的执行过程可参考书本 CSAPP（C：P166，O：P278）
6：使用test命令（同and命令，不修改目标对象的值）来测试eax中的值是否为0，如果为0则跳过引爆炸弹的函数
7：这一句和上一句是一个整体，如果eax==0,就跳转到0x400ef7，这个地址也就是第 9 行的地址，成功跳过了引爆炸弹函数。意思就是我们输入的某个字符串成功匹配，也就是strings_not_equal函数返回值为 0。
8：调用函数explode_bomb，引爆炸弹
9：将栈指针rsp加上 8 个字节，也就是恢复 8 个字节的栈空间

(gdb) disas strings_not_equal 
Dump of assembler code for function strings_not_equal:
=> 0x0000000000401338 <+0>: push   %r12
   0x000000000040133a <+2>: push   %rbp
   0x000000000040133b <+3>: push   %rbx
   0x000000000040133c <+4>: mov    %rdi,%rbx
   0x000000000040133f <+7>: mov    %rsi,%rbp
   0x0000000000401342 <+10>: callq  0x40131b <string_length>
   0x0000000000401347 <+15>: mov    %eax,%r12d
   0x000000000040134a <+18>: mov    %rbp,%rdi
   0x000000000040134d <+21>: callq  0x40131b <string_length>
   0x0000000000401352 <+26>: mov    $0x1,%edx
   0x0000000000401357 <+31>: cmp    %eax,%r12d
   0x000000000040135a <+34>: jne    0x40139b <strings_not_equal+99>
   0x000000000040135c <+36>: movzbl (%rbx),%eax
   0x000000000040135f <+39>: test   %al,%al
   0x0000000000401361 <+41>: je     0x401388 <strings_not_equal+80>
   0x0000000000401363 <+43>: cmp    0x0(%rbp),%al
   0x0000000000401366 <+46>: je     0x401372 <strings_not_equal+58>
   0x0000000000401368 <+48>: jmp    0x40138f <strings_not_equal+87>
   0x000000000040136a <+50>: cmp    0x0(%rbp),%al
   0x000000000040136d <+53>: nopl   (%rax)
   0x0000000000401370 <+56>: jne    0x401396 <strings_not_equal+94>
   0x0000000000401372 <+58>: add    $0x1,%rbx
   0x0000000000401376 <+62>: add    $0x1,%rbp
   0x000000000040137a <+66>: movzbl (%rbx),%eax
   0x000000000040137d <+69>: test   %al,%al
   0x000000000040137f <+71>: jne    0x40136a <strings_not_equal+50>
   0x0000000000401381 <+73>: mov    $0x0,%edx
   0x0000000000401386 <+78>: jmp    0x40139b <strings_not_equal+99>
   0x0000000000401388 <+80>: mov    $0x0,%edx
   0x000000000040138d <+85>: jmp    0x40139b <strings_not_equal+99>
   0x000000000040138f <+87>: mov    $0x1,%edx
   0x0000000000401394 <+92>: jmp    0x40139b <strings_not_equal+99>
   0x0000000000401396 <+94>: mov    $0x1,%edx
   0x000000000040139b <+99>: mov    %edx,%eax
   0x000000000040139d <+101>: pop    %rbx
   0x000000000040139e <+102>: pop    %rbp
   0x000000000040139f <+103>: pop    %r12
   0x00000000004013a1 <+105>: retq   
End of assembler dump.

3-5：在函数调用时先保存相关寄存器值，rbp和rbx就是用来保存两个参数的寄存器
6：将寄存器rdi的值复制到寄存器rbp
7：将寄存器rsi的值复制到寄存器rbx

其实看到这里就一直能够猜到答案是什么了。我们通过之前的phase_1函数能够大概知道需要输入一个值进行比较，如果比较正确就能解除炸弹。现在我们又进入到了这个比较函数，比较函数有两个参数，分别保存在两个寄存器里。我们正常的思维如果写一个比较函数，肯定一个参数是我们输入的值，一个参数是正确的值。

这里看到了rsi寄存器，我们还记得在phase_1函数中第 4 行的esi寄存器吗？这两个寄存器是同一个寄存器，只不过esi是寄存器的低 32 位，既然esi已经赋值了，那剩下的一个参数保存我们输入的内容。所以esi内存的内容就是我们需要的正确答案。我们只要把寄存器esi中的值打印出来，或者内存地址为0x402400的内容打印出来即可。可以通过以下三条命令查看。

(gdb) p (char*)($esi)
$5 = 0x402400 "Border relations with Canada have never been better."
(gdb) x/s 0x402400
0x402400: "Border relations with Canada have never been better."
(gdb) x/s $esi
0x402400: "Border relations with Canada have never been better."

将答案复制，然后继续运行

The program being debugged has been started already.
Start it from the beginning? (y or n) y
Starting program: /home/dominic/learning-linux/bomb/bomb 
Welcome to my fiendish little bomb. You have 6 phases with
which to blow yourself up. Have a nice day!
Border relations with Canada have never been better.

Breakpoint 2, 0x0000000000400ee0 in phase_1 ()
(gdb) s
Single stepping until exit from function phase_1,
which has no line number information.
main (argc=<optimized out>, argv=<optimized out>) at bomb.c:75
75     phase_defused();                 /* Drat!  They figured it out!
(gdb) s
77     printf("Phase 1 defused. How about the next one?\n");

从 13 行phase_defused()可以知道我们已经解除了炸弹，从 15 行printf函数也可以看到，需要进行下一个炸弹的拆除。过来人的建议，在这里就开始分析phase_2，寻找答案，因为继续执行就要开始输入内容了，将无法调试。

phase_2

继续分析第二个炸弹，

(gdb) disas phase_2
Dump of assembler code for function phase_2:
   0x0000000000400efc <+0>: push   %rbp
   0x0000000000400efd <+1>: push   %rbx
   0x0000000000400efe <+2>: sub    $0x28,%rsp
   0x0000000000400f02 <+6>: mov    %rsp,%rsi
   0x0000000000400f05 <+9>: callq  0x40145c <read_six_numbers>
   0x0000000000400f0a <+14>: cmpl   $0x1,(%rsp)
   0x0000000000400f0e <+18>: je     0x400f30 <phase_2+52>
   0x0000000000400f10 <+20>: callq  0x40143a <explode_bomb>
   0x0000000000400f15 <+25>: jmp    0x400f30 <phase_2+52>
   0x0000000000400f17 <+27>: mov    -0x4(%rbx),%eax
   0x0000000000400f1a <+30>: add    %eax,%eax
   0x0000000000400f1c <+32>: cmp    %eax,(%rbx)
   0x0000000000400f1e <+34>: je     0x400f25 <phase_2+41>
   0x0000000000400f20 <+36>: callq  0x40143a <explode_bomb>
   0x0000000000400f25 <+41>: add    $0x4,%rbx
   0x0000000000400f29 <+45>: cmp    %rbp,%rbx
   0x0000000000400f2c <+48>: jne    0x400f17 <phase_2+27>
   0x0000000000400f2e <+50>: jmp    0x400f3c <phase_2+64>
   0x0000000000400f30 <+52>: lea    0x4(%rsp),%rbx
   0x0000000000400f35 <+57>: lea    0x18(%rsp),%rbp
   0x0000000000400f3a <+62>: jmp    0x400f17 <phase_2+27>
   0x0000000000400f3c <+64>: add    $0x28,%rsp
   0x0000000000400f40 <+68>: pop    %rbx
   0x0000000000400f41 <+69>: pop    %rbp
   0x0000000000400f42 <+70>: retq   
End of assembler dump.

3-6：保存程序入口地址，变量等内容，就不再赘述了
7: 调用read_six_numbers函数，根据函数名我们可以猜测这个函数需要读入六个数字
8-9：比较寄存器rsp存的第一个数字是否等于0x1，如果等于就跳转到phase_2+52处继续执行，如果不等于就执行explode_bomb。栈中保存了六个输入的数字，保存顺序是从右往左，假如输入1,2,3,4,5,6。那么入栈的顺序就是6,5,4,3,2,1，寄存器rsp指向栈顶，也就是数字1的地址。
21:假设第一个数字正确，我们跳转到<+52>位置，也就是第 21 行，将rsp+0x4写入寄存器rbx，栈指针向上移动四个字节，也就是取第二个输入的参数，将它赋给寄存器rbx
22：将rsp+0x18写入寄存器rbp，十六进制0x18=24，4 个字节一个数，刚好 6 个数，就是将输入参数的最后一个位置赋给寄存器rbp
23：跳到phase_2+27继续执行
12：rbx-0x4赋给寄存器eax。第 21 行我们知道，rbx此时已经到第二个参数了，这一句就是说把第一个参数的值写入寄存器eax
13：将eax翻一倍，第 8 行知道第一个参数值为1，所以此时eax值为2
14-15：比较eax是否等于rbx。rbx此时保存的是第二个参数，这里也就是比较第二个参数是否等于2。如果等于跳转到phase_2+41位置，如果不等于就调用爆炸函数
17-18：假设第二个参数就是 2，我们跳过了炸弹来到第 17 行，将rbx继续上移，然后比较rbp是否等于rbx，我们知道rbp保存了最后一个参数的地址，所以这里的意思就是看看参数有没有到最后一个参数。
19：如果rbx<rbp，意思就是还没到最后一个参数，就跳转到phase_2+27
12：再次回到第 12 行，这里就是相当于一个循环了，让rbx一直向上移动，分别存入第 2，3，4，5，6 个参数，在移动到下一个参数时先保存当前参数到寄存器eax让其翻一倍，然后rbx再移动到下一个参数，比较eax==rbx。直到rbx越过了rbp。程序跳转到phase_2+64，将栈空间恢复。

以上分析也可以得出答案了，我们只要输入一个以1为初值，公比为2，个数为6的等比数列就是答案，也就是1 2 4 8 16 32。

(gdb) c
Continuing.
Phase 1 defused. How about the next one?
1 2 4 8 16 32

Breakpoint 6, 0x00000000004015c4 in phase_defused ()
(gdb) s
Single stepping until exit from function phase_defused,
which has no line number information.
main (argc=<optimized out>, argv=<optimized out>) at bomb.c:84
84     printf("That's number 2.  Keep going!\n");
(gdb) s

这个炸弹的作者应该再心狠手辣一点，把函数名换成read_some_numbers，这样我们就不得不看这个函数的内容了，因为这个函数里还有一个坑，这个坑在函数名字上一句被填了。那就是这个函数会对参数个数做判断，如果小于 5 就爆炸。

(gdb) disas read_six_numbers
Dump of assembler code for function read_six_numbers:
   0x000000000040145c <+0>: sub    $0x18,%rsp
   0x0000000000401460 <+4>: mov    %rsi,%rdx
   0x0000000000401463 <+7>: lea    0x4(%rsi),%rcx
   0x0000000000401467 <+11>: lea    0x14(%rsi),%rax
   0x000000000040146b <+15>: mov    %rax,0x8(%rsp)
   0x0000000000401470 <+20>: lea    0x10(%rsi),%rax
   0x0000000000401474 <+24>: mov    %rax,(%rsp)
   0x0000000000401478 <+28>: lea    0xc(%rsi),%r9
   0x000000000040147c <+32>: lea    0x8(%rsi),%r8
   0x0000000000401480 <+36>: mov    $0x4025c3,%esi
   0x0000000000401485 <+41>: mov    $0x0,%eax
   0x000000000040148a <+46>: callq  0x400bf0 <__isoc99_sscanf@plt>
   0x000000000040148f <+51>: cmp    $0x5,%eax
   0x0000000000401492 <+54>: jg     0x401499 <read_six_numbers+61>
   0x0000000000401494 <+56>: callq  0x40143a <explode_bomb>
   0x0000000000401499 <+61>: add    $0x18,%rsp
   0x000000000040149d <+65>: retq   
End of assembler dump.

3：申请 24 个字节栈空间
4：rdx=rsi，将输入参数的第一个参数放到寄存器rdx中，为啥是第一个参数，因为rsi现在保存的地址是栈顶位置，栈顶目前保存就是第一个参数。
5：rcx = rsi + 4，把第二个参数的地址传给寄存器rcx
6：rax = rsi + 20，把第六个参数的地址传给寄存器rax
7：rsp + 8 = rax第八个参数
8：rax = rsi + 16，把第五个参数传给
9：rsp = rax第七个参数
10：r9 = rsi + 12把第四个参数传给寄存器r9
11：r8 = rsi + 8把第三个参数传给寄存器r8
12：
13：eax = 0
14：调用输入函数sscanf
15-17：函数返回值个数与 5 比较，如果小于 5 就爆炸，否则返回

phase_3

   0x0000000000400f43 <+0>: sub    $0x18,%rsp
   0x0000000000400f47 <+4>: lea    0xc(%rsp),%rcx
   0x0000000000400f4c <+9>: lea    0x8(%rsp),%rdx
   0x0000000000400f51 <+14>: mov    $0x4025cf,%esi
   0x0000000000400f56 <+19>: mov    $0x0,%eax
   0x0000000000400f5b <+24>: callq  0x400bf0 <__isoc99_sscanf@plt>
   0x0000000000400f60 <+29>: cmp    $0x1,%eax
   0x0000000000400f63 <+32>: jg     0x400f6a <phase_3+39>
   0x0000000000400f65 <+34>: callq  0x40143a <explode_bomb>
   0x0000000000400f6a <+39>: cmpl   $0x7,0x8(%rsp)
   0x0000000000400f6f <+44>: ja     0x400fad <phase_3+106>
   0x0000000000400f71 <+46>: mov    0x8(%rsp),%eax
   0x0000000000400f75 <+50>: jmpq   *0x402470(,%rax,8)
   0x0000000000400f7c <+57>: mov    $0xcf,%eax
   0x0000000000400f81 <+62>: jmp    0x400fbe <phase_3+123>
   0x0000000000400f83 <+64>: mov    $0x2c3,%eax
   0x0000000000400f88 <+69>: jmp    0x400fbe <phase_3+123>
   0x0000000000400f8a <+71>: mov    $0x100,%eax
   0x0000000000400f8f <+76>: jmp    0x400fbe <phase_3+123>
   0x0000000000400f91 <+78>: mov    $0x185,%eax
   0x0000000000400f96 <+83>: jmp    0x400fbe <phase_3+123>
   0x0000000000400f98 <+85>: mov    $0xce,%eax
   0x0000000000400f9d <+90>: jmp    0x400fbe <phase_3+123>
   0x0000000000400f9f <+92>: mov    $0x2aa,%eax
   0x0000000000400fa4 <+97>: jmp    0x400fbe <phase_3+123>
   0x0000000000400fa6 <+99>: mov    $0x147,%eax
   0x0000000000400fab <+104>: jmp    0x400fbe <phase_3+123>
   0x0000000000400fad <+106>: callq  0x40143a <explode_bomb>
   0x0000000000400fb2 <+111>: mov    $0x0,%eax
   0x0000000000400fb7 <+116>: jmp    0x400fbe <phase_3+123>
   0x0000000000400fb9 <+118>: mov    $0x137,%eax
   0x0000000000400fbe <+123>: cmp    0xc(%rsp),%eax
   0x0000000000400fc2 <+127>: je     0x400fc9 <phase_3+134>
   0x0000000000400fc4 <+129>: callq  0x40143a <explode_bomb>
   0x0000000000400fc9 <+134>: add    $0x18,%rsp
   0x0000000000400fcd <+138>: retq

1：开辟 24 字节的栈空间
2：rcx = rsp + 12第二个参数
3：rdx = rsp + 8第一个参数
4-8：和phase_2里read_six_numbers函数中的第 13 行开始一样，输入数据，判断一下输入参数的个数，只不过这里是返回值个数大于 1，如果参数个数正确就跳到phase_3+39也就是第 10 行，否则引爆炸弹。
10-11：如果7 < rsp + 8 等价于 7 < rdx 等价于 7 < 第一个参数就跳转到phase_3+106，爆炸。这里确定第一个数必须小于 7
12：eax = rsp + 8 等价于 eax = 第一个参数
13：跳转至0x402470 + 8 * rax处，具体跳转到哪里根据第一个值做判断
14：eax = 207
15：跳转至phase_3+123,即 32 行
16：eax = 707
17：跳转到 32 行
18：eax = 256
19：跳转到 32 行
20：eax = 389
21-27：以此类推
29：eax = 0
30：
31：eax = 311
32-34：比较eax和rsp + 12 等价于比较第二个参数和eax。如果相等就返回，如果不等就引爆。

分析至此，我们也就知道了程序的大概流程，输入两个值，第一个值必须小于等于 7，第二个值根据第一个值来确定，具体等于多少，根据跳转表确定，因为第一个值有八个数，也就对应着汇编中八段寄存器eax赋值的过程，我们只要输入第一个合法的数值，然后再打印出寄存器eax的值，即可确定答案。

比如我们先测试一下第一个值为 0 时，对应的第二个值为多少，我们输入0 10，因为只是测试，第二个值任意。

That's number 2.  Keep going! //接上个炸弹后面
88     input = read_line();
(gdb) n
0 10              //输入测试答案
89     phase_3(input);
(gdb) n
Breakpoint 4, 0x0000000000400f43 in phase_3 ()
(gdb) n
Single stepping until exit from function phase_3,
which has no line number information.
Breakpoint 2, 0x000000000040143a in explode_bomb ()
(gdb) p $eax
$14 = 207         //207即是答案

输入真正答案测试，

(gdb) n
0 207                         //输入答案
89     phase_3(input);
(gdb) n
Breakpoint 4, 0x0000000000400f43 in phase_3 ()
(gdb) n
Single stepping until exit from function phase_3,
which has no line number information.
main (argc=<optimized out>, argv=<optimized out>) at bomb.c:90
90     phase_defused();    //炸弹拆除
(gdb) 
91     printf("Halfway there!\n");

我们上面说过，第一个值有八种可能，所以这题答案也有八个，我们只要挨个测试0-7，分别打印出寄存器eax的值就可以得到所有答案。他们分别是

phase_4

行百里者半九十，NO

(gdb) disas phase_4
Dump of assembler code for function phase_4:
   0x000000000040100c <+0>: sub    $0x18,%rsp
   0x0000000000401010 <+4>: lea    0xc(%rsp),%rcx
   0x0000000000401015 <+9>: lea    0x8(%rsp),%rdx
   0x000000000040101a <+14>: mov    $0x4025cf,%esi
   0x000000000040101f <+19>: mov    $0x0,%eax
   0x0000000000401024 <+24>: callq  0x400bf0 <__isoc99_sscanf@plt>
   0x0000000000401029 <+29>: cmp    $0x2,%eax
   0x000000000040102c <+32>: jne    0x401035 <phase_4+41>
   0x000000000040102e <+34>: cmpl   $0xe,0x8(%rsp)
   0x0000000000401033 <+39>: jbe    0x40103a <phase_4+46>
   0x0000000000401035 <+41>: callq  0x40143a <explode_bomb>
   0x000000000040103a <+46>: mov    $0xe,%edx
   0x000000000040103f <+51>: mov    $0x0,%esi
   0x0000000000401044 <+56>: mov    0x8(%rsp),%edi
   0x0000000000401048 <+60>: callq  0x400fce <func4>
   0x000000000040104d <+65>: test   %eax,%eax
   0x000000000040104f <+67>: jne    0x401058 <phase_4+76>
   0x0000000000401051 <+69>: cmpl   $0x0,0xc(%rsp)
   0x0000000000401056 <+74>: je     0x40105d <phase_4+81>
   0x0000000000401058 <+76>: callq  0x40143a <explode_bomb>
   0x000000000040105d <+81>: add    $0x18,%rsp
   0x0000000000401061 <+85>: retq

1-8：开辟空间，保存参数信息，调用输入函数，和上面的分析重复，不再赘述。注意的是第 6 行，x/s 0x4025cf可知两个参数是整型数值。
9-10：参数个数必须等于 2，否则引爆
11-12：14与rsp + 8比较，等价于14与第一个参数比较。表示第一个参数必须小于等于 14，否则引爆。
14：edx = 14
15：esi = 0
16：edi = rsp + 8即edi = 第一个参数
17：调用函数fun4，参数分别为edi 0 14
18：测试返回值是否为 0，如果不为 0，引爆
20-22：比较0和rsp + 12，如果不等，引爆，否则返回

(gdb) disas func4
Dump of assembler code for function func4:
   0x0000000000400fce <+0>: sub    $0x8,%rsp
   0x0000000000400fd2 <+4>: mov    %edx,%eax
   0x0000000000400fd4 <+6>: sub    %esi,%eax
   0x0000000000400fd6 <+8>: mov    %eax,%ecx
   0x0000000000400fd8 <+10>: shr    $0x1f,%ecx
   0x0000000000400fdb <+13>: add    %ecx,%eax
   0x0000000000400fdd <+15>: sar    %eax
   0x0000000000400fdf <+17>: lea    (%rax,%rsi,1),%ecx
   0x0000000000400fe2 <+20>: cmp    %edi,%ecx
   0x0000000000400fe4 <+22>: jle    0x400ff2 <func4+36>
   0x0000000000400fe6 <+24>: lea    -0x1(%rcx),%edx
   0x0000000000400fe9 <+27>: callq  0x400fce <func4>
   0x0000000000400fee <+32>: add    %eax,%eax
   0x0000000000400ff0 <+34>: jmp    0x401007 <func4+57>
   0x0000000000400ff2 <+36>: mov    $0x0,%eax
   0x0000000000400ff7 <+41>: cmp    %edi,%ecx
   0x0000000000400ff9 <+43>: jge    0x401007 <func4+57>
   0x0000000000400ffb <+45>: lea    0x1(%rcx),%esi
   0x0000000000400ffe <+48>: callq  0x400fce <func4>
   0x0000000000401003 <+53>: lea    0x1(%rax,%rax,1),%eax
   0x0000000000401007 <+57>: add    $0x8,%rsp
   0x000000000040100b <+61>: retq

func (edi, esi, edx)
{
   // edi = 第一个参数, esi = 0, edx = 14
   eax = edx            // 4:mov %edx, %eax
   eax = eax -esi       // 5:sub esi, %eax
   eax = edx -esi
   ecx = eax            // 6:mov %eax, %ecx
   ecx = edx - esi
   eсx = ecx >> 31      // 7:shr  $0x1f, %ecx
   ecx = (edx - esi) >> 31
   eax = eax + ecx      // 8:add %ecx, %eax
   eax = (edx - esi) + ((edx - esi) >> 31)//替换eax和ecx
   eax = eax > 1;       // 9:sar %eax
   eax = ((edx - esi) +((edx -esi) >> 31)) / 2
   ecx = eax + esi * 1   // 10:lea (rax,ersi,1), %ecx
   ecx = ((edx - esi) +((edx -esi) >> 31)) / 2 + esi * 1

   ecx = ((14 - 0) + ((14 - 0) >> 31)) / 2 + 0
   ecx = 7

   // 11:cmp %edi, %ecx
   if (ecx <= edi)
   {
      // 12:jle 400ff2
      eax = 0    // mov $0x0,%eax
      // 18:cmp %edi, %ecx
      if(ecx >= edi)
      {
         // 19:jge    0x401007 <func4+57>
         return;
         //由此可以得知道 edx == edi
      }
   }
}

phase_5

   0x0000000000401062 <+0>: push   %rbx
   0x0000000000401063 <+1>: sub    $0x20,%rsp
   0x0000000000401067 <+5>: mov    %rdi,%rbx
   0x000000000040106a <+8>: mov    %fs:0x28,%rax
   0x0000000000401073 <+17>: mov    %rax,0x18(%rsp)
   0x0000000000401078 <+22>: xor    %eax,%eax
   0x000000000040107a <+24>: callq  0x40131b <string_length>
   0x000000000040107f <+29>: cmp    $0x6,%eax
   0x0000000000401082 <+32>: je     0x4010d2 <phase_5+112>
   0x0000000000401084 <+34>: callq  0x40143a <explode_bomb>
   0x0000000000401089 <+39>: jmp    0x4010d2 <phase_5+112>
   0x000000000040108b <+41>: movzbl (%rbx,%rax,1),%ecx
   0x000000000040108f <+45>: mov    %cl,(%rsp)
   0x0000000000401092 <+48>: mov    (%rsp),%rdx
   0x0000000000401096 <+52>: and    $0xf,%edx
   0x0000000000401099 <+55>: movzbl 0x4024b0(%rdx),%edx
   0x00000000004010a0 <+62>: mov    %dl,0x10(%rsp,%rax,1)
   0x00000000004010a4 <+66>: add    $0x1,%rax
   0x00000000004010a8 <+70>: cmp    $0x6,%rax
   0x00000000004010ac <+74>: jne    0x40108b <phase_5+41>
   0x00000000004010ae <+76>: movb   $0x0,0x16(%rsp)
   0x00000000004010b3 <+81>: mov    $0x40245e,%esi
      0x00000000004010b8 <+86>: lea    0x10(%rsp),%rdi
   0x00000000004010bd <+91>: callq  0x401338 <strings_not_equal>
   0x00000000004010c2 <+96>: test   %eax,%eax
   0x00000000004010c4 <+98>: je     0x4010d9 <phase_5+119>
   0x00000000004010c6 <+100>: callq  0x40143a <explode_bomb>
   0x00000000004010cb <+105>: nopl   0x0(%rax,%rax,1)
   0x00000000004010d0 <+110>: jmp    0x4010d9 <phase_5+119>
   0x00000000004010d2 <+112>: mov    $0x0,%eax
   0x00000000004010d7 <+117>: jmp    0x40108b <phase_5+41>
   0x00000000004010d9 <+119>: mov    0x18(%rsp),%rax
   0x00000000004010de <+124>: xor    %fs:0x28,%rax
   0x00000000004010e7 <+133>: je     0x4010ee <phase_5+140>
   0x00000000004010e9 <+135>: callq  0x400b30 <__stack_chk_fail@plt>
   0x00000000004010ee <+140>: add    $0x20,%rsp
   0x00000000004010f2 <+144>: pop    %rbx
   0x00000000004010f3 <+145>: retq

GDB 调试入门

Sun, 29 Aug 2021 18:40:16 +0000

file 加载程序

(gdb) file bomb
Reading symbols from bomb...

set args 带参数调试

有时候程序不是直接可以运行的，需要加上一些必要的参数。带上参数运行很容易，只要在程序名后加上相应参数即可，但是如何带上参数进行调试呢？这就需要set args命令。

比如在BombLab实验中，我们不可能一次解决所有phase，但是每次重新调试，已经解决的phase还要重新输入一次答案，这就很麻烦，好在这个实验的作者也考虑到了，他支持读取文本。我们可以把答案预先写入一个文本文件中，程序读取已经保存的答案即可跳过相应的phase。

假设我们把答案写入了solutions.txt文件中，首先，我们加载程序，然后通过set args solutions.txt设置运行参数。

(gdb) file bomb
Reading symbols from bomb...
(gdb) set args solutions.txt 
(gdb) r
Starting program: /home/dominic/learning-linux/bomb/bomb solutions.txt 
Welcome to my fiendish little bomb. You have 6 phases with
which to blow yourself up. Have a nice day!
Phase 1 defused. How about the next one?
That's number 2.  Keep going!

list 查看源码

查看 10 行源码

每条命令显示 10 行代码

(gdb) l
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include "support.h"
26 #include "phases.h"
27 
28 /* 
29  * Note to self: Remember to erase this file so my victims will have no
30  * idea what is going on, and so they will all blow up in a
31  * spectaculary fiendish explosion. -- Dr. Evil 
32  */
(gdb) l
33 
34 FILE *infile;
35 
36 int main(int argc, char *argv[])
37 {
38     char *input;
39 
40     /* Note to self: remember to port this bomb to Windows and put a 
41      * fantastic GUI on it. */
42

set list num 设置默认显示代码行数

(gdb) set list 20   //默认显示20行代码

list linenumber 查看指定行代码

(gdb) l 10  
(gdb) l main.h : 10 //指定main.c文件中的第十行

list function 查看指定函数的代码

break 打断点

break linenum 对指定行打断点

(gdb) b 36
Note: breakpoint 1 also set at pc 0x400da0.
Breakpoint 2 at 0x400da0: file bomb.c, line 37.

break function 对指定函数打断点

(gdb) b main
Breakpoint 3 at 0x400da0: file bomb.c, line 37.
(gdb) b phase_1
Breakpoint 4 at 0x400ee0

删除断点包括禁用断点

delete 删除所有断点

(gdb) delete 
Delete all breakpoints? (y or n) y

disable breakpoint 禁用断点

(gdb) info b #先看有哪些断点
Num     Type           Disp Enb Address            What
3       breakpoint     keep y   0x0000000000400da0 in main at bomb.c:37
4       breakpoint     keep y   0x0000000000400ee0 <phase_1>
(gdb) d 3 #禁用第三号断点
(gdb) info b #再次查看断点信息发现已经没有第三号断点
Num     Type           Disp Enb Address            What
4       breakpoint     keep y   0x0000000000400ee0 <phase_1>

clear function 删除一个函数中所有的断点

(gdb) info b
Num     Type           Disp Enb Address            What
4       breakpoint     keep y   0x0000000000400ee0 <phase_1>
(gdb) clear phase_1
(gdb) info b
Deleted breakpoint 4 No breakpoints or watchpoints.

启动与退出

run 启动程序直到遇到断点

(gdb) run

start 启动程序并在第一条代码处停下

(gdb) start

x 配置 gdb 常用命令

gdb -q -x gdbinit

//gdbinit
display/z $xs
display/z $x6
display/z $x7
set disassemble-next-line on
b _start
target remote: 34

有了配置文件，就不用每次启动 gdb 时都要重新输入一遍调试命令。

quit 退出调试

(gdb) quit

调试命令

print 打印变量值

格式化字符 (/fmt)	说明
/x	以十六进制的形式打印出整数。
/d	以有符号、十进制的形式打印出整数。
/u	以无符号、十进制的形式打印出整数。
/o	以八进制的形式打印出整数。
/t	以二进制的形式打印出整数。
/f	以浮点数的形式打印变量或表达式的值。
/c	以字符形式打印变量或表达式的值。

(gdb) p i       # 10进制
$5 = 3
(gdb) p/x i     # 16进制
$6 = 0x3
(gdb) p/o i     # 8进制
$7 = 03

打印地址值

表示从内存地址 0x54320 读取内容，h 表示以双字节为单位，3 表示输出 3 个单位，u 表示按照十六进制显示。

(gdb) x/3uh 0x54320

查看当前程序栈的内容：x/10x $sp–>打印 stack 的前 10 个元素查看当前程序栈的信息：info frame—-list general info about the frame 查看当前程序栈的参数：info args—lists arguments to the function 查看当前程序栈的局部变量：info locals—list variables stored in the frame 查看当前寄存器的值：info registers(不包括浮点寄存器)

ptype 打印变量类型

(gdb) ptype i
type = int
(gdb) ptype array[i]
type = int
(gdb) ptype array
type = int [12]

display 跟踪显示变量

print命令可以打印出变量的值，但是只是一次性的。如果我们想要跟踪某个变量的变化，可以使用display命令，每当程序在断点处停下，都会打印出跟踪的变量值。

(gdb) display

info display查看已跟踪的变量，delete display取消跟踪显示变量。

step 执行一行代码

执行一行代码，如果改行代码是函数，将进入函数内部。

(gdb) s

finish 跳出函数

如果通过s单步调试进入到函数内部，想要跳出这个函数体，可以执行 finish命令。如果想要跳出函数体必须要保证函数体内不能有有效断点，否则无法跳出。

next 执行一行代码

next 命令和 step 命令功能是相似的，只是在使用 next 调试程序的时候不会进入到函数体内部，next 可以缩写为 n。

until 跳出循环体

通过 until 命令可以直接跳出某个循环体，这样就能提高调试效率了。如果想直接从循环体中跳出，必须要保证，要跳出的循环体内部不能有有效的断点，必须要在循环体的开始 / 结束行执行该命令。

layout 分割窗口，边调试边看源码

layout src

Responsive Image

layout asm

Responsive Image

layout split

Responsive Image

远程调试

`-s -S`

-s启动gdb server，默认端口号为 1234 -S让程序在_start处停下。

VSCode 调试 RISC-V 程序

Mon, 23 Aug 2021 15:51:51 +0000

前提

本文主要涉及 VSCode 的相关配置，编译及调试工具需要提前安装好。

已经安装好riscv-toolchain，包括riscv64-unknown-elf-gcc，riscv64-unknown-elf-gdb
已经安装好qemu，包括riscv32-softmmu,riscv32-linux-user,riscv64-softmmu,riscv64-linux-user
已经安装好g++,gdb

调试流程简介

对于我这样的新手，要调试一个项目源码最怕的就是开始，也就是怎么能把项目跑起来。

我们以一个简单的test项目，看看在 VSCode 里怎么跑起来。

拿到源码后，将其以文件夹形式，加入到 VSCode 中，文件 - 打开文件夹 - 选择 test 项目文件夹。项目就会在 VSCode 中打开，但是此时我们还无法编译运行，我们需要在 VSCode 上构建出一个 C 语言的编译与调试环境。

首先得安装一个插件C/C++，打开插件中心Ctrl+Shit+X，搜索，安装。

然后输入F5，会弹出对话框，选择C++(GDB)，继续选择g++。VSCode 会自动创建.vscode文件夹，已经两个文件launch.json和tasks.json。 Responsive Image

launch.json用来配置调试环境，tasks.json主要用来配置编译环境，当然也可以配置其他任务。task.json里配置的每个任务其实就相当于多开一个控制台。

配置`tasks.json`

因为我们先要编译源码，生成.out或者.exe文件，才能调试，所以先进行编译任务配置。

自动生成的文件是个配置模板，我们可以根据自己的实际情况进行配置，也有一部分可以保持默认。

// tasks.json
{
    // https://code.visualstudio.com/docs/editor/tasks
    "version": "2.0.0",
    "tasks": [
        {
             // 任务的名字，注意是大小写区分的
             //会在launch中调用这个名字
            "label": "C/C++: g++ build active file", 
             // 任务执行的是shell
            "type": "shell", 
             // 命令是g++
            "command": "g++", 
             //g++ 后面带的参数
            "args": [
                "'-Wall'",
                "-g",           // 生成调试信息，否则无法进入断点
                "'-std=c++17'",     //使用c++17标准编译
                "'${file}'",        //当前文件名
                "-o",               //对象名，不进行编译优化
                "'${fileBasenameNoExtension}.exe'",  //当前文件名（去掉扩展名）
            ],
        }
    ]
}

如果项目是通过 Makefile 编译的，那就更加简单，只需要配置一个任务即可。

{
  "version": "2.0.0",
  "tasks": [
    {
       //任务的名字方便执行
      "label": "Make Project",
      "type": "shell",
      "command": "make",
      "args":[
          //8线程编译
          "-j8",
      ],
    },
  ]
}

运行该任务时就会执行make命令进行编译。

配置`launch.json`

// launch.json

{
    "version": "0.2.0",
    "configurations": [
        {
            //调试任务的名字
            "name": "g++ - Build and debug active file", 
            //在launch之前运行的任务名，这个名字一定要跟tasks.json中的任务名字大小写一致
            "preLaunchTask": "C/C++: g++ build active file",  
            "type": "cppdbg",
            "request": "launch",
            //需要运行的是当前打开文件的目录中，
            //名字和当前文件相同，但扩展名为exe的程序
            "program": "${fileDirname}/${fileBasenameNoExtension}.exe", 
            "args": [],
            // 选为true则会在打开控制台后停滞，暂时不执行程序
            "stopAtEntry": false,
            // 当前工作路径：当前文件所在的工作空间
            "cwd": "${workspaceFolder}",
            "environment": [],
            // 是否使用外部控制台
            "externalConsole": false,  
            "MIMode": "gdb",
            "setupCommands": [
                {
                    "description": "Enable pretty-printing for gdb",
                    "text": "-enable-pretty-printing",
                    "ignoreFailures": true
                }
            ]
        }]
}

运行

经过以上配置后，我们打开main.cpp文件，在cout处打一个断点，按F5，即可编译，运行，调试。一定要打开main.cpp文件，不能随便打开文件就开始哦。因为我们在配置时使用了一些预定义，比如${file}表示当前文件，所以只有打开需要调试的文件才能开始。

Responsive Image

程序将会在cout语句停下来。

我们可以注意一下界面下方的控制台，可以更直观了解launch.jason和tasks.jason。

Responsive Image

右边的框，就是我们在tasks.jason中配置的任务，左边的框就是我们在tasks.jason中command以及args的内容，他就是帮我们提前写好编译的选项。然后在 shell 中运行。

编译调试 RISC-V 程序

了解以上这些，就可以按需配置所需的环境了。我们还是从tasks.jason开始。因为开发用的电脑是x86的，所以先要编译出riscv的程序，再用模拟器模拟出rsicv的环境，然后在模拟的环境中运行程序，最后才能开始调试。

假设已经安装好开头所提到的工具。首先配置tasks.jason：

{
    "version": "2.0.0",
    "tasks": [
        {
            // 编译当前代码
            "type": "shell",
            "label": "C/C++(RISCV): Build active file",
            // 编译器的位置
            "command": "/opt/riscv/bin/riscv64-unknown-elf-g++",
            "args": [
                "-Wall", // 开启所有警告
                "-g", // 生成调试信息s
                "${file}",
                "-o",
                "${workspaceFolder}/debug/${fileBasenameNoExtension}" // 我选择将可执行文件放在debug目录下
            ],
            // 当前工作路径：执行当前命令时所在的路径
            "options": {
                "cwd": "${workspaceFolder}"
            },
            "problemMatcher": [
                "$gcc"
            ]
        },
        {
            // 启动qemu供调试器连接
            "type": "shell",
            "label": "Run Qemu Server(RISCV)",
            "dependsOn": "C/C++(RISCV): Build active file",
            "command": "qemu-system-riscv64",
            "args": [
                "-g",
                "65500", // gdb端口，自己定义
                "${workspaceFolder}/debug/${fileBasenameNoExtension}"
            ],
        },
        {
            // 有时候qemu有可能没法退出，故编写一个任务用于强行结束qemu进程
            "type": "shell",
            "label": "Kill Qemu Server(RISCV)",
            "command": "ps -C qemu-riscv64 --no-headers | cut -d \\  -f 1 | xargs kill -9",
        }
    ]
}

tasks.jason是可以配置多个任务的，第一个任务用来编译成riscv架构下的程序，第二个任务用来启动 qemu，让程序在 qemu 上运行起来。

第一个任务中，command就是配置编译器riscv64-unkonown-elf-gcc的属性，第二个任务中，command是配置 qemu 模拟器qemu-system-riscv32的属性。第三个任务中，用来配置结束 qemu 模拟器的命令。

接下来配置launch.jason：

{
    "version": "0.2.0",
    "configurations": [
        { 
            "name": "C/C++(RISCV) - Debug Active File",
            "type": "cppdbg",
            "request": "launch",
            "program": "${workspaceFolder}/debug/${fileBasenameNoExtension}",
            "args": [],
            "stopAtEntry": false,
            "cwd": "${workspaceFolder}",
            "environment": [],
            "externalConsole": false,
            "MIMode": "gdb",
            "setupCommands": [
                {
                    "description": "为 gdb 启用整齐打印",
                    "text": "-enable-pretty-printing",
                    "ignoreFailures": true
                }
            ],
            // RISC-V工具链中的gdb
            "miDebuggerPath": "/opt/riscv/bin/riscv64-unknown-elf-gdb", 
            // 这里需要与task.json中定义的端口一致
            "miDebuggerServerAddress": "localhost:65500" 
        }
    ]
}

我们在配置x86下的调试环境时，launch.jason中有个"preLaunchTask": "C/C++: g++ build active file"，属性，这个属性的目的是在启动调试之前，先执行任务名字为"C/C++: g++ build active file"任务，也是就编译的任务。

因为启动 qemu 会导致阻塞，所以这里没有加preLaunchTask，在启动调试之前，先把 qemu 运行起来。输入Ctrl+Shift+P，打开 VSCode 命令行。输入Run Task，

Responsive Image

点击第一个，选择任务，我们可以看到出现的三个任务就是我们在tasks.jason中配置的三个任务。选择第一个 Build，编译出程序，再重复操作，选择第三个执行 QEMU 任务。

Responsive Image

预定义变量

官网

GDB on 夜云泊

DEBUG 原理

什么是 JTAG

边界扫描技术

断点是如何实现的？

为什么调试器能够烧录程序呢？

OpenOCD (Open On-Chip Debugger)

参考资料

CSAPPLAB-Bomb Lab

Tips

缩写注释

寄存器信息

GDB

phase_1

phase_2

phase_3

phase_4

phase_5

GDB 调试入门

file 加载程序

set args 带参数调试

list 查看源码

查看 10 行源码

set list num 设置默认显示代码行数

list linenumber 查看指定行代码

list function 查看指定函数的代码

break 打断点

break linenum 对指定行打断点

break function 对指定函数打断点

删除断点包括禁用断点

delete 删除所有断点

disable breakpoint 禁用断点

clear function 删除一个函数中所有的断点

启动与退出

run 启动程序直到遇到断点

start 启动程序并在第一条代码处停下

x 配置 gdb 常用命令

quit 退出调试

调试命令

print 打印变量值

打印地址值

ptype 打印变量类型

display 跟踪显示变量

step 执行一行代码

finish 跳出函数

next 执行一行代码

until 跳出循环体

layout 分割窗口，边调试边看源码

layout src

layout asm

layout split

远程调试

-s -S

VSCode 调试 RISC-V 程序

前提

调试流程简介

配置tasks.json

配置launch.json

运行

编译调试 RISC-V 程序

预定义变量

`-s -S`

配置`tasks.json`

配置`launch.json`