IC的帆哥 - RISCV 2022-08-19T19:28:01+08:00 Typecho https://icfgblog.com/index.php/feed/atom/category/riscv/ <![CDATA[Gem5 Debug]]> https://icfgblog.com/index.php/riscv/351.html 2022-08-19T19:28:01+08:00 2022-08-19T19:28:01+08:00 icfg66 http://www.icfgblog.com Gem5的源码在src文件夹,涉及很多内容,如果希望修改某些模块,或增加某些功能,总感觉无从下手:一方面对Gem5的代码组织不清楚,另一方面对硬件结构不熟悉。

经过一番探索,逐渐有些感觉,特来记录一波。

以O3 CPU为例,主要有Fetch、Decode、Rename、Execute、Writeback、Commit这几级流水。源码主要集中在src/cpu/o3。 image.png

分析工具主要有两类,一类是静态分析工具,它可以查看函数的调用关系,理清代码的不同层级。

  • vscode
  • understand
  • grep -nr "function"

另一类是动态分析工具,它可以跟踪“O3 CPU”运行的时序,更进一步了解软件代码的运行。

  • gdb
  • gdb可视化工具gdbgui

一、静态分析

“Understand” 是收费软件,但网上很多破解版,而且只有windows版本。新建工程,导入源码之后,会自动分析这些函数的调用和被调用关系。vscode也有函数跳转功能,两者可以结合着看。

另一方面,因为Gem5是混合了python(主要为了连线和传参)和C++(基本硬件的建模),所以有些函数没法跳转,这时候用可以用grep搜索。 image.png

二、动态分析

如果想查看一些中间变量,用print大法需要重新编译,非常耗时,这时用gdb断点调试可以事半功倍。

gdb --args build/X86/gem5.opt configs/example/se.py -c test_ban/hello

gdb常用指令

b fetch.cc:1024 # 打断点
info b # 查看断点
d 编号# 删除编号
r  # run
c # continue
n # next line
s # 进入子函数
si # step inst
p param #打印变量

如果有图形界面,gdbgui工具可以更方便调试,

 pip install gdbgui #安装gdbgui

~/.local/bin/gdbgui -p 10001 -r "a.out"  # 浏览器本地127.0.0.1:10001端口打开即可

~/.local/bin/gdbgui -p 10001 -r --args ./build/RISCV/gem5.debug --debug-flags=O3CPUAll debug-start=78000 configs/example/se.py --cpu-type=O3CPU --l1d_size=32kB --l1i_size=32kB --caches -m 230000 -c /home/hezf/Documents/OS_test/gem5_pro/testbench/hello/hello.elf

浏览器打开本地端口10001,可以看到调试界面,更多的调试指南可以查看官网。

image.png

三、O3 CPU代码分析

1.仿真前的初始化

src/sim/main.cc: importer() -> importInit()-> initAll()
src/python/embedded.cc: initAll()
src/sim/init.cc: initAll()-> pybind_init_event()
src/python/pybind11/event.cc: pybind_init_event() -> simulate()
src/sim/simulate.cc: simulate() -> doSimloop() -> serviceOne()
src/sim/eventq.cc: serviceOne() -> eventq.hh:event->process()

2. 各级流水线

image.png

image.png

image.png

]]>
<![CDATA[Gem5 O3 可视化]]> https://icfgblog.com/index.php/riscv/349.html 2022-08-01T09:32:38+08:00 2022-08-01T09:32:38+08:00 icfg66 http://www.icfgblog.com Gem5是研究体系结构的硬件仿真工具,官方也提供了较详细的入门文档gem5 documentation。

在研究超标量乱序CPU时,Gem5也提供了可视化样例gem5: Visualization

./build/RISCV/gem5.opt --debug-flags=O3PipeView --debug-start=78000 --debug-file=trace.out configs/example/se.py --cpu-type=O3CPU --caches --cmd=tests/tests-progs/hello/bin/riscv/linux/hello -m 230000

这个脚本会产生trace.out文件,记录tick(ps) 78000到230000时段的流水线信息。再通过python脚本生成pipeline.out文件,就可以通过less查看了

./util/o3-pipeview.py -c 500 -o pipeview.out --color m5out/trace.out
less -r pipeview.out

image.png

但这个方式存在两个问题:第一是可视化界面实在不友好,第二是很难找到main函数的核心代码。

Konata

Konata是开源的Gem5 O3 pipeline可视化工具,只需要获得trace.out文件,再将其导入软件,就可以看大美观的流水线。 image.png

但要找到main里的核心代码也不容易,main之前需要很多的铺垫: 从_start函数运行很久才能到主函数 image.png

当然可以通过设置记录的起始时间解决,但还是不太方便。

编译链接

无意中刷到JYY老师的操作系统:系统调用可以通过ld -e 指定编译器从哪个函数开始执行。

比如一段简单的代码:

// hello.c
int main(){
  int sum = 0;
  for(int i = 0;i<5;i++){
    sum+= i*i;
  }
  while(1);
  //return 0;
}

编译时可以先生成可重定向文件,在ld -e指定从main函数开始执行。

# 生成可重定向文件
riscv64-linux-gnu-gcc -c hello.c 
# 指定从main函数开始执行
riscv64-linux-gnu-ld -e main hello.o -o hello.elf
# 生成可读的汇编文件
riscv64-linux-gnu-objdum -S -D hello.elf > hello.dump

查看汇编代码,可以看到只有短短的几行,没有_start函数。

image.png

再运行gem5获得trace.out文件,可以看到确实从第一条指令addi sp,sp,-32开始执行,并呈现完整的5个循环。

image.png

image.png

最后需要注意的是,这里没有return 0,目的是为了运行gem5不产生错误信息。如果将while(1)替换为return 0,那么运行会报错Segemtion fault (core dumped),因为return前没有初始化堆栈,造成错误的地址访问。

测试时可以先加return 0,确定退出的仿真时间,再换成while(1), 根据仿真时间来结束仿真。

]]>
<![CDATA[Difftest踩坑笔记(二)]]> https://icfgblog.com/index.php/software/341.html 2022-06-12T19:32:00+08:00 2022-06-12T19:32:00+08:00 icfg66 http://www.icfgblog.com 如何搭建自己的Difftest框架呢?一生一芯仓库的wiki给了优秀的回答,但要全搭起来还是不容易,同样是两个原因:不够保姆、版本。

1. 初始化仓库

首先clone一生一芯官网的初始化仓库。

git clone -b ysyx2204 git@github.com:OSCPU/ysyx-workbench.git
cd ysyx-workbench
# 初始化chisel环境
bash init.sh npc-chisel

2. Difftest文件夹

NutShell@3a8832e下的difftest拷贝到npc目录下,和playground同级。同时需要修改npc/build.sc文件,才能调用difftest中的clas,但需要修改difftest的版本至3.5.0-RC1,不然会报错。 参考以下三个Issue:issue8,issue9,issue10

// import Mill dependency
import mill._
import mill.scalalib._
import mill.scalalib.scalafmt.ScalafmtModule
import mill.scalalib.TestModule.Utest
// support BSP
import mill.bsp._

object playground extends ScalaModule with ScalafmtModule { m =>
  override def scalaVersion = "2.12.13"
  override def scalacOptions = Seq(
    "-Xsource:2.11",
    "-language:reflectiveCalls",
    "-deprecation",
    "-feature",
    "-Xcheckinit",
    // Enables autoclonetype2 in 3.4.x (on by default in 3.5)
    "-P:chiselplugin:useBundlePlugin"
  )
  override def ivyDeps = Agg(
    ivy"edu.berkeley.cs::chisel3:3.5.0-RC1",
  )
  override def scalacPluginIvyDeps = Agg(
    ivy"edu.berkeley.cs:::chisel3-plugin:3.4.3",
    ivy"org.scalamacros:::paradise:2.1.1"
  )
  object test extends Tests with Utest {
    override def ivyDeps = m.ivyDeps() ++ Agg(
      ivy"com.lihaoyi::utest:0.7.10",
      ivy"edu.berkeley.cs::chiseltest:0.3.3",
    )
  }
  override def moduleDeps = super.moduleDeps ++ Seq(difftest)
}

object difftest extends ScalaModule {
  override def scalaVersion = "2.12.13"
  override def millSourcePath = os.pwd / "difftest"
  override def ivyDeps = Agg(
    ivy"edu.berkeley.cs::chisel3:3.5.0-RC1"
  )
}

3.单周期CPU

CPU的chisel模板参考oscpu-chisel-framework,需要做两方面改动:

  • 添加二读一写端口的ram1w2r.v:difftest/src/test/vsrc/common/ram1w2r.v。因为单周期一般区分imem和dmem。
  • 修改difftest的接入时序,这点比较繁琐,也花了很长时间debug。

时序主要修改了两个文件:InstFetch.scala 和 Core.scala

  • InstFetch.scala 添加pc_valid信号,告诉difftest这是一个有效提交指令,然后Nemu运行一条指令,再对比各自的寄存器。如果没这样做,第一条提交的指令会出错。

  • Core.scala添加RegNext做延时,这是调节时序的。寄存器的更新在指令的下一拍,传给difftest的pc需要和寄存器的更新同步。这样difftest接受指令提交后,Nemu运行一条指令,然后比对各自的寄存器。

4. 测试BIN文件

测试BIN文件在这个仓库可以找到,感觉是之前一生一芯的开源仓库,不知为什么原官方仓库不见了。

BIN文件生成的时候需要加编译选项-march=rv64g -mabi=lp64d,否则默认会编译出压缩指令,运行时会报错(暂时没有实现压缩指令解码器)。

最后 npc目录下的Makefile 生成emu时,需要加上EMU_CXX_EXTRA_FLAGS="-DFIRST_INST_ADDRESS=0x80000000",告诉nemu在0x80000000的位置开始取值。

5. 小结

本想专心写硬件,没想到花了那么多时间大环境,print大法排查了很久,附上调试好的仓库,希望jyy老师不会打我。系统环境是Ubuntu20.04的虚拟机。如果用wsl,有可能需要改动一些地方。

git clone https://gitee.com/he_zhifan/ysyx-workbench.git
cd ysyx-workbench
git submodule update --init --recursive
bash install_tools.sh
git checkout v0.5

cd nemu
make riscv64-xs-ref_defconfig
make

cd ../npc
make sim

默认仿真addi-riscv-tests.bin文件,会停在0x8000050的位置,因为lui指令还没实现。li,mov是addi的伪指令,bne虽然没实现,但默认下条指令是pc+4,也能通过。 image.png

附

附上difftest的函数跳转图 入口函数:difftest/src/test/csrc/verilator/main.cpp

main.cpp
	|-构造emu
		|-调用构造函数:reset 10 cycles,init_ram,init_flash
	|-调用emu->execute
		|-init_difftest
          *****while*****
		  single_cycle运行dut
		  difftest_step()运行nemu        emu.cpp :426(difftest.cpp:88)
				|-do_first_instr_commit()   difftest.cpp :103(354)
					do_instr_commit()         difftest.cpp :148(222)
					*compare regs             difftest.cpp :178              
					|-打印对比信息             difftest.cpp :180
						state->dispaly:打印Commit Group         difftest.cpp:614
						Difftes display: Instr Trace, REF Regs  difftest.cpp:608
						display_trapinfo打印trap位置,和指令统计结果
					|-打印错误的寄存器
          ****end while***
		  display_trapinfo()             emu.cpp:495(569)

打印verilog里面的日志信息
]]>
<![CDATA[Difftest踩坑笔记(一)]]> https://icfgblog.com/index.php/software/340.html 2022-06-12T19:31:00+08:00 2022-06-12T19:31:00+08:00 icfg66 http://www.icfgblog.com 一、Difftest简介

Difftest是差分测试框架,有什么用呢?高性能CPU的设计需要做复杂的测试,传统的测试方法运行较慢,而且出了问题很难定位,Difftest就是为了解决这两个问题,基本的逻辑也不难: image.png

  • 处理器运行一条指令
  • 模拟器运行相同的指令
  • 比较两者的状态

为什么能运行更快呢?最著名的模拟器当属Qemu,此外伯克利也提供了针对riscv的模拟器spike,但两者的实现都比较复杂,中科院采用了南大的开发的轻量级教学模拟器Nemu。因为只需要在指令层面做仿真,因此有很大的优化空间。

为什么能容易定位bug?因为每运行一条指令,都会对比关键寄存器的数值,做到动态实时比对,spike需要最终运行完才能比对。计算机的运行就是不同状态的转移,这个观点非常精妙。

那么,这么好的框架如何用起来呢?

二、NutShell difftest

NutShell,Xiangshan都有difftest相关的介绍,也提供了Difftest使用指南,但真正搭起来还真不容易。

  • 第一是因为这些资料比较零散,没有完整的“保姆级教程”。
  • 第二是版本、版本、版本,包括chisel3、difftest、Nutshell等版本,不同介绍的时间点不一样,复现起来也不简单。

为了有个初步的认识,先简单体验NutShell的difftest框架。

1.找对版本

进入xs-env工程,下载对应的NutShell@3a8832e和NEMU@26c7e50版本,参考仓库的setuptools.sh安装比要的软件。如verilator v4.218等。

2.Run起来

NutShell的文档对difftest的使用介绍不多,但有个彩蛋给出了完整的操作流程:nutshell/difftest/.github/workflows/main.yml。这是持续集成框架:在项目开发的时候,每次commit提交,会在云端github提供的服务器Docker上按照main.yml的规则运行新提交代码,对新代码进行自动测试。

参照main.yml不难跑通,如果遇到报错,根据提示不难定位:比如需要在difftest/verilator.mk文件中,将clang++换成g++;或者注释掉41行的VEXTRA-FLAGS += - - instr-count-dpi 1;或者装一些依赖库。

# git clone 对饮版本的NEMU和NutShell
cd NEMU 
make riscv64-xs-ref_defconfig
make

cd NutShell
source ./env.sh
make clean
make emu EMU_CXX_EXTRA_FLAGS="-DFIRST_INST_ADDRESS=0x80000000"
./build/emu -b 0 -e 0 -i ./ready-to-run/microbench.bin

如果想看看difftest的效果,可以修改NutShell中ALU单元的某个运算符,再生成emu并运行。

Idea下打开工程全红怎么办?最新的NutShell用mill构建,而不是sbt,因此目录下没有build.sbt,而是build.sc,,如果直接用idea.sh打开,自动检查功能用不了,不能快乐跳转。Mill的官网提供了IntelliJ Support的解决方案:

mill mill.scalalib.GenIdea/idea

三、小结

Difftest是CPU开发过程中的高效调试框架,NutShell下跑通Difftest需要非常注意版本,参考持续集成main.yml能很容易跑通。

如果自己从头写CPU,该如果接入Difftest呢?请看下回分解

]]>
<![CDATA[捡到RoCC的贝壳]]> https://icfgblog.com/index.php/riscv/338.html 2022-06-03T16:22:55+08:00 2022-06-03T16:22:55+08:00 icfg66 http://www.icfgblog.com Chipyard Docker——坑外有坑 搭好chipyard的环境之后,便开始做一些简单开发,Berkeley提供了用户定制协处理器的接口,方便在Rocketchip上拓展一些自定义的硬件加速模块。

一、RoCC入门资料

整理过一些RoCC(Rocket of Costum)开发的实用资料:

  1. RoCC最大公约数
  2. Design and programming of a coprocessor for a RISC-V architecture

二、RoCC模块

写了一个矩阵向量乘法的加速器,增加了三条核心拓展指令:

  • push : 从内存传入向量至RoCC
  • mvm : 执行矩阵向量乘法(权重矩阵已提前写好)
  • save : 从RoCC传出结果至内存

完成功能测试之后,希望性能,于是在RoCC_mvm指令前后添加时钟数计时,结果发现打印的周期数远远小于估算的周期数,最终计算结果是对的。 image.png

难道gcc -O2 优化改变了指令执行顺序?反汇编查看执行的指令,确实也是这个顺序!为之奈何?——波形时序图。

调出几个关键信号:

  • inst_real: 实际执行的指令
  • RoCC : RoCC内部状态机状态
  • inst_pre:这是自己预想的时序图 图片1.png

发现执行mvm指令之后,RoCC进入mvm状态,但计算还没结束,cpu紧接着执行后面的读时钟和打印指令,最后计算完毕之后,才执行save,保证了计算结果的正确性,但计时不正确。

三、捡到贝壳

之前一致觉得RoCC运算的时候,流水线会停滞,没想到CPU还是可以做其他事情的,那么是否可以在RoCC计算的时候,CPU做一些准备数据的工作呢,这样可以充分利用计算资源,实现完美的时间管理! image.png

四、知其所以

为什么是这样的时序呢?之前做芯来科技E203协处理器的时候,确实和预想的逻辑一样,RocketChip为什么不同呢?看内存一致性模型相关的资料,结合官方手册The RISC-V Instruction Set Manual,找到一些线索。

内存一致性模型是描述多核访存的时候,应该遵守什么样的规则,不同的规则对应不同的模型,不同的模型在性能、编程难度等方面也不同。访存的读写指令在流水线上是多周期完成的,为了避免出错,可以有这样一个模型:读或写完成之后,再写或读下一条指令。这就是SC(Sequential consistency,顺序一致性模型)。按这个模型设计的处理器,编程友好,但性能会差一些。

为了提高性能,需要对读写放宽限制。为了充分释放CPU的计算能力,读比写的优先级会更高,因此可以放宽“写完之后再读”的限制:如果读写地址不同,还没写完毕,就可以执行下一条读指令。这就是TSO(Total Store Order,强顺序模型)。

如果放宽“写完之后再写”的限制,那么会得到PSO模型(partial store ordering)。

如果完全放宽读写限制,那么会的到WMO(weak memory ordering,弱一致性模型),而这里的Rocketchip就是采用RVWMO模型。缺少了这些限制,性能能够提升,但为了保证程序执行的正确性,RISC-V提供了同步指令“fence”。

所以为了保证我的拓展指令功能正确,需要在push和save指令前后添加同步指令:push完毕之后,才能执行计算,计算完毕之后,才能保存数据。这样才可以保证功能的正确性:

图片2.png

以上的模型可以用下表总结: image.png

有关内存一致性模型的内容很复杂,不知让大佬们掉了多少头发,只能简单介绍点皮毛,还很可能理解错~

无意中从计时的错误发现一种提高性能的方法,还是挺神奇的。

]]>
<![CDATA[虚拟地址转物理地址]]> https://icfgblog.com/index.php/software/337.html 2022-05-21T15:24:20+08:00 2022-05-21T15:24:20+08:00 icfg66 http://www.icfgblog.com 操作系统启动过程中,如何完成物理地址到虚拟地址的转换?虚拟地址又是如何翻译成物理地址的?

以qemu-system-riscv64为例,opensbi会将内核搬到内存0x80200000的位置,如果内核的.ld链接文件也是以0x80200000开始,那么人畜无害,操作系统一直在物理地址下运行,可以作为RTOS简单控制。但如果要开启虚拟地址,要做什么操作呢?

1. 物理地址到虚拟地址的转换?

首先我们在链接的时候,需要修改.ld的基址,0x80200000修改为想要内核运行的虚拟地址下,比如0xFFFFFFFFC0200000。这样一来opensbi还是会将内核搬到0x80200000的位置,如果继续执行,pc会跳转到一个0xFFFFFFFFC0200000以上的位置,远远超过了物理内存地址,必然报错。那么还需要做什么设置呢?

开启虚拟内存。CSR中有个satp(Supervisor Address Translation and Protection Register)寄存器,它的结构如下:

satp

最高4位表示寻址模式:

  • 0000表示不适用页表,直接用物理地址,用于简单的嵌入式系统。
  • 1000表示Sv39页表,也是接下来要说明的,虚拟内存空间为512GB。
  • 1001表示Sv48,比Sv39多一级,虚拟内存空间为256TB。

将satp的模式切换到Sv39,并且设置指向首级页表的地址PPN,最后执行sfence.vma刷新TLB,即可使用虚拟地址。

当然在此之前,还需要设置页表。页表可以在入口代码处提前设置,然后将其起始地址赋值给satp.PPN。

2. 虚拟地址如何转换为物理地址?

开启Sv39后,假设初始化函数的入口地址VA是0xffffffffc0200032,该地址如何转换成物理地址呢?先看虚拟地址的结构图: image.png

首先会访问satp获得页表的基地址,比如0x80205,将该地址左移12位后,和虚拟地址的VPN[2]左移3位相加(一个页表项占8字节),以0xffffffffc0200032为例,VPN[2]=111111111,VPN[1]=000000001,VPN[0]=000000000,page offset=000110010。

第一级页表项位置:0x80205<<12 + 111111111<<3 = 0x80205ff8,页表项的结构图如下: image.png

  • V为Valid位,D位Dirty位,A为Accessed位
  • RWX表示可读,可写,可执行位
  • RWX如果全0,那么该页表项需要指向下一级页表

假设0x80205ff8的页表项PTE已设置,PTE.PPN=0x80000,PTE.XWRV=1111,那么该页表项不是指向下一级页表,可以直接转换物理地址,这时需要不但需要虚拟地址的page offset,还需要VPN[1]和VPN[0]:

PA = 0x80000<<12 + VA[29:0] = 0x80200032

即完成了虚拟地址和物理地址的转换。

3. 小结

物理地址切换虚拟地址模式:

  • 分配页表内存空间,初始化页表;
  • 设置页基址寄存器satp;
  • 刷新TLB

虚拟地址转换物理地址:

  • 第一级页表项PTE1 = satp.PPN<<12 + VA.VPN2<<3 ;如果可RWX,物理地址PA=PTE1.PPN<<12+VA[29:0],如果RWX全0,进入下一级。
  • 第二级页表项PTE2 = PTE1.PPN<<12 + VA.VPN1<<3;如果可RWX,物理地址PA=PTE2.PPN<<12+VA[20:0],如果RWX全0,进入下一级。
  • 第三级页表项PTE3 = PTE2.PPN<<12 + VA.VPN0<<3;如果可RWX,物理地址PA=PTE3.PPN<<12+VA[11:0]
]]>
<![CDATA[RISCV 特权级拾遗]]> https://icfgblog.com/index.php/riscv/336.html 2022-04-27T10:15:00+08:00 2022-04-27T10:15:00+08:00 icfg66 http://www.icfgblog.com 最近了解了一波RISCV特权指令,起因是想弄清楚linux启动过程中M模式、S模式、U模式分别是如何切换的?中断和异常的时候硬件做了什么,软件要做什么?如何判断当前运行在什么模式下?

1. 模式转换

带着这些问题查看手册,确实收获不少,比如:

  • 开机时,默认进入M模式。初始化之后,配置mstatus寄存器MPP位,执行mret指令可以跳转到S或U模式。
  • U模式下主动执行ecall(同步异常),可以进入M模式,跳转到预先保存在mtvec的异常处理程序地址,最后通过mret返回U模式。
  • U模式下被动接受的中断包括,plic(键盘鼠标等),clic(时钟中断,线程切换必备),软件中断。流水线检测到中断信号时,会调整到预先保存在mtvec的异常处理程序地址,最后通过mret返回U模式。

详细的可以参考中文手册第10章

2. 硬件做了什么?

直接上图,但有一点疑惑,最后“再把权限模式更改为M”,我在gdb始终找不到当前运行模式的标志。

image.png

3. 判断当前模式

在qemu下运行简单的OS,在M和U模式下执行csrr mhartid,发现运行前的M寄存器都一样,但U模式会陷入异常。

在一篇问答里找到一点线索:

RISC-V故意不让代码轻易发现它正在运行的模式,因为这是一个虚拟化漏洞。作为一般原则,代码应该为哪种模式设计,并隐式知道它将在哪种模式下运行。应用程序代码应假定它处于 U 模式。操作系统应该假设它处于S模式(它实际上可能是虚拟化的,并在U模式下运行,U模式无法执行虚拟机监控程序捕获和模拟的事情)。

最后查看Nutshell的源码(rocketchip看不来),在src/main/scala/nutcore/backend/fu/CSR.scala文件找到

// 367行定义了特权级寄存器,初始化为M模式,该寄存器用户不可见!
  val priviledgeMode = RegInit(UInt(2.W), ModeM)

//618行根据不同模式下的ecall指令
  csrExceptionVec(ecallM) := priviledgeMode === ModeM && io.in.valid && isEcall
  csrExceptionVec(ecallS) := priviledgeMode === ModeS && io.in.valid && isEcall
  csrExceptionVec(ecallU) := priviledgeMode === ModeU && io.in.valid && isEcall
//659行 Mret 更新模式为mpp的值
  when (valid && isMret) {
    val mstatusOld = WireInit(mstatus.asTypeOf(new MstatusStruct))
    val mstatusNew = WireInit(mstatus.asTypeOf(new MstatusStruct))
    // mstatusNew.mpp.m := ModeU //TODO: add mode U
    mstatusNew.ie.m := mstatusOld.pie.m
    priviledgeMode := mstatusOld.mpp
    mstatusNew.pie.m := true.B
    mstatusNew.mpp := ModeU
    mstatus := mstatusNew.asUInt
    lr := false.B
    retTarget := mepc(VAddrBits-1, 0)
  }

折腾了半天,没想到这运行模式保存在软件不可见的硬件中。

]]>