本文属于《 TinyEMU模拟器基础系列教程》之一，欢迎查看其它文章。

1 访存指令介绍

访存指令，主要有，如下这些：

在RISC-V架构中，CPU在处理与内存访问相关的这些指令时，会发出对某地址的访问。这些指令通常涉及加载（Load）和存储（Store）操作，用于从内存中读取数据或将数据写入内存。

本文旨在，通过分析访存指令的执行，以理解CPU在执行指令时，是如何发出以及处理这些地址请求的。

2 指令译码

我们以ld指令（读取）为例，进行说明。

指令形式：ld rd, imm(rs1)
功能说明：rd = M[rs1+imm][0:63]，表示从内存地址（rs1+imm）中，加载一个64位值到寄存器rd

取指译码，是在riscv_cpu_template.h的glue函数中完成，代码如下：

static void no_inline glue(riscv_cpu_interp_x, XLEN)(RISCVCPUState *s,int n_cycles1)
{for(;;) {...// 取指insn = get_insn32(code_ptr); // 译码执行funct3 = (insn >> 12) & 7;imm = (int32_t)insn >> 20;addr = s->reg[rs1] + imm;switch(funct3) {...case 3: /* ld */{uint64_t rval;if (target_read_u64(s, &rval, addr))goto mmu_exception;val = (int64_t)rval;}break;}...s->reg[rd] = val;}
}

我们在riscv_cpu.c的target_read_slow函数中，打断点：

b riscv_cpu.c:308 if addr>=0x80000000

再通过调用堆栈，回溯到glue函数中。
当TinyEMU对ld指令，进行译码执行时：

• 从机器码insn中，提取imm；
• 从机器码insn中，提取rs1，并计算出访存地址addr = reg[rs1] + imm。

然后，通过调用target_read_u64函数，读取addr地址内容，放入rd寄存器中。

这里，例子中，各值如下：

• insn == 0xa767b783
• rs1 == 0xf
• imm == 0xfffffa76
• addr == 0x80006d88

这里得到的addr，可能是虚拟地址，也可能是物理地址，我们统一当成虚拟地址看待即可，后续会进行转换。

3 地址转换

3.1 VA与PA

虚拟地址（Virtual Address）：

• 处理器生成的地址，用于在软件层面访问内存。虚拟地址空间是程序看到的内存视图，它可能远大于实际的物理内存大小。虚拟地址的主要目的是提供内存保护（通过隔离不同进程的地址空间）和简化内存管理（通过允许操作系统透明地管理物理内存）。

• 在 RISC-V 系统中，虚拟地址通常通过内存管理单元（MMU）进行转换，以映射到物理地址。MMU 负责执行虚拟到物理地址的转换，同时检查访问权限和页面有效性。

物理地址（Physical Address）：

• 内存芯片实际使用的地址，用于定位特定的内存位置。物理地址空间是实际可用的 RAM 的大小，它受到硬件和操作系统的限制。

• 在 RISC-V 中，当处理器需要访问内存时，它会生成一个虚拟地址。然后，MMU 会将这个虚拟地址转换为物理地址，处理器使用这个物理地址来访问实际的 RAM。

只有进入OS阶段，开启MMU后，才支持VA；在此之前，所有的访问全都为PA。

3.2 VA转PA

target_read_u64函数，是通过宏来定义的，在riscv_cpu_priv.h中：

#define TARGET_READ_WRITE(size, uint_type, size_log2)                   \
static inline __exception int target_read_u ## size(RISCVCPUState *s, uint_type *pval, target_ulong addr)                              \
{\uint32_t tlb_idx;\tlb_idx = (addr >> PG_SHIFT) & (TLB_SIZE - 1);\if (likely(s->tlb_read[tlb_idx].vaddr == (addr & ~(PG_MASK & ~((size / 8) - 1))))) { \*pval = *(uint_type *)(s->tlb_read[tlb_idx].mem_addend + (uintptr_t)addr);\} else {\mem_uint_t val;\int ret;\ret = target_read_slow(s, &val, addr, size_log2);\if (ret)\return ret;\*pval = val;\}\return 0;\
}\
...TARGET_READ_WRITE(64, uint64_t, 3)

首先，会查询TLB中，是否有addr（VA）缓存：

• 有的话，直接取出addr对应的PA。
• 没有的话，则调用target_read_slow函数，继续查询。

在target_read_slow函数中，再调用get_phys_addr函数查询。

int target_read_slow(RISCVCPUState *s, mem_uint_t *pval,target_ulong addr, int size_log2)
{...// part1if (get_phys_addr(s, &paddr, addr, ACCESS_READ)) {s->pending_tval = addr;s->pending_exception = CAUSE_LOAD_PAGE_FAULT;return -1;}...
}

如果查询失败，会触发page fault异常，处理器接受到该异常后，会自动创建VA对应的页表。

static int get_phys_addr(RISCVCPUState *s,target_ulong *ppaddr, target_ulong vaddr,int access)
{// 当前是否运行在M模式if (priv == PRV_M) {*ppaddr = vaddr;return 0;}// 读取satp寄存器mode = (s->satp >> 60) & 0xf;if (mode == 0) {/* bare: no translation */*ppaddr = vaddr;return 0;} else {/* sv39/sv48 */levels = mode - 8 + 3;pte_size_log2 = 3;vaddr_shift = MAX_XLEN - (PG_SHIFT + levels * 9);if ((((target_long)vaddr << vaddr_shift) >> vaddr_shift) != vaddr)return -1;pte_addr_bits = 44;}// 页表查询pte_addr = (s->satp & (((target_ulong)1 << pte_addr_bits) - 1)) << PG_SHIFT;pte_bits = 12 - pte_size_log2;pte_mask = (1 << pte_bits) - 1;for(i = 0; i < levels; i++) {vaddr_shift = PG_SHIFT + pte_bits * (levels - 1 - i);pte_idx = (vaddr >> vaddr_shift) & pte_mask;pte_addr += pte_idx << pte_size_log2;if (pte_size_log2 == 2)pte = phys_read_u32(s, pte_addr);elsepte = phys_read_u64(s, pte_addr);//printf("pte=0x%08" PRIx64 "\n", pte);if (!(pte & PTE_V_MASK))return -1; /* invalid PTE */paddr = (pte >> 10) << PG_SHIFT;xwr = (pte >> 1) & 7;if (xwr != 0) {if (xwr == 2 || xwr == 6)return -1;/* priviledge check */if (priv == PRV_S) {if ((pte & PTE_U_MASK) && !(s->mstatus & MSTATUS_SUM))return -1;} else {if (!(pte & PTE_U_MASK))return -1;}/* protection check *//* MXR allows read access to execute-only pages */if (s->mstatus & MSTATUS_MXR)xwr |= (xwr >> 2);if (((xwr >> access) & 1) == 0)return -1;need_write = !(pte & PTE_A_MASK) ||(!(pte & PTE_D_MASK) && access == ACCESS_WRITE);pte |= PTE_A_MASK;if (access == ACCESS_WRITE)pte |= PTE_D_MASK;if (need_write) {if (pte_size_log2 == 2)phys_write_u32(s, pte_addr, pte);elsephys_write_u64(s, pte_addr, pte);}vaddr_mask = ((target_ulong)1 << vaddr_shift) - 1;*ppaddr = (vaddr & vaddr_mask) | (paddr  & ~vaddr_mask);return 0;} else {pte_addr = paddr;}}return -1;
}

这里有2种情况：

• 如果运行在M模式下（运行固件/bios/bootloader），尚未启用MMU时，VA==PA，无需转换。
• 如果运行在S模式下（运行OS），MMU已启用，则读取satp寄存器，并根据该寄存器中，保存的第一级页表基址，进行页表查询，最后得到PA。

具体页表查询原理，我们暂时不关心，只需要理解：

• OS启动过程中，会创建第一级页表，并将其基址保存到satp寄存器，开启MMU。
• 页表，是由OS建立的，保存在物理内存中，我们查询页表，其实就是在遍历内存，以便得到VA对应的PA。

4 判断地址空间范围

int target_read_slow(RISCVCPUState *s, mem_uint_t *pval,target_ulong addr, int size_log2)
{...// part2pr = get_phys_mem_range(s->mem_map, paddr);...
}
PhysMemoryRange *get_phys_mem_range(PhysMemoryMap *s, uint64_t paddr)
{PhysMemoryRange *pr;int i;for(i = 0; i < s->n_phys_mem_range; i++) {pr = &s->phys_mem_range[i];if (paddr >= pr->addr && paddr < pr->addr + pr->size)return pr;}return NULL;
}

上面转换得到的PA，然后，再调用get_phys_mem_range函数，判断PA到底属于以下地址空间中哪个范围。

也就是说，上面得到的PA地址，可能为0x0~0x88000000范围内的任意地址。

5 执行访存操作

int target_read_slow(RISCVCPUState *s, mem_uint_t *pval,target_ulong addr, int size_log2)
{...// part3else if (pr->is_ram) {tlb_idx = (addr >> PG_SHIFT) & (TLB_SIZE - 1);ptr = pr->phys_mem + (uintptr_t)(paddr - pr->addr);s->tlb_read[tlb_idx].vaddr = addr & ~PG_MASK;s->tlb_read[tlb_idx].mem_addend = (uintptr_t)ptr - addr;switch(size_log2) {...case 3:ret = *(uint64_t *)ptr;break;}} else {offset = paddr - pr->addr;if (((pr->devio_flags >> size_log2) & 1) != 0) {ret = pr->read_func(pr->opaque, offset, size_log2);}
#if MLEN >= 64else if ((pr->devio_flags & DEVIO_SIZE32) && size_log2 == 3) {/* emulate 64 bit access */ret = pr->read_func(pr->opaque, offset, 2);ret |= (uint64_t)pr->read_func(pr->opaque, offset + 4, 2) << 32;}
#endif}*pval = ret;
}

这里分为2个分支，看PA是否为RAM地址（Low Dram和High Dram）。

• 访问RAM内存
• 访问非RAM（设备）内存

5.1 访问RAM内存

若PA为RAM地址时，进行以下计算：

ptr = pr->phys_mem + (uintptr_t)(paddr - pr->addr);

（1）计算出欲访问物理地址paddr，相对于RAM物理基址pr->addr的偏移，也就是paddr - pr->addr。
（2）然后，再加上模拟器分配给RAM的内存基址（其实是Host机器的虚拟地址），也就是pr->phys_mem + (uintptr_t)(paddr - pr->addr)。
（3）得到的结果ptr，就是指令欲访问VA，对应的ram内存地址。此时，还会将VA与PA对应关系，更新到TLB中，下次就可以直接查询TLB，而不用查页表了。

最后，通过指针，就可以取出相应长度内容了，通过pval将值返回。

5.2 访问非RAM（设备）内存

若PA为设备地址时，执行以下操作：

• 计算出欲访问物理地址paddr，相对于该设备物理基址pr->addr的偏移，也就是offset = paddr - pr->addr。
• 然后，调用该设备对应的read_func函数，ret = pr->read_func(pr->opaque, offset, ...)，以便读取该offset处的内容。
• 最后，读取到的值，通过pval返回。

比如CLINT，在riscv_machine_init函数中，划分地址空间时，就将clint_read、clint_write函数指针进行了保存（读写函数、设备地址范围等，进行了捆绑），以便在后续，需要处理该设备地址范围内访问时，可以直接调用该函数。

static VirtMachine *riscv_machine_init(const VirtMachineParams *p)
{...// 划分地址空间cpu_register_device(s->mem_map, CLINT_BASE_ADDR, CLINT_SIZE, s,clint_read, clint_write, DEVIO_SIZE32);cpu_register_device(s->mem_map, PLIC_BASE_ADDR, PLIC_SIZE, s,plic_read, plic_write, DEVIO_SIZE32);cpu_register_device(s->mem_map, HTIF_BASE_ADDR, 16,s, htif_read, htif_write, DEVIO_SIZE32);...
}

比如，PA为0x2004000，写操作的话，那么就是，表示向CLINT中mtimecmp（定时器比较寄存器）写入一个值。mtimecmp是一个内存映射寄存器，定义在CLINT中断控制器中。

clint_write函数定义，如下：

static void clint_write(void *opaque, uint32_t offset, uint32_t val,int size_log2)
{...switch(offset) {case 0x4000:m->timecmp = (m->timecmp & ~0xffffffff) | val;riscv_cpu_reset_mip(m->cpu_state, MIP_MTIP);break;...}
}

此时，计算出的offset为0x4000，然后调用riscv_cpu_reset_mip函数，将val值写入了mip寄存器。

其他的设备，也是类似的原理。

6 访存处理流程图

因此，归根到底，CPU在执行指令时，发出的访问地址：

• 如果在RAM范围内，表示访问物理内存；
• 如果在设备范围内，表示访问该设备内部的寄存器或内存资源。

关于访存的处理过程，整理为流程图，如下：