NEMU on RunicDolphin806

NEMU-PART III

Tue, 11 Nov 2025 00:00:00 +0000

PA3：存储管理

实现高速缓存

经过实践，高速缓存的一级和二级结构最好同时实现，否则会在分页控制中出现难以预料的bug！

定义高速缓存结构

新建文件/nemu/include/memory/cache.h，填写以下内容：

宏定义缓存块：

 1#ifndef __CACHE_H__
 2#define __CACHE_H__
 3
 4#include "common.h"
 5
 6// 定义高速缓存参数
 7#define CACHE_E_L1 8
 8#define CACHE_E_L2 16
 9#define CACHE_BLOCK 64
10#define CACHE_SIZE_L1 64*1024
11#define CACHE_SIZE_L2 4*1024*1024
12
13...
14
15#endif

缓存块的结构体定义：

 1// 定义一级缓存
 2struct cache_l1 {
 3    bool valid;
 4    int tag;
 5    uint8_t byte[CACHE_BLOCK];
 6} cache_L1[CACHE_SIZE_L1 / CACHE_BLOCK];
 7
 8// 定义二级缓存
 9struct cache_l2 {
10    bool valid;
11    bool dirty;
12    int tag;
13    uint8_t byte[CACHE_BLOCK];
14} cache_L2[CACHE_SIZE_L2 / CACHE_BLOCK];
15
16// 定义高速缓存函数
17void init_cache();
18uint32_t cache_read_L1(hwaddr_t addr);
19uint32_t cache_read_L2(hwaddr_t addr);
20void cache_write_L1(hwaddr_t addr, size_t len, uint32_t data);
21void cache_write_L2(hwaddr_t addr, size_t len, uint32_t data);

高速缓存的读写函数

新建文件/nemu/src/memory/cache.c

缓存的初始化

 1void init_cache(){
 2    int i;
 3    for(i = 0; i < CACHE_SIZE_L1 / CACHE_BLOCK; i++) {
 4        cache_L1[i].valid = false;
 5        cache_L1[i].tag = 0;
 6        memset(cache_L1[i].byte, 0, CACHE_BLOCK);
 7    }
 8    for(i = 0; i < CACHE_SIZE_L2 / CACHE_BLOCK; i++) {
 9        cache_L2[i].dirty = false;
10        cache_L2[i].valid = false;
11        cache_L2[i].tag = 0;
12        memset(cache_L2[i].byte, 0, CACHE_BLOCK);
13    }
14}

读取缓存块中的内容

 1uint32_t cache_read_L1(hwaddr_t addr) {
 2    // 取出地址中set的部分（右移block位并 & 1111111）
 3    // set = 7 byte (set = 2^s = 128)
 4    // offset = 6 byte (block = 2^e = 64)
 5    uint32_t set = (addr >> 6) & 0x7f; 
 6    bool hit = false;
 7    int i;
 8    // 一级缓存中找到相应set
 9    for(i = set * CACHE_E_L1; i < (set + 1) * CACHE_E_L1; i++) { 
10        if(cache_L1[i].tag == (addr >> 13) && cache_L1[i].valid) { // 如果tag和地址相符合并且valid == true
11            hit = true; 
12            return i;
13        }
14    }
15     
16    // 一级缓存中找空内存块
17    for(i = set * CACHE_E_L1; i < (set + 1) * CACHE_E_L1; i++) {
18        // 找到空的地方退出
19        if (!cache_L1[i].valid) {
20            break; 
21        }  
22    }
23    // 到最后仍然没有找到空的地方，执行随机替换算法
24    if(i == (set + 1) * CACHE_E_L1) { 
25        srand(0);
26        i = set * CACHE_E_L1 + rand() % CACHE_E_L1;
27    }
28    cache_L1[i].valid = true;
29    cache_L1[i].tag = addr >> 13;
30    int j = cache_read_L2(addr);;
31    memcpy(cache_L1[i].byte, cache_L2[j].byte, CACHE_BLOCK);
32    
33    return i;
34}
35
36uint32_t cache_read_L2(hwaddr_t addr){
37    uint32_t s = (addr >> 6) & ((1 << 12) - 1);
38    uint32_t block = (addr >> 6) << 6;
39    int i;
40    bool hit = false;
41    for (i = s * CACHE_E_L2; i < (s + 1) * CACHE_E_L2; i++) {
42        if (cache_L2[i].tag == (addr >> 18) && cache_L2[i].valid) {
43            hit = true;
44            break;
45        }
46    }
47    if (!hit) {
48        int j;
49        for (i = s * CACHE_E_L2; i < (s + 1) * CACHE_E_L2; i++) {
50            if (!cache_L2[i].valid)
51                break;
52        }
53        if (i == (s + 1) * CACHE_E_L2) {
54            srand(0);
55            i = s * CACHE_E_L2 + rand() % CACHE_E_L2;
56            if (cache_L2[i].dirty) {
57                uint8_t mask[BURST_LEN * 2];
58                memset(mask, 1, BURST_LEN * 2);
59                for (j = 0; j < CACHE_BLOCK / BURST_LEN; j++) {
60                    call_ddr3_write(block + j * BURST_LEN, cache_L2[i].byte + j * BURST_LEN, mask);
61                }	
62            }
63        }
64        cache_L2[i].valid = true;
65        cache_L2[i].tag = addr >> 18;
66        cache_L2[i].dirty = false;
67        for (j = 0; j < BURST_LEN; j++){
68            call_ddr3_read(block + j * BURST_LEN, cache_L2[i].byte + j * BURST_LEN);
69        }
70    }
71    return i;
72}

数据写入缓存块

 1void cache_write_L1(hwaddr_t addr, size_t len, uint32_t data) {
 2    uint32_t set = (addr >> 6) & 0x7f;
 3    uint32_t offset = addr & (CACHE_BLOCK - 1); 
 4    int i;
 5    bool hit = false;
 6    for (i = set * CACHE_E_L1; i < (set + 1) * CACHE_E_L1; i++) {
 7        if (cache_L1[i].tag == (addr >> 13) && cache_L1[i].valid) {
 8            hit = true;
 9            break;
10        }
11    }
12    // 写直通
13    if (hit) { 
14        memcpy(cache_L1[i].byte + offset, &data, len);
15    }
16    cache_write_L2(addr, len, data);
17}
18
19void cache_write_L2(swaddr_t addr, size_t len, uint32_t data) {
20    uint32_t set = (addr >> 6) & ((1 << 12) - 1); 
21    uint32_t offset = addr & 0x3f;	
22    int i;
23    bool hit = false;
24    for (i = set * CACHE_E_L2; i < (set + 1) * CACHE_E_L2; i++) {
25        if (cache_L2[i].tag == (addr >> 13) && cache_L2[i].valid) {
26            hit = true;
27            break;
28        }
29    }
30    if (!hit){
31        i = cache_read_L2(addr);
32    }
33    cache_L2[i].dirty = true;
34    memcpy(cache_L2[i].byte + offset, &data, len);
35}

修改内存读写逻辑

在/nemu/src/memory/memory.c中，修改hwaddr_read和hwaddr_write两个函数：

 1uint32_t hwaddr_read(hwaddr_t addr, size_t len) {
 2    uint32_t offset = addr & (CACHE_BLOCK - 1);
 3    uint32_t block = cache_read_L1(addr);
 4    uint8_t temp[4];
 5    memset(temp, 0, sizeof(temp));
 6    if (offset + len >= CACHE_BLOCK) {
 7        uint32_t second_block = cache_read_L1(addr + len);
 8        memcpy(temp, cache[block].byte + offset, CACHE_BLOCK - offset);
 9        memcpy(temp + CACHE_BLOCK - offset, cache[second_block].byte, len - (CACHE_BLOCK - offset));
10    } else {
11        memcpy(temp, cache[block].byte + offset, len);
12    }
13    int zero = 0;
14    uint32_t result = unalign_rw(temp + zero, 4) & (~0u >> ((4 - len) << 3));
15    return result;
16}
17
18void hwaddr_write(hwaddr_t addr, size_t len, uint32_t data) {
19    cache_write_L1(addr, len, data);
20}

实现分段机制

修改kernel

首先需要在kernel中加入切换到保护模式的代码：在kernel/include/common.h中定义宏IA32_SEG，然后重新编译kernel。

1- //#define IA32_SEG
2+ #define IA32_SEG

这一步必须完成！如果你是CV大佬，很容易漏掉这个步骤！

定义段寄存器

在CPU_state结构中添加GDTR，CR0和各种段寄存器，包括CS, DS, ES, SS, 其具体结构参考i386手册。

在libcommon/x86-inc目录下的头文件中定义了一些和x86相关的宏和结构体，你可以在NEMU中包含这些头文件来使用它们。

 1// 段寄存器
 2enum {R_ES, R_CS, R_SS, R_DS};
 3
 4// 定义段寄存器结构体
 5typedef struct {
 6    uint16_t selector;
 7    uint16_t attribute;
 8    uint32_t limit;
 9    uint32_t base;
10} Segment_Reg;
11
12...
13
14typedef struct {
15    ...
16
17    // GDTR寄存器
18    struct GDTR {
19        uint32_t base;
20        uint16_t limit;
21    } gdtr;
22
23    // CR0和CR3寄存器由 /lib-common/x86-inc/cpu.h 定义
24    CR0 cr0;
25    CR3 cr3;
26
27    // 设置段寄存器
28    union {
29        struct {
30            Segment_Reg sreg[4];	
31        };
32        struct {
33            Segment_Reg es, cs, ss, ds;
34        };
35    };
36
37} CPU_state;

完善指令集

添加lgdt指令。
添加opcode为0F 20和0F 22的mov指令，使得我们可以设置/读出CR0。
添加opcode为8E的mov指令，使得我们可以设置段寄存器。
为了设置CS寄存器, 你需要实现ljmp指令

实现段寄存器的捆绑规则

在Operand结构体中添加成员sreg，位置：/nemu/include/cpu/decode/operand.h

 1typedef struct {
 2    uint32_t type;
 3    size_t size;
 4    union {
 5        uint32_t reg;
 6-       swaddr_t addr;
 7+		struct {
 8+			swaddr_t addr;
 9+			uint8_t sreg;
10+		};
11        uint32_t imm;
12        int32_t simm;
13    };
14    uint32_t val;
15    char str[OP_STR_SIZE];
16} Operand;

修改所有调用swaddr_read()和swaddr_write()的代码，为它们添加段寄存器的参数。具体要求如下：

指令	实现要求
`opcode`为`A0`, `A1`, `A2`, `A3` 的`mov`指令	使用`DS`寄存器
一些堆栈操作指令	隐式使用`SS`寄存器
`instr_fetch()`	总是使用`CS`寄存器
`monitor`中，`x`和`p`命令读出内存时	使用`DS`寄存器
`bt`命令打印栈帧链	使用`SS`寄存器
字符串操作指令使用的段寄存器	请查阅 i386 手册

修改内存读写函数

设置CR0后，如果发现CR0的PE位为 1，则进入IA-32保护模式，从此所有虚拟地址的访问（包括swaddr_read()和 swaddr_write()）都需要经过段级地址转换。

为了实现段级地址转换，需要对/nemu/src/memory/memory.c中的swaddr_read()和swaddr_write()函数作少量修改：

1uint32_t swaddr_read(swaddr_t addr, size_t len) {
2#ifdef DEBUG
3    assert(len == 1 || len == 2 || len == 4);
4#endif
5    lnaddr_t lnaddr = seg_translate(addr, len, current_sreg);
6    return lnaddr_read(lnaddr, len);
7}
8
9// swaddr_write()函数采取类似操作

其中sreg记录了当前段级地址转换所用到的段寄存器的编码。关于段寄存器的编码，请查阅i386手册。

然后实现seg_translate()函数。再次提醒，在 NEMU 中，只有进入保护模式之后才会进行段级地址转换。

1lnaddr_t seg_translate(swaddr_t addr, size_t len, uint8_t sreg_id) {
2    if (cpu.cr0.protect_enable == 0) {
3        return addr;
4    }
5    else {
6        return cpu.sreg[sreg_id].base + addr;
7    }
8}

实现分页机制

思考题

GDT能有多大

段选择符的结构中，INDEX有13位，故GDT最大能容纳2^13个段描述符

为什么是线性地址？

不可以。虚拟地址需要经GDT中的段表翻译才能得出地址，而如果GDTR中存放虚拟地址则找不到GDT在哪里了。

如何提高寻找段描述符的效率

可以按照高速缓存的思想，建立类似cache 和 TLB 的结构来提高寻找效率。

段式存储管理的缺点

分段管理要求分配一大段连续的存储空间，难以实现并且容易造成大量的外部碎片出现。

页式存储管理的优点

没有外部碎片，并且不再需要大段连续的存储空间，提高了内存的利用率。

一些问题

Q：为什么页表表项中的基地址信息只有20位而不是32位

A：分页基地址有20位是8086的传统，在8086的分段机制中，每个段的基地址由seg_reg（即段寄存器的值）«4得到，而段寄存器是16位的，左移4位得到20位的基地址。

Q：表项和CR3中的基地址都是物理地址，这是必须的吗？能否采用虚拟地址或者线性地址？

A：是必须的，如果cr3中的基地址是虚拟地址，则无从寻找页表翻译成物理地址，进入鸡生蛋蛋生鸡的死循环。至于其他表项的虚拟地址与线性地址问题同理。

Q：为什么不采用一级页表？采用一级页表会有什么缺点？

A：多级页表可以有效地节约内存空间，如果仅采用一级页表，将可能导致较大的页表长期驻留在内存中。

空指针是“空”的吗？

空指针只是未分配或者未指向内存任何位置的指针，并不是“NULL”的。

在扁平模式下如何进行保护

对于数据有不同的访问权限，未达到需要的权限时不能进行写操作

地址映射
分页机制

因为这里定义的ｘ生成的地址是虚拟地址，超过了物理地址的界限，报错0xc014a000 outside of the physical memory。而kvm.c中的虚拟地址都经过了va_to_pa的转换，在物理地址范围之内。

进行反汇编后，其地址如下：

c01003d6: e8 65 09 00 00 call c0100d40

该call指令的opcode为e8，实现的是跳转到：该条指令的下一条指令的首地址+偏移量的位置。由于未进行寻址，故不需要进行虚实地址转化。

分页的环境下，在没有初始化页表时，0～128M的虚拟地址到物理地址的映射相当于一个简易的页表，使得高位的地址可以通过该虚拟地址（即经过va_to_pa）访问到物理地址，从而进行初始化页表的操作。

init_mm()函数执行退出时。该函数将nemu映射到了高位地址并且将之前的PDE全部置为无效，此时返回main.c时，栈中保存的返回地址需要经过虚实转换，可由于页面被置为了无效，所以报错。查看汇编代码，直接调用此函数时，nemu运行在物理地址上，由于在init_mm中将之前的PDE都置为无效，所以在loader()函数寻址时页面无效，导致报错。

NEMU-PART II

Wed, 17 Sep 2025 00:00:00 +0000

PA2：指令系统

实验目的：

掌握i386（IA-32）指令格式。
掌握NEMU平台的指令周期。

运行用户程序

任务：编写几条指令的helper函数, 使得第一个简单的C程序可以在NEMU中运行起来。

流程：

make run运行NEMU。
按c执行程序。
查看报错信息，观察出现未知指令的内存地址和对应操作码。
编写对应的指令文件xxx-template.h，xxx.h，xxx.c。
在all-instr.h中添加对应的头文件。
在exec.c中对应位置添加操作名称。

添加call指令

查找call指令对应的Opcode等信息，可知操作码为e8。

call指令

编写call-template.h

 1#include "cpu/exec/template-start.h"
 2
 3#define instr call
 4
 5// call + 相对偏移量（视为一个立即数）
 6make_helper(concat(call_i_, SUFFIX)) {
 7    // 解码偏移量（立即数）
 8    int len = concat(decode_i_, SUFFIX)(cpu.eip + 1); 
 9    // 压栈操作 (push)
10    reg_l(R_ESP) -= DATA_BYTE; 
11    // eip寄存器的下一位地址写入esp (mov)
12    MEM_W(reg_l(R_ESP), cpu.eip + len + 1); 
13    // 加上立即数偏移量，实现跳转
14    cpu.eip += (DATA_TYPE_S)op_src->val; 
15    // 更新eip寄存器
16    print_asm("call: 0x%x", cpu.eip + len + 1); 
17    return len + 1;
18}
19
20// call + 寄存器
21make_helper(concat(call_rm_, SUFFIX)) {
22    // 解码寄存器/内存
23    int len = concat(decode_rm_, SUFFIX)(eip + 1);
24    reg_l(R_ESP) -= DATA_BYTE;
25    MEM_W(reg_l(R_ESP), cpu.eip + len + 1);
26    cpu.eip = (DATA_TYPE_S)op_src->val - len - 1;
27    print_asm("call: %s", op_src->str);
28    return len + 1;
29}
30
31#include "cpu/exec/template-end.h"

call指令示意

编写call.c

 1#include "cpu/exec/helper.h"
 2
 3#define DATA_BYTE 1
 4#include "call-template.h"
 5#undef DATA_BYTE
 6
 7#define DATA_BYTE 2
 8#include "call-template.h"
 9#undef DATA_BYTE
10
11#define DATA_BYTE 4
12#include "call-template.h"
13#undef DATA_BYTE
14
15make_helper_v(call_i)
16make_helper_v(call_rm)

编写call.h

1#ifndef __CALL_H__
2#define __CALL_H__
3
4make_helper(call_i_v);
5make_helper(call_rm_v);
6
7#endif

在nemu/src/cpu/exec/all-instr.h中包含call.h，并在nemu/src/cpu/exec/exec.c中的opcode_table中填写相应的helper函数。

添加test指令

test指令

test指令其实相当于进行AND按位与操作，但是test是不会改变操作数的，只会改变EFLAGS寄存器中的标志位。

标志位	名称	功能
CF	进位标志	如果运算的结果最高位产生了进位或借位，其值为1，否则为0。
PF	奇偶标志	计算运算结果里1的奇偶性，偶数为1，否则为0。
ZF	零标志	相关指令结束后判断是否为0，结果为0，其值为1，否则为0。
SF	符号标志	相关指令结束后判断正负，结果为负，其值为1，否则为0。
I	中断使能标志	表示能否响应外部中断，若能响应外部中断，其值为1，否则为0。
DF	方向标志	当DF为1，ESI、EDI自动递减，否则自动递增。
OF	溢出标志	反映有符号数运算结果是否溢出，如果溢出，其值为1，否则为0。

编写test-template.h

 1#include "cpu/exec/template-start.h"
 2
 3#define instr test
 4
 5static void do_execute() {
 6    // 两个操作数进行与运算
 7    DATA_TYPE result = op_dest->val & op_src->val;
 8
 9    cpu.eflags.CF = 0;
10    cpu.eflags.OF = 0;
11
12    // 在/nemu/src/cpu/eflags.c中定义的函数
13    // 可根据结果自动修改eflags寄存器的值
14    update_eflags_pf_zf_sf((DATA_TYPE_S)result);
15    print_asm_template1();
16}
17make_instr_helper(i2a)
18make_instr_helper(i2rm)
19make_instr_helper(r2rm)
20
21#include "cpu/exec/template-end.h"

程序中经常使用一些缩写，并已成为约定俗成的惯例。

例如，为了方便理解，通常把to用2代替。因此i2rm表示立即数传到寄存器/内存中，r2rm表示寄存器传到寄存器/内存中。

i18n与此类似，是internationalization的缩写，表示“国际化”。

编写test.c

 1#include "cpu/exec/helper.h"
 2
 3#define DATA_BYTE 1
 4#include "test-template.h"
 5#undef DATA_BYTE
 6
 7#define DATA_BYTE 2
 8#include "test-template.h"
 9#undef DATA_BYTE
10
11#define DATA_BYTE 4
12#include "test-template.h"
13#undef DATA_BYTE
14
15make_helper_v(test_i2a)
16make_helper_v(test_i2rm)
17make_helper_v(test_r2rm)

编写test.h

 1#ifndef _TEST_H_
 2#define _TEST_H_
 3
 4make_helper(test_i2a_b);
 5make_helper(test_i2rm_b);
 6make_helper(test_r2rm_b);
 7
 8make_helper(test_i2a_v);
 9make_helper(test_i2rm_v);
10make_helper(test_r2rm_v);
11
12#endif

添加je指令

je指令

添加je指令有两种方法，一种是参考普通指令的执行方式，用static void do_execute创建函数并使用make_instr_helper()；另一种是直接定义一个新的make_jcc_helper()宏。这里采用后者，因为这样所有条件跳转如jne，jg，jge等都可以用make_jcc_helper()的宏实现。

 1#include "cpu/exec/template-start.h"
 2 
 3// 条件跳转指令译码过程复杂，make_instr_helper无法使用，需要重新定义
 4#define make_jcc_helper(cc) \
 5    make_helper(concat4(j, cc, _, SUFFIX)) { \
 6        int len = concat(decode_si_, SUFFIX)(eip + 1); \
 7        print_asm(str(concat(j,cc)) " %x",cpu.eip+op_src->val+1+len+(DATA_BYTE == 4)); \
 8        if (concat(check_cc_, cc)()) { \
 9            cpu.eip += op_src->val; \
10        } \
11        return len + 1; \
12    }
13
14#include "cpu/exec/template-end.h"

在include/cpu/eflags.h中定义比较函数：

1static inline bool check_cc_e() {
2    return cpu.eflags.ZF == 1;
3}

这样在调用make_je_helper时就会使用check_cc_e函数判断是否更新eflags寄存器的值。

添加其他指令

push指令

push指令

操作流程：
① esp寄存器值减4，表示栈顶指针下移一个地址的长度。
② 将读入的数据写入地址中，表示数据入栈。

cmp指令

cmp指令

操作流程：
① 记录源操作数-目标操作数的值。
② 用所得的值更新eflags寄存器。

pop指令

pop指令

操作流程：
① 向译码出的对象操作数中写入栈顶数据。
② 栈顶指针加4，回到push前的状态。

ret指令

ret指令

操作流程：
① 使eip跳转到esp中存放的地址处。
② 栈顶指针加4。

实现更多指令

jbe指令

在jcc-template.h指令中添加be字段，并在eflags.h中补充check_cc_be函数。

leave指令

leave指令

操作流程：
① 使esp指向ebp（栈底）所指的位置。
② ebp指向esp所存的地址。
③ 栈顶指针加4。

add指令

实现浮点数定点化

什么是定点化

我们约定最高位为符号位，接下来的15位表示整数部分，低16位表示小数部分，即约定小数点在第15和第16位之间（从第0位开始）。从这个约定可以看到，FLOAT类型其实是实数的一种定点表示。

更通俗的解释是：定点化数的小数点位置是固定的；或者说，定点化数的小数位数是确定的。

定点数

由这个定义，可以得出以下结论：

对于一个实数a，它的FLOAT类型表示A = a * 2^16 = a << 16。

定点数的运算

在lib-common/FLOAT.h中定义定点数与整型的基本运算：

 1static inline int F2int(FLOAT a) {
 2	// 将定点数转换为整型
 3	return (a >> 16);
 4}
 5
 6static inline FLOAT int2F(int a) {
 7	// 将整型转换为定点数
 8	return (a << 16);
 9}
10
11static inline FLOAT F_mul_int(FLOAT a, int b) {
12	// 定点数与整型相乘
13	return a * b;
14}
15
16static inline FLOAT F_div_int(FLOAT a, int b) {
17	// 定点数与整型相除
18	return a / b;
19}

在lib-common/FLOAT/FLOAT.c中定义浮点数到定点数的转化和定点数的运算：

定义浮点数结构

1// 接收IEEE编码的浮点数
2typedef union {
3	struct {
4		uint32_t m : 23;	// 尾数位
5		uint32_t e : 8;		// 指数位
6		uint32_t s : 1;		// 符号位
7	};
8	uint32_t val;
9} Float;

将浮点数转化为定点数

回忆浮点数的计算公式：对于一段32位长的浮点数编码，它对应的浮点数值为：$V = (-1)^s \times M \times 2^E$

其中 $E = 1 - bias$，$M = 1 + f$

 1FLOAT f2F(float a) {
 2	/* You should figure out how to convert `a' into FLOAT without
 3	 * introducing x87 floating point instructions. Else you can
 4	 * not run this code in NEMU before implementing x87 floating
 5	 * point instructions, which is contrary to our expectation.
 6	 *
 7	 * Hint: The bit representation of `a' is already on the
 8	 * stack. How do you retrieve it to another variable without
 9	 * performing arithmetic operations on it directly?
10	 */
11
12	Float f;
13	void *temp = &a;
14	f.val = *(uint32_t *) temp;     // 联合体val接收IEEE编码
15
16	uint32_t m = f.m | (1 << 23);	// 为尾数位添加1
17	// 计算偏移量
18	int shift = (int)f.e - (127+23-16);
19	
20	// 对m执行偏移操作
21	if(shift > 0) {
22		m <<= shift;
23	}
24	else {
25		m >>= (-shift);
26	}
27
28	return (__sign(f.val) ? -m : m);
29}

浮点数转定点数

实现定点数的运算
运行integral和quadratic-eq，补充缺失指令

为简易调试器增加变量支持

在nemu/src/monitor/debug/elf.c文件中：

 1//sym是我们需要匹配的符号名称，success指针用于设置是否匹配成功
 2uint32_t look_up_symtab(char *sym){
 3    int i;
 4    //遍历符号表逐个匹配符号
 5    for(i=0;i < nr_symtab_entry;i++){
 6        //逐个提取符号信息中的符号类别
 7        uint8_t type = ELF32_ST_TYPE(symtab[i].st_info);
 8        //当遇到类别为FUNC或者OBJECT时候匹配符号名
 9        if((type == STT_FUNC || type == STT_OBJECT) && strcmp(strtab + symtab[i].st_name, sym) == 0){
10        //匹配成功后返回符号的地址
11        return symtab[i].st_value;
12        }
13    }
14    printf("No sym found");
15    return 0;
16}

实现kernel加载

kernel/src/elf/elf.c

 1...
 2	/* TODO: fix the magic number with the correct one */
 3    //修改为elf文件的魔数
 4	const uint32_t elf_magic = 0x464c457f;
 5	uint32_t *p_magic = (void *)buf;
 6	nemu_assert(*p_magic == elf_magic);
 7 
 8	/* Load each program segment */
 9    //初始化ph指向program header开头，buf指向elf文件的开头，e_phoff为program header偏移量
10    ph = (void *)buf + elf->e_phoff;
11    //eph指向program header的末尾，e_phnum为program header中segment的数量
12    //遍历program header表，加载需要加载的segment
13	for(Elf32_Phdr *eph = ph + elf->e_phnum;ph < eph;ph++) {
14		/* Scan the program header table, load each segment into memory */
15		if(ph->p_type == PT_LOAD) {
16            uint32_t addr = ph->p_vaddr; //存储segment加载到的目标地址
17			/* TODO: read the content of the segment from the ELF file 
18			 * to the memory region [VirtAddr, VirtAddr + FileSiz)
19			 */
20            //利用函数从当前segment中读取filesiz大小的数据到目标地址
21         ramdisk_read((void *)addr, ELF_OFFSET_IN_DISK + ph->p_offset,ph->p_filesz);
22			
23			/* TODO: zero the memory region 
24			 * [VirtAddr + FileSiz, VirtAddr + MemSiz)
25			 */
26         //通过函数将未初始化的数据置0
27         memset((void *)addr + ph->p_filesz,0,ph->p_memsz - ph->p_filesz);
28...

进入PA3 →

NEMU-PART II Pre

Tue, 16 Sep 2025 00:00:00 +0000

磨刀不误砍柴工！！！

实验目的：

掌握i386（IA-32）指令格式。
掌握NEMU平台的指令周期。

切换用户程序

修改工程目录下的Makefile文件，更换NEMU的用户程序：

1- USERPROG := obj/testcase/mov
2+ USERPROG := obj/testcase/mov-c

同理，将mov-c更换为testcase/src目录下的其他文件，例如add、bubble-sort等，即可执行对应的用户程序。

了解NEMU的指令集

X86系列处理器采用变长指令字结构，各种指令长度随指令功能而异。

要实现一条指令，首先你需要知道这条指令的格式和功能。格式决定如何解释，功能决定如何执行。这些信息都在 instruction set page（i386 手册第17 章）。

i386 手册中的汇编语言格式都是 Intel 格式，而 objdump（反汇编）的默认格式是 AT&T 格式，两者的源操作数和目的操作数位置不一样，千万不要把它们混淆了！

指令格式

x86指令的一般格式如下：

x86指令的一般格式

Opcode（操作码）必定出现，其余组成部分可能不出现。Opcode决定是否出现ModR/M；SIB、Displacement、Immediate由ModR/M决定。
对于某些组成部分，其长度并不是固定的。
给定一条具体指令的二进制形式，其组成部分的划分是有办法确定的，不会产生歧义

例如对于以下指令：

指令示例

它的划分如下：

示例指令划分

ModR/M部分为什么解析出了disp32[--][--]？

ModR/M内部这一个字节的组成，分为了三个部分，具体每个部分的编码都对应着右边表内的含义，以ModR/M内的编码为基准进行查表就能够解析出对应的含义。

例如例子中的ModR/M部分编码是84（十六进制），对应二进制就是10000100，对应回格式中的部分就是Mod部分为10，R/M部分为100，二者在右边表中可以对应出一行，这一行的对应指令就是disp32[--][--]。disp32代表偏移量（displacement）为32位的，两个[--][--]就代表我们需要解析SIB中的编码部分才能得到偏移量的具体数值。

阅读Opcode Table

以mov指令的第一种形式为例：

mov指令

列数	具体含义
Description	将一个8位寄存器中的数据传送到8位的寄存器或者内存中，其中`r/m`表示“寄存器或内存”。
Opcode	88表示这条指令的`opcode`的首字节是`0x88`，`/r`表示后面跟一个`ModR/M`字节，并且 `ModR/M`字节中的`reg/opcode`域解释成通用寄存器的编码。
Instruction	`r8`表示8位寄存器；`r/m8`表示8位寄存器或内存，具体由`mod`字段决定。

通用寄存器编码

接下来的两种形式也就不难看懂了：但这两种形式的Opcode都是一样的，难道不会出现歧义吗？

x86是通过指令一般格式中的 operand-size prefix来区分上面这两种形式的。

Operand-size prefix的编码是0x66，作用是指示当前指令需要改变操作数的长度。在 IA-32 中，通常如果这个前缀没有出现，操作数长度默认是 32 位；当这个前缀出现的时候，操作数长度就改变成16位。

换句话说，如果把一个开头为89 ...的比特串解释成指令，它就应该被解释成MOV r/m32, r32的形式；如果比特串的开头是66 89...，它就应该被解释成MOV r/m16, r16。

C语言宏定义

在C语言中，可以使用命令#define来定义宏。宏不负责检查语法的正确性。

1// 常规的宏
2#define PI 3.1415926
3// 带参数的宏
4#define putchar(x) putc(x, stdout)
5
6// 使用宏进行连接
7#define concat(x, y)   x ## y

例如：

1#define make_helper(name) int name(swaddr_t eip)

这个宏定义就代表了以下的两行代码是同一个代码，我们使用的时候看到的是上面部分函数，但是程序执行的时候实际上是在执行下面的函数（实际上就是同一个函数）：

1make_helper(exec)
2int exec(swaddr_t eip)

在C语言中，宏必须定义在一行中。

若需通过换行提高代码可读性，可使用\附在每行末尾。

NEMU的指令周期

取指

核心流程

 1void cpu_exec(volatile uint32_t n) {
 2    ...
 3
 4    for(; n>0; n--) {
 5        int instr_len = exec(cpu.eip);  // 执行当前%eip所指向的指令
 6        cpu.eip += instr_len;           // %eip指向下一条指令
 7    }
 8
 9    ...
10}

函数exec：

1make_helper(exec) {     //等价于 int exec(swaddr_t eip)
2    ops_decoded.opcode = instr_fetch(eip, 1);       // 表示读取一个字节的操作码
3    return opcode_table[ops_decoded.opcode](eip);   // 返回一个函数 
4}

其中，函数instr_fetch()负责取指：

1static inline uint32_t instr_fetch(swaddr_t addr, size_t len) {
2    return swaddr_read(addr, len);
3}

instr_fetch()从eip处提取Opcode，存储到ops_decoded.opcode中。

译码

所有指令的规则如下：

内容	规则
指令	指令名称，具体由i386手册确定
形式	`i2r`，将立即数移动到寄存器 `i2rm`，将立即数移动到寄存器或内存 `r2rm`，将寄存器移动到寄存器或内存
操作数后缀	`b`表示操作数长度为8，`v`表示无法确定操作数长度，可能是16或32

通过opcode_table，根据提取到的Opcode找到对应的指令处理函数（如mov_i2r_v）。

执行

对于同一指令的不同形式，它们的执行阶段是相同的。如mov_i2rm和mov_rm2r，它们的执行阶段都是将源操作数存储到目标操作数中。
对于不同指令的同一种形式，它们的译码阶段是相同的。如mov_i2rm和sub_rm2r，它们的译码阶段都是识别出一个立即数和一个rm操作数。
对于同一条指令同一种形式的不同长度，它们的译码阶段和执行阶段都非常类似。如mov_i2rm_b，mov_i2rm_w和mov_i2rm_l。它们都是识别出一个立即数和一个rm操作数，然后把立即数存入rm操作数。

访存

访存指令

写回

指令执行完后，eip指向下一条指令。

编写指令的流程

编写指令模板文件xxx-template.h
① 在文件头尾分别包含cpu/exec/template-start.h和cpu/exec/template-end.h。
② 定义宏instr为指令名称。
③ 定义函数static void do_execute()，实现该指令的通用执行过程。
④ 定义helper函数
（1）若指令的译码方式在nemu/include/cpu/decode/decode.h中已经存在，那么可以考虑使用宏 make_instr_helper()来构造helper函数（大部分 helper 函数都可以通过这种方式构造）。
（2）否则可以考虑添加相应的译码函数或者不使用make_instr_helper(), 而是直接使用make_helper()来定义helper函数，在函数体中直接进行译码，并调用do_execute()（可以参考nemu/src/cpu/exec/data-mov/xchg-template.h中的xchg_a2r指令类型。
编写指令实例化文件xxx.c
① 包含cpu/exec-helper.h。
② 通过分别将宏DATA_BYTE定义成 1, 2, 4, 分别对指令模板文件xxx-template.h进行实例化。
③ 若一个helper函数只会在某些操作数长度中用到，可以在xxx-template.h中通过条件编译的功能来指定（可以参考nemu/src/cpu/exec/data-mov/xchg-template.h中的xchg_a2r指令类型）。
④ 必要时通过宏make_helper_v()定义相应的重载函数，根据指令的操作数长度前缀确定调用哪一个helper函数。
编写指令头文件xxx.h，声明helper函数的原型。
在nemu/src/cpu/exec/all-instr.h中包含xxx.h。
在nemu/src/cpu/exec/exec.c中的opcode_table中填写相应的helper函数

编写指令的流程

进入PA2 →

NEMU-PART I

Mon, 08 Sep 2025 00:00:00 +0000

你说得对，但是NEMU是一个基于X86-64处理器模拟的IA-32操作系统。NEMU运行在一个被称作Docker的容器，在这里，被容器选中的人将被授予gcc，导引C语言之力。你将扮演一位名为Debug的神秘用户，编写众多C语言程序，在调试中找出FAIL的原因，同时逐步发掘Hit Bad Trap的真相。

目标：制作一个32位的操作系统

什么是NEMU

在X86-64处理器的机器上模拟一个32位操作系统（一个用来执行其它程序的程序！），它包括4个连贯的实验内容：

阶段	任务
PA1	简易调试器
PA2	指令系统
PA3	存储管理
PA4	中断与I/O

认识NEMU

NEMU的结构

调试器操作指令集

在nemu/src/monitor/debug/ui.c中定义了调试器的结构：

 1static struct {
 2    char *name;
 3    char *description;
 4    // 函数指针，可指向*name，*description
 5    int (*handler) (char *);     
 6} cmd_table [] = {
 7    { "help", "Display informations about all supported commands", cmd_help },
 8    { "c", "Continue the execution of the program", cmd_c },
 9    { "q", "Exit NEMU", cmd_q },
10
11    /* TODO: Add more commands */
12    /* 接下来若想定义新的操作，格式为
13    { "name", "description", function},
14    */
15};

几个有用的函数

函数	作用
`Log()`	`printf()`的升级版，专门用来输出调试信息，同时还会输出使用`Log()`所在的源文件，行号和函数，当输出的调试信息过多的时候，可以很方便地定位到代码中的相关位置
`Assert()`	`assert()`的升级版，当测试条件为假时，在`assertion fail`之前可以输出一些信息
`panic()`	用于输出信息并结束程序，相当于无条件的`assertion fail`
`swaddr_read()` / `swaddr_write()`	访问模拟的内存
`strtok()`	一个简单的字符串分割工具，用于解析命令
`sscanf()`	可以从字符串中读入格式化的内容, 使用它有时候可以很方便地实现字符串的解析

PA1：简易调试器

机器永远是对的！

未经过测试的每行代码永远是错误的！

RTFM！（阅读手册！）

实现正确的寄存器结构体

寄存器

在/nemu/include/cpu/reg.h中，原寄存器结构体定义为：

 1typedef struct {
 2    struct {
 3        uint32_t _32;
 4        uint16_t _16;
 5        uint8_t _8[2];
 6    } gpr[8];
 7
 8    /* Do NOT change the order of the GPRs' definitions. */
 9    uint32_t eax, ecx, edx, ebx, esp, ebp, esi, edi;
10    ... 
11} CPU_state;

使用结构体，每一个寄存器均独立存在，而X86系统的寄存器是共享的，例如 %eax 的后16位即为 %ax。因此应使用联合体的形式定义寄存器，这样对 %ax 操作时也会相应地改变 %eax 的值。

 1typedef struct {
 2    union {
 3        union {
 4            uint32_t _32;
 5            uint16_t _16;
 6            uint8_t _8[2];
 7        } gpr[8];
 8
 9        /* Do NOT change the order of the GPRs' definitions. */
10        struct {
11            uint32_t eax, ecx, edx, ebx, esp, ebp, esi, edi;
12        };	
13    };
14    ...
15} CPU_state;

实现调试器的功能

回顾nemu/src/monitor/debug/ui.c中对调试器的定义，需增加新的操作指令。

指令名	示例	功能
`si`	`si 10`	单步执行
`info`	`info r`	打印寄存器状态
	`info w`	打印监视点状态
`x`	`x N EXPR`	扫描内存
`p`	`p EXPR`	表达式求值
`w`	`w EXPR`	设置监视点
`d`	`d N`	删除监视点

 1static struct {
 2    char *name;
 3    char *description;
 4    int (*handler) (char *);
 5} cmd_table [] = {
 6    ...
 7    // 定义单步执行操作，关键字为 si，以此类推
 8    { "si", "Single step execution", cmd_si },
 9    { "info", "Show register or monitor's infomation", cmd_info },
10    { "x", "Scan Memory", cmd_x },
11    ...
12};

单步执行

在nemu/src/monitor/debug/ui.c中定义新的操作函数：

 1static int cmd_si(char *args) {
 2    char *arg = strtok(NULL, " ");  // 获取第二个字符
 3    int step = 0;   // 待操作步数
 4    int i = 0;
 5   
 6    if (arg == NULL) {
 7        cpu_exec(1);
 8    }
 9    else {
10        sscanf(arg, "%d", &step);  // 将arg转换为整型数
11        if (step <= 0) {
12            printf("Illegal input!");
13        }
14        else {
15            for(; i<step; i++) {
16                cpu_exec(1);
17            }
18        }
19    }
20    return 0;
21}

报错请查看：

使用循环时，循环变量的初始化应在循环结构之前，否则会报错：

1nemu/src/monitor/debug/ui.c:55: error: 'for' loop initial declarations are only allowed in C99 mode
2nemu/src/monitor/debug/ui.c:55: note: use option -std=c99 or -std=gnu99 to compile your code

读取函数应使用 sscanf。

打印寄存器状态

同理，定义操作函数cmd_info

 1static int cmd_info(char *args) {
 2    char *arg = strtok(NULL, " ");  // 获取第二个字符
 3    int i = 0;
 4
 5    if (*arg == 'r') {    // 参数为'r'时打印寄存器的值
 6        for(; i<8; i++) {
 7            // 打印eax, ecx, edx, ebx, esp, ebp, esi, edi 8个寄存器
 8            printf("%s\t\t", regsl[i]);     // 打印寄存器名称
 9            // 先打印16进制值，再打印10进制值（仿GDB）
10            // "\t" 为制表符，让输出更美观
11            printf("0x%08x\t\t%d\n", cpu.gpr[i]._32, cpu.gpr[i]._32);
12        }
13        // 打印%eip 寄存器
14        printf("eip\t\t0x%08x\t\t%d\n", cpu.eip, cpu.eip);  
15    }
16    else {
17        printf("Illegal input!\n");
18    }
19
20    return 0;
21}

扫描内存

 1static int cmd_x(char *args) {
 2    char *arg_1 = strtok(NULL, " ");    // 获取第1个参数 N
 3    char *arg_2 = strtok(NULL, " ");    // 获取第2个参数 EXPR
 4    int i = 0;
 5    int j = 0;
 6
 7    int N;
 8    swaddr_t address;	
 9
10    sscanf(arg_1, "%d", &N);
11    sscanf(arg_2, "%x", &address);	// 获取起始内存地址
12    
13    for(; i<N; i++) {
14        // 每行打印4个值
15        if (j%4 == 0) {
16            printf("0x%x:", address);
17        }
18
19        // 每4字节打印一个值
20        printf("0x%08x ", swaddr_read(address, 4));
21        address += 4;
22        j++;
23
24        // 4个值后换行
25        if (j%4 == 0) {
26            printf("\n");
27        }
28    }
29
30    printf("\n");
31    return 0;
32}

表达式求值

阶段1：词法分析

定义token

在/nemu/src/monitor/debug/expr.c中，观察token结构体，它包含两个数据type和str：

1typedef struct token {
2    int type;       // 记录token的类型
3    char str[32];   // 记录token的具体数据
4} Token;

容易发现，当token为+, -, &等单运算符时，只需要记录它的type即可，因为它们的type唯一标识了各自的具体数据。

在/nemu/src/monitor/debug/expr.c的列举类中，定义token的类型。

 1enum {
 2    NOTYPE = 256,
 3    NUM = 1,        // 10进制数
 4    REGISTER = 2,   // 寄存器
 5    HEX = 3,        // 16进制数
 6    EQ = 4,         // 相等
 7    NOTEQ = 5,      // 不相等
 8    OR = 6,         // 或运算
 9    AND = 7,        // 与运算
10    POINT,          // 指针
11    NEG
12
13    /* TODO: Add more token types */
14
15};

定义了枚举类后，相应的字段和数字就确定了唯一对应的关系。例如，type = NUM和type = 1均表示10进制整数。

定义正则表达式

在/nemu/src/monitor/debug/expr.c中，定义正则表达式：

 1static struct rule {
 2    char *regex;
 3    int token_type;
 4} rules[] = {
 5
 6    /* TODO: Add more rules.
 7     * Pay attention to the precedence level of different rules.
 8     */
 9
10    {" +",	NOTYPE},                // spaces 空格
11
12    {"\\+", '+'},                   // plus 运算符
13    {"\\-", '-'},
14    {"\\*", '*'},
15    {"\\/", '/'},
16
17    {"\\$[a-z]+", REGISTER},        // 数据
18    {"0x[0-9a-fA-F]+", HEX},
19    {"[0-9]+", NUM},
20
21    {"==", EQ},                     // equal
22    {"!=", NOTEQ},
23
24    {"&&", AND},                    // 逻辑运算符
25    {"\\|\\|", OR},
26    {"!", '!'},
27
28    {"\\(", '('},                   // 括号
29    {"\\)", ')'},
30};

正则表达式的作用是识别当前表达式的具体内容。例如，对于表达式4 + 3 * ( 2 - 1 )，正则表达式的识别结果应为：

识别token

识别token

在/nemu/src/monitor/debug/expr.c中的make_token函数可以帮助我们实现这一工作。

 1static bool make_token(char *e) {
 2    ...
 3    while(e[position] != '\0') {
 4        ...
 5        for(i = 0; i < NR_REGEX; i ++) {
 6            ...
 7            // 清空token值，防止每次运算相互干扰
 8            int j = 0;
 9            for(; j < 32; j++) {
10                tokens[nr_token].str[j] = '\0';
11            }
12            
13            // tokens.type的赋值函数
14            switch(rules[i].token_type) {
15                case 256: 
16                    break;
17
18                // 输入10进制数、寄存器、16进制数
19                case NUM:
20                    tokens[nr_token].type = NUM;
21                    strncpy(tokens[nr_token].str, &e[position - substr_len], substr_len);
22                    nr_token++;
23                    break;
24
25                // REGISTER，HEX，EQ，NOTEQ，AND，OR与之类似
26
27                ...
28                
29                // 输入单运算符
30                case '+':
31                    tokens[nr_token].type = '+';
32                    nr_token++;
33                    break;
34
35                // -, *, /, !, (, ) 与之类似
36
37                ...
38
39                default: 
40                    assert(0);
41            }
42            break;
43        }
44    }
45}

以其中一个为例：

1case NUM:
2    // token的类型为NUM
3    tokens[nr_token].type = NUM;
4    // 将sub_strlen长度的值存储到tokens.str
5    strncpy(tokens[nr_token].str, &e[position - substr_len], substr_len);
6    // 开始读取下一个token
7    nr_token++;
8    // 跳出switch循环
9    break;

阶段2：表达式求值

判断表达式括号匹配

 1bool check_parentheses(int p, int q) {
 2    int a = 0;          // 记录表达式token下标
 3    int i = 0, j = 0;   // 分别记录左、右括号总数
 4
 5    // 检查表达式首尾是否为括号
 6    if(tokens[p].type == '(' || tokens[q].type == ')') {
 7        for(a = p; a<=q; a++) {
 8            if(tokens[a].type == '(') {
 9                i++;
10            }
11            if(tokens[a].type == ')') {
12                j++;
13            }
14            if(a != q && i == j) {
15                // 排除例如 (a+b)) 这种情况
16                return false;
17            }
18        }
19
20        if(i == j) {
21            // 左右括号数量相等，正确
22            return true;
23        } 
24        else {
25            // 数量不等，错误
26            return false;
27        }
28    }
29
30    return false;
31}

寻找主操作符

dominant operator（主操作符）是表达式中最后参与运算的运算符，根据运算符优先级可知：

非运算符的token不是dominant operator。
出现在一对括号中的token不是dominant operator。注意到这里不会出现有括号包围整个表达式的情况，因为这种情况已经在check_parentheses()相应的if块中被处理了。
dominant operator的优先级在表达式中是最低的。这是因为dominant operator是最后一步才进行的运算符。
当有多个运算符的优先级都是最低时，根据结合性，最后被结合的运算符才是dominant operator。一个例子是1 + 2 + 3，它的dominant operator应该是右边的+。

找到主操作符后，表达式的运算可归结为主操作符两侧数的运算。这也就意味着该问题满足了分治的基本条件：一个问题可分解为若干个与原问题结构相同的子问题。

参阅此处：分治法

 1int dominant_operator(int p, int q) {
 2    int step = 0;
 3    int op = -1;
 4    int i = 0;  	// 记录token下标
 5    int pri = 0; 	// 记录当前操作符优先级
 6
 7    for(i = p; i <= q; i++) {
 8        if(tokens[i].type == '(') {
 9            step ++;
10        }
11        else if(tokens[i].type == ')') {
12            step --;
13        }
14
15        if(step == 0) {
16            if(tokens[i].type == OR) {
17                if(pri < 51) {
18                    op = i;
19                    pri = 51;
20                }
21            }
22            else if(tokens[i].type == AND) {
23                if(pri < 50) {
24                    op = i;
25                    pri = 50;
26                }
27            }
28            else if(tokens[i].type == EQ || tokens[i].type == NOTEQ) {
29                if(pri < 49) {
30                    op = i;
31                    pri = 49;
32                }
33            }
34            else if(tokens[i].type == '+' || tokens[i].type == '-') {
35                if(pri < 48) {
36                    op = i;
37                    pri = 48;
38                }
39            }
40            else if(tokens[i].type == '*' || tokens[i].type == '/') {
41                if(pri < 46) {
42                    op = i;
43                    pri = 46;
44                }
45            }	
46        }
47        else if(step < 0) {
48            return -2;
49        }
50    }
51    return op;
52}

递归计算表达式的值

这里运用的就是分治算法。

  1uint32_t eval(int p, int q) {
  2    int result = 0;
  3    int op = 0;
  4    int val1, val2;
  5
  6    // 表达式左侧超过右侧，错误
  7    if (p > q) {
  8        assert(0);
  9    }
 10
 11    // 表达式左侧等于右侧，说明为单个数字
 12    else if (p == q) {
 13        // 处理10进制数
 14        if (tokens[p].type == NUM) {
 15            sscanf(tokens[p].str, "%d", &result);
 16            return result;
 17        } 
 18
 19        // 处理16进制数
 20        else if (tokens[p].type == HEX) {
 21            int i = 2;
 22            while(tokens[p].str[i] != 0) {
 23                result *= 16;
 24                if (tokens[p].str[i] <= '9') {
 25                    // 16进制为0-9
 26                    result += tokens[p].str[i] - '0'; 	
 27                }
 28                else {
 29                    // 16进制为a-f
 30                    result += tokens[p].str[i] - 'a' + 10;	
 31                }
 32                i++;
 33            }
 34            return result;
 35        } 
 36
 37        // 处理寄存器
 38        else if (tokens[p].type == REGISTER) {
 39            if (!strcmp(tokens[p].str, "$eax")) {
 40                return cpu.eax;
 41            } 
 42
 43            // 剩下的寄存器使用相同的处理办法
 44            
 45            ...
 46
 47            else {
 48                return 0;
 49            }
 50        } 
 51        else {
 52            assert(0);
 53        }
 54    }
 55
 56    // 表达式两侧不等，但是括号匹配，去掉括号
 57    else if (check_parentheses(p, q) == true) {
 58         return eval(p + 1, q - 1);
 59    }
 60
 61    // 正常表达式
 62    else {
 63        // 寻找主操作符
 64        op = dominant_operator(p, q);
 65
 66        if (op == -2) {
 67            assert(0);
 68        } 
 69
 70        // 处理一元运算符
 71        else if (op == -1) {
 72            // 处理逻辑非运算，如 !1
 73            if (tokens[p].type == '!') {
 74                sscanf(tokens[q].str, "%d", &result);
 75                return !result;
 76            }
 77
 78            // 之后将在此处实现负数运算和指针解引用
 79
 80        }
 81
 82        // 计算主操作数两侧表达式值
 83        
 84        val1 = eval(p, op - 1);     // 计算主操作数左侧表达式
 85        val2 = eval(op + 1, q);     // 计算主操作数右侧表达式
 86
 87        switch (tokens[op].type) {
 88            case '+' : 
 89                return val1 + val2;	
 90
 91            // -, *, / , OR, AND, EQ, NOTEQ运算以此类推 
 92             
 93            ...
 94
 95            default : 
 96                assert(0);
 97        }
 98    }
 99    return 0;
100}

举例：

分治法求表达式的值

expr函数

 1uint32_t expr(char *e, bool *success) {
 2    if(!make_token(e)) {
 3        *success = false;
 4        return 0;
 5    }
 6
 7    /* TODO: Insert codes to evaluate the expression. */
 8
 9    int i;
10    for (i = 0; i < nr_token; i++){
11        if (tokens[i].type == '*' && (i == 0 || (tokens[i - 1].type != NUM && tokens[i - 1].type != HEX && tokens[i - 1].type != ')'))){
12            tokens[i].type = POINT;
13        }
14        if (tokens[i].type == '-' && (i == 0 || (tokens[i - 1].type != NUM && tokens[i - 1].type != HEX && tokens[i - 1].type != ')'))){
15            tokens[i].type = NEG;
16        }
17    }
18    return eval(0, nr_token - 1);
19
20    // panic("please implement me");
21    return 0;
22}

最终实现

在/nemu/src/monitor/debug/ui.c中写入cmd_p函数：

1static int cmd_p(char *args) {
2    bool *success = false;
3    int result = 0;
4    result = expr(args, success);
5    if(!success) {
6        printf("%d\n", result); 
7    }
8    return 0;
9}

表达式求值功能正式实现。

选做任务：实现负数运算和指针解引用

在eval函数中加入以下内容：

 1uint32_t eval(int p, int q) {
 2
 3    ...
 4
 5    // 正常表达式
 6    else {
 7       // 处理一元运算符
 8        else if (op == -1) {
 9
10            ...
11
12            // 处理带负数的表达式，如 1+ -1
13            if (tokens[p].type == NEG) {
14                sscanf(tokens[q].str, "%d", &result);
15                return -result;
16            }
17
18            // 实现指针解引用
19            else if (tokens[p].type == POINT) {
20                if (!strcmp(tokens[p + 2].str, "$eax")){
21                    result = swaddr_read(cpu.eax, 4);
22                    return result;
23                }
24
25                // 其余寄存器采用类似操作
26
27                ...
28            }
29        } 
30    }  
31}

监视点

新建监视点

在nemu/src/monitor/debug/watchpoint.c中，定义函数new_wp()：

 1// 从free_链表中返回一个空闲监视点
 2WP* new_wp() {
 3    WP *temp;
 4    temp = free_;           // free_链表的头节点作为返回值
 5    free_ = free_->next;    // free_链表的下一个节点成为头节点
 6    temp->next = NULL;      // 空闲监视点为head链表的尾节点
 7
 8    // 若head链表为空，返回的节点成为头节点
 9    if(head == NULL) {
10        head = temp;
11    }
12    // head链表不为空，寻找其尾节点
13    else {
14        WP *p;
15        p = head;
16        // 将返回的节点插入head链表的尾部
17        while (p->next != NULL) {
18            p = p->next;
19        }
20        p->next = temp;
21    }
22    return temp;
23}

示意图如下：

监视点链表

释放监视点

同理，在nemu/src/monitor/debug/watchpoint.c中定义：

 1// 释放监视点至free_链表
 2void free_wp(WP *wp) {
 3    if(wp == NULL) {
 4        assert(0);   // 返回节点为空
 5    } 
 6    else if (wp == head) {
 7        head = head->next;
 8    }
 9    else {
10        WP* temp = head;
11        // 找到head链表待删除节点的前一个节点
12        while(temp != NULL && temp->next != wp) {
13            temp = temp->next;
14        }
15        // 取消待删除节点与其后节点的连接
16        temp->next = wp->next;
17    }
18
19    // 待删除节点成为free链表的头节点
20    wp->next = free_;
21    free_ = wp;
22
23    // 清空待删除节点的内容
24    wp->result = 0;
25    wp->expr[0] = '\0';
26}

释放监视点实际上就是新建监视点的逆操作，换言之，就是将head链表待删除的节点变成free链表的头节点。

判断监视点是否触发

在nemu/src/monitor/debug/watchpoint.c中定义：

 1// 判断监视点是否触发
 2bool checkWP() {
 3    bool check = false;	 // 最终返回值
 4
 5    bool *success = false;  
 6    WP *temp = head;    // 从head链表的头节点开始遍历
 7    int expr_temp;
 8
 9    while(temp != NULL) {
10        expr_temp = expr(temp->expr, success);
11        if (expr_temp != temp->result){
12            check = true;
13            printf ("Hint watchpoint %d at address 0x%08x\n", temp->NO, cpu.eip);
14            temp = temp->next;
15            continue;
16            // 检测到监视点对应的值发生变化
17        }
18        temp->result = expr_temp;
19        temp = temp->next;
20    }	
21    return check;
22}

在/nemu/src/monitor/cpu-exec.c中加入以下内容：

1/* TODO: check watchpoints here. */
2
3// 链接外部函数
4extern bool checkWP();
5bool change = checkWP();
6if (change) {
7    nemu_state = STOP;
8}

打印监视点和删除监视点

 1// 打印所有监视点
 2void printf_wp(){
 3    WP *temp = head;
 4    if (temp == NULL){
 5        printf("No watchpoints\n");
 6    }
 7    while (temp != NULL){
 8        printf("Watch point %d: %s\n", temp->NO, temp->expr);
 9        temp = temp->next;
10    }
11}
12
13// 删除监视点
14WP* delete_wp(int p, bool *key){
15    WP *temp = head;
16    while (temp != NULL && temp->NO != p){
17        temp = temp->next;
18    }
19    if (temp == NULL){
20        *key = false;
21    }
22    return temp;
23}

加入调试器指令

最后在/nemu/src/monitor/debug/ui.c中加入指令函数：

 1// 打印监视器的值
 2static int cmd_info(char *args) {
 3	char *arg = strtok(NULL, " ");  // 获取第二个字符
 4
 5	...
 6
 7	else if(*arg == 'w') {
 8		extern void printf_wp();
 9		printf_wp();
10	}
11
12	...
13
14	return 0;
15}
16
17// 设置监视点
18static int cmd_w(char *args) {
19
20    extern WP* new_wp();
21    WP* temp = new_wp();
22
23    bool *success = false;
24    int result = 0;
25    result = expr(args, success);
26
27    if(!success) {
28        // 若表达式合法，将对应的值赋给temp这个新监视点
29        temp->result = result;
30        strcpy(temp->expr, args);
31    }
32
33    return 0;
34}
35
36// 删除监视点
37static int cmd_d(char *args) {
38    int p = 0;
39    bool key = true;
40    sscanf(args, "%d", &p);
41
42    // 记得链接外部函数
43    extern WP* delete_wp();
44    extern void free_wp();
45    WP *q = delete_wp(p, &key);
46
47    if (key){
48        printf("Delete watchpoint %d: %s\n", q->NO, q->expr);
49        free_wp(q);
50        return 0;
51    } 
52    else {
53        printf("No found watchpoint %d\n", p);
54        return 0;
55    }
56
57    return 0;
58}

思考题

思考题1：opcode_table到底是一个什么类型的数组？

解答

opcode_table数组是一个函数指针数组。

思考题2（1）：在cmd_c()函数中, 调用cpu_exec()的时候传入了参数-1 , 你知道为什么吗?

解答

-1是无符号类型最大的数字，所以函数里的for循环可以执行所有指令。

思考题2（2）：框架代码中定义wp_pool等变量的时候使用了关键字static，static在此处的含义是什么? 为什么要在此处使用它?

解答

static在此处的含义是静态全局变量，该变量只能被本文件中的函数调用，并且是全局变量，而不能被同一程序其他文件中的函数调用，使用static是为了避免它被误修改。

思考题3-1：EFLAGS寄存器中的CF位是什么意思?

解答

i386手册里P34页中和参阅附录c提到，CF是进位标志。

EFLAGS寄存器

思考题3-2：ModR/M字节是什么?

解答

P241-243页。ModR/M 由 Mod，Reg/Opcode，R/M 三个部分组成。 Mod 是前两位，提供寄存器寻址和内存寻址， Reg/Opcode为3-5位，如果是Reg表示使用哪个寄存器，Opcode表示对group属性的Opcode进行补充； R/M为6-8位，与mod结合起来会得到8个寄存器和24个内存寻址。

ModR/M

思考题3-3：mov指令的具体格式是怎么样的?

解答

P345页，格式是DEST ← SRC。

mov指令

思考题3-4：完成 PA1 的内容之后, nemu目录下的所有.c和.h和文件总共有多少行代码? 你是使用什么命令得到这个结果的？和框架代码相比, 你在PA1中编写了多少行代码？你可以把这条命令写入Makefile中, 随着实验进度的推进, 你可以很方便地统计工程的代码行数, 例如敲入 make count就会自动运行统计代码行数的命令。再来个难一点的, 除去空行之外, nemu目录下的所有.c和.h文件总共有多少行代码？

解答

通过find . -name "*[.h/.c]" | xargs wc -l命令，得到4376行。和框架代码4197行相比, 我在 PA1中编写了606行代码。

通过find . -name "*[.h/.c]" | xargs grep "^." | wc -l命令计算去除空行的所有.c .h文件得到了3900行代码。

make count指令如下：

make count

@find nemu/ -name “.c” -o -name “.h” | xargs cat | grep -v ^$$ | wc -l

思考题3-5：打开工程目录下的Makefile文件, 你会在CFLAGS变量中看到 gcc 的一些编译选项。请解释 gcc 中的-Wall和-Werror有什么作用? 为什么要使用-Wall和-Werror？

解答

-Wall使GCC编译后显示所有的警告信息。-Werror会将将所有的警告当成错误进行处理，并且取消编译操作。使用-Wall和-Werror就是为了找出可能存在的错误，尽可能地避免程序运行出错，优化程序。

至此，PA1全部完成

PA2预备知识

正则表达式

Thu, 10 Oct 2024 00:00:00 +0000