[tests] add cover demo

README.md

@@ -163,7 +163,7 @@ $ nix develop -c t1-helper run -i <top-name> -c <config-name> -e <emulator-type>
 wheres
 - `<config-name>` is the configuration name
 - `<top-name>` is one of the `t1emu`, `t1rocketemu`
-- `<emulator-type>` is one of the `verilator-emu`, `verilator-emu-trace`, `vcs-emu`, `vcs-emu-trace`
+- `<emulator-type>` is one of the `verilator-emu`, `verilator-emu-trace`, `vcs-emu`, `vcs-emu-trace`, `vcs-emu-cover`
 - `<case-name>` is the name of a testcase, you can resolve runnable test cases by command: `t1-helper listCases -c <config-name> <regexp>`
 
 For example:
@@ -206,6 +206,12 @@ $ nix develop -c t1-helper check
 The `t1-helper check` subcommand will read RTL event produced in `run` stage,
 so make sure you `run` a test before `check`.
 
+To get the coverage report, use the `vcs-emu-cover` emulator type:
+
+```console
+$ nix develop -c t1-helper run -i t1emu -c blastoise -e vcs-emu-cover mlir.hello
+```
+
 #### Export RTL Properties
 
 ```shell
@@ -328,6 +334,51 @@ $ nix build .#t1.<config-name>.<top-name>.cases.intrinsic.matmul -L
 $ ls -al ./result
 ```
 
+#### Developing Coverage
+
+To develop coverage, use the following steps:
+
+1. Write the coverpoint description file at the same level as the test case source code.
+2. Update the `default.nix` file to parse the coverpoint description file.
+
+For example, to develop coverage for the `mlir.hello` test case:
+
+tests/mlir/hello/hello.json:
+```json
+{
+  "assert": [
+    {
+      "name": "vmv_v_i",
+      "description": "single instruction vmv.v.i"
+    }
+  ],
+  "tree": [],
+  "module": []
+}
+```
+
+tests/mlir/default.nix:
+```shell
+if [ -f ${caseName}.json ]; then
+  ${jq}/bin/jq -r '[.assert[] | "+assert " + .name] + [.tree[] | "+tree " + .name] + [.module[] | "+module " + .name] | .[]' \
+      ${caseName}.json > $pname.cover
+else 
+  echo "-assert *" > $pname.cover
+fi
+```
+
+Then, you can run the test building script to check if the coverage is generated correctly:
+
+```shell
+nix build .#t1.blastoise.t1emu.cases.mlir.hello -L
+```
+
+Use the `vcs-emu-cover` emulator type to run the test case and generate the coverage report:
+
+```shell
+nix develop -c t1-helper run -i t1emu -c blastoise -e vcs-emu-cover mlir.hello
+```
+
 ### Bump Dependencies
 Bump nixpkgs:
 ```shell

nix/t1/conversion/sv-to-vcs-simulator.nix

@@ -51,6 +51,8 @@ stdenv.mkDerivation rec {
     "assert"
     "-cm_dir"
     "./cm"
+    "-assert"
+    "enable_hier"
   ]
   ++ lib.optionals (!enableCover) [
     "-assert"

nix/t1/run/run-vcs-emu.nix

@@ -49,6 +49,8 @@ stdenvNoCC.mkDerivation (rec {
   ++ lib.optionals emulator.enableCover [
     "-cm"
     "assert"
+    "-assert"
+    "hier=${testCase}/${testCase.pname}.cover"
   ]
   ++ lib.optionals emulator.enableTrace [
     "+t1_wave_path=${testCase.pname}.fsdb"

script/emu/src/Main.scala

@@ -44,13 +44,13 @@ object Main:
       attr
     ) ++ extraArgs
     os.proc(args).call().out.trim()
-
-  def resolveTestElfPath(
+  
+  def resolveTestPath(
     ip:       String,
     config:   String,
     caseName: String,
     forceX86: Boolean = false
-  ): os.Path =
+  ): os.Path = 
     val casePath = os.Path(caseName, os.pwd)
     if (os.exists(casePath)) then return casePath
 
@@ -61,11 +61,35 @@ object Main:
     val nixStorePath = resolveNixPath(
       s"${caseAttrRoot}t1.${config}.${ip}.cases.${caseName}"
     )
-    val elfFilePath  = os.Path(nixStorePath) / "bin" / s"${caseName}.elf"
+    val filePath  = os.Path(nixStorePath)
+
+    filePath
+  end resolveTestPath
+
+  def resolveTestElfPath(
+    ip:       String,
+    config:   String,
+    caseName: String,
+    forceX86: Boolean = false
+  ): os.Path =
+    val testPath = resolveTestPath(ip, config, caseName, forceX86)
+    val elfFilePath  = testPath / "bin" / s"${caseName}.elf"
 
     elfFilePath
   end resolveTestElfPath
 
+  def resolveTestCoverPath(
+    ip:       String,
+    config:   String,
+    caseName: String,
+    forceX86: Boolean = false
+  ): os.Path =
+    val testPath = resolveTestPath(ip, config, caseName, forceX86)
+    val coverFilePath  = testPath / s"${caseName}.cover"
+
+    coverFilePath
+  end resolveTestCoverPath
+
   def resolveTestBenchPath(
     ip:      String,
     config:  String,
@@ -203,8 +227,8 @@ object Main:
       s"Using config=${BOLD}${finalConfig.get}${RESET} emulator=${BOLD}${finalEmuType.get}${RESET} case=${BOLD}$caseName${RESET}"
     )
 
-    val caseElfPath =
-      resolveTestElfPath(finalIp.get, finalConfig.get, caseName, forceX86)
+    val caseElfPath = resolveTestElfPath(finalIp.get, finalConfig.get, caseName, forceX86)
+    val caseCoverPath = resolveTestCoverPath(finalIp.get, finalConfig.get, caseName, forceX86)
     val outputPath  = prepareOutputDir(outDir.getOrElse("t1-sim-result"))
     val emulator    = resolveTestBenchPath(finalIp.get, finalConfig.get, finalEmuType.get)
 
@@ -216,7 +240,7 @@ object Main:
     )
       ++ optionals(timeout.isDefined, Seq(s"+t1_timeout=${timeout.getOrElse("unreachable")}"))
       ++ optionals(isTrace, Seq(s"+t1_wave_path=${outputPath / "wave.fsdb"}"))
-      ++ optionals(isCover, Seq(s"-cm assert"))
+      ++ optionals(isCover, Seq("-cm", "assert", "-assert", s"hier=${caseCoverPath}"))
       ++ optionals(!leftOverArguments.isEmpty, leftOverArguments)
 
     if dryRun.value then return