profile
viewpoint
Hodjat Asghari Esfeden hodjat91 Google Sunnyvale, CA www.hodjat.me Hardware Engineer @Google Computer Science PhD from @UCRiverside

google/riscv-dv 567

Random instruction generator for RISC-V processor verification

fvutils/pyvsc 46

Python packages providing a library for Verification Stimulus and Coverage

hodjat91/ibex 0

Ibex is a small 32 bit RISC-V CPU core, previously known as zero-riscy.

hodjat91/pyvsc 0

Python packages providing a library for Verification Stimulus and Coverage

hodjat91/riscv-dv 0

SV/UVM based instruction generator for RISC-V processor verification

hodjat91/rodinia 0

rodinia benchmark modified to run with ENZO and pathcu instead of nvcc CUDA compiler

hodjat91/vim-config 0

my vim config to share amongst my machines

PullRequestReviewEvent

Pull request review commentgoogle/riscv-dv

[PyFlow]: Add support for sub_programs

+"""+Copyright 2020 Google LLC+Copyright 2020 PerfectVIPs Inc.++Licensed under the Apache License, Version 2.0 (the "License");+you may not use this file except in compliance with the License.+You may obtain a copy of the License at+http://www.apache.org/licenses/LICENSE-2.0+Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+"""++import logging+import random+import vsc+++@vsc.randobj+class riscv_program:+    def __init__(self):+        self.program_id = vsc.rand_bit_t(16)+        self.call_stack_level = vsc.rand_uint32_t()+        self.sub_program_id = vsc.rand_list_t(vsc.bit_t(16))++    @vsc.constraint+    def legel_c(self):+        vsc.unique(self.sub_program_id)+        with vsc.foreach(self.sub_program_id, idx = True) as i:+            self.sub_program_id[i] != self.program_id++    def convert2string(self):+        string = "PID[{}] Lv[{}] :".format(self.program_id, self.call_stack_level)+        for i in range(len(self.sub_program_id)):+            string = "{} {}".format(string, self.sub_program_id[i])+        return string++# -----------------------------------------------------------------------------------------+# RISC-V assembly program call stack generator+#+# The call stack is generated as a tree structure to avoid dead call loop.+# Level 0:                     P0+#                           /  |  \+# Level 1:                 P1  P2  P3+#                          |     \/  \+# Level 2:                 P4    P5   P6+#                                 |+# Level 3:                        P7+#+# Rules: A program can only call the program in the next level.+#        A program can be called many times by other upper level programs.+#        A program can call the same lower level programs multiple times.+# -----------------------------------------------------------------------------------------+++@vsc.randobj+class riscv_callstack_gen:+    def __init__(self):+        # Number of programs in the call stack+        self.program_cnt = vsc.int_t(10)+        # Handles of all programs+        self.program_h = []+        # Maximum call stack level+        self.max_stack_level = vsc.int_t(50)+        # Call stack level of each program+        self.stack_level = vsc.randsz_list_t(vsc.bit_t(11))++    @vsc.constraint+    def program_stack_level_c(self):+        # The stack level is assigned in ascending order to avoid call loop+        self.stack_level.size == self.program_cnt+        self.stack_level[0] == 0+        with vsc.foreach(self.stack_level, idx=True) as i:+            with vsc.if_then(i > 0):+                self.stack_level[i] in vsc.rangelist(vsc.rng(1, self.program_cnt - 1))+                self.stack_level[i] >= self.stack_level[i - 1]+                self.stack_level[i] <= self.stack_level[i - 1] + 1+                self.stack_level[i] <= self.max_stack_level++    # Init all program instances before randomization+    def init(self, program_cnt):+        self.program_cnt = program_cnt+        self.program_h = [0] * program_cnt+        for i in range(len(self.program_h)):+            self.program_h[i] = riscv_program("program_{}".format(i))++# In the randomiation stage, only the stack level of each program is specified. The call stack+# generation process is to build the call relationship between different programs. This is+# implemented with post randomize rather than constraints for performance considerations.+# Solving a complex call stack with SV constraint could take considerable time for the solver.

maybe update this line as well? Since here there is no SV solver :)

aneels3

comment created time in a day

PullRequestReviewEvent

Pull request review commentgoogle/riscv-dv

[PyFlow]: Add support for sub_programs

+"""+Copyright 2020 Google LLC+Copyright 2020 PerfectVIPs Inc.++Licensed under the Apache License, Version 2.0 (the "License");+you may not use this file except in compliance with the License.+You may obtain a copy of the License at+http://www.apache.org/licenses/LICENSE-2.0+Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+"""++import logging+import random+import vsc+++@vsc.randobj+class riscv_program:+    def __init__(self):+        self.program_id = vsc.rand_bit_t(16)+        self.call_stack_level = vsc.rand_uint32_t()+        self.sub_program_id = vsc.rand_list_t(vsc.bit_t(16))++    @vsc.constraint+    def legel_c(self):+        vsc.unique(self.sub_program_id)+        with vsc.foreach(self.sub_program_id, idx = True) as i:+            self.sub_program_id[i] != self.program_id++    def convert2string(self):+        string = "PID[{}] Lv[{}] :".format(self.program_id, self.call_stack_level)+        for i in range(len(self.sub_program_id)):+            string = "{} {}".format(string, self.sub_program_id[i])+        return string++# -----------------------------------------------------------------------------------------+# RISC-V assembly program call stack generator+#+# The call stack is generated as a tree structure to avoid dead call loop.+# Level 0:                     P0+#                           /  |  \+# Level 1:                 P1  P2  P3+#                          |     \/  \+# Level 2:                 P4    P5   P6+#                                 |+# Level 3:                        P7+#+# Rules: A program can only call the program in the next level.+#        A program can be called many times by other upper level programs.+#        A program can call the same lower level programs multiple times.+# -----------------------------------------------------------------------------------------+++@vsc.randobj+class riscv_callstack_gen:+    def __init__(self):+        # Number of programs in the call stack+        self.program_cnt = vsc.int_t(10)+        # Handles of all programs+        self.program_h = []+        # Maximum call stack level+        self.max_stack_level = vsc.int_t(50)+        # Call stack level of each program+        self.stack_level = vsc.randsz_list_t(vsc.bit_t(11))++    @vsc.constraint+    def program_stack_level_c(self):+        # The stack level is assigned in ascending order to avoid call loop+        self.stack_level.size == self.program_cnt+        self.stack_level[0] == 0+        with vsc.foreach(self.stack_level, idx=True) as i:+            with vsc.if_then(i > 0):+                self.stack_level[i] in vsc.rangelist(vsc.rng(1, self.program_cnt - 1))+                self.stack_level[i] >= self.stack_level[i - 1]+                self.stack_level[i] <= self.stack_level[i - 1] + 1+                self.stack_level[i] <= self.max_stack_level++    # Init all program instances before randomization+    def init(self, program_cnt):+        self.program_cnt = program_cnt+        self.program_h = [0] * program_cnt+        for i in range(len(self.program_h)):+            self.program_h[i] = riscv_program("program_{}".format(i))++# In the randomiation stage, only the stack level of each program is specified. The call stack

nit: typo

aneels3

comment created time in a day

PullRequestReviewEvent

push eventgoogle/riscv-dv

shrujal20

commit sha 3710b9750fa5b7e95d50b97c5343ff0097cf2240

implement rv64i

view details

aneels3

commit sha a8c65bf5f4039a45a170862ba58f99c2dce2c674

fix issue with imm value for 64 bit instr Signed-off-by: aneels3 <b150023ec@nitsikkim.ac.in>

view details

Hodjat Asghari Esfeden

commit sha a7e27bc046405f0dbcde091be99f5a5d564e2172

Merge pull request #831 from saurabhsingh-pvips/new_rv64i [PyFlow]: Add support for RV64IMC

view details

push time in a day

PR merged google/riscv-dv

[PyFlow]: Add support for RV64IMC

This PR adds RV64IMC support for PyFlow.

+229 -2

2 comments

5 changed files

aneels3

pr closed time in a day

PullRequestReviewEvent
PullRequestReviewEvent

Pull request review commentgoogle/riscv-dv

[PyFlow]: Add support for RV64IMC

 def update_imm_str(self):         self.imm_str = str(self.uintToInt(self.imm))      def uintToInt(self, x):-        if x < (2 ** rcs.XLEN) / 2:+        if x < (2 ** 32) / 2:

can you please replace constant 32 with a parameter?

aneels3

comment created time in a month

PullRequestReviewEvent

push eventgoogle/riscv-dv

aneels3

commit sha 8a4e2a8b1d73970703152c49446e53c51e10efa4

Add support for RV32FD coverage Signed-off-by: aneels3 <b150023ec@nitsikkim.ac.in>

view details

Hodjat Asghari Esfeden

commit sha 96c1ee6f371f2754c45b4831fcab95f6671689d9

Merge pull request #828 from saurabhsingh-pvips/rv32fd_coverage [PyFlow]: Add support for RV32FD coverage

view details

push time in a month

PR merged google/riscv-dv

[PyFlow]: Add support for RV32FD coverage

This PR adds the support for coverage collection of RV32FD instructions. Signed-off-by: aneels3 b150023ec@nitsikkim.ac.in

+5902 -111

0 comment

5 changed files

aneels3

pr closed time in a month

PullRequestReviewEvent

PR merged google/riscv-dv

Reviewers
[PyFlow]: Integrate random seed for PyFlow

Signed-off-by: aneels3 b150023ec@nitsikkim.ac.in

+14 -1

1 comment

4 changed files

aneels3

pr closed time in a month

push eventgoogle/riscv-dv

aneels3

commit sha b3498ea7f4ab6924d045c1036f16d90f741fa638

Integrate random seed for pyflow Signed-off-by: aneels3 <b150023ec@nitsikkim.ac.in>

view details

Hodjat Asghari Esfeden

commit sha a556f0c8602d63d67724a9a5cd68023009bfec32

Merge pull request #820 from saurabhsingh-pvips/random_seed [PyFlow]: Integrate random seed for PyFlow

view details

push time in a month

issue commentgoogle/riscv-dv

VCS Error

Do you have VCS license and have you set up the environment path? What do you see with running this command? "echo $VCS_HOME"

sundas56

comment created time in 3 months

PullRequestReviewEvent

Pull request review commentgoogle/riscv-dv

[PyFlow]: Add support for RV32FD coverage

 def __init__(self):                                                   "Aligned"    : vsc.bin(1),
                                                   "Not-aligned": vsc.bin(0)
                                                    })
+    '''Floating instructions'''
+
+    @vsc.covergroup
+    class flw_cg(object):
+        def __init__(self, precision, ignore):
+            super().__init__()
+
+            self.instr = None
+            self.options.ignore = ignore
+            self.cp_rs1 = vsc.coverpoint(lambda: self.instr.rs1,
+                                         cp_t=vsc.enum_t(riscv_reg_ex_zero_t))
+            self.cp_fd = vsc.coverpoint(lambda: self.instr.fd,
+                                        cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_imm_sign = vsc.coverpoint(lambda: self.instr.imm_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_gpr_hazard = vsc.coverpoint(lambda: self.instr.gpr_hazard,
+                                                cp_t=vsc.enum_t(hazard_e))
+            self.cp_lsu_hazard = vsc.coverpoint(lambda: self.instr.lsu_hazard,
+                                                cp_t=vsc.enum_t(
+                                                    branch_hazard_e))
+            self.cp_sfp_special_values_on_fd_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fd_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+
+    @vsc.covergroup
+    class fld_cg(object):
+        def __init__(self, precision):
+            super().__init__()
+
+            self.instr = None
+            self.cp_rs1 = vsc.coverpoint(lambda: self.instr.rs1,
+                                         cp_t=vsc.enum_t(riscv_reg_ex_zero_t))
+            self.cp_fd = vsc.coverpoint(lambda: self.instr.fd,
+                                        cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_imm_sign = vsc.coverpoint(lambda: self.instr.imm_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_gpr_hazard = vsc.coverpoint(lambda: self.instr.gpr_hazard,
+                                                cp_t=vsc.enum_t(hazard_e))
+            self.cp_lsu_hazard = vsc.coverpoint(lambda: self.instr.lsu_hazard,
+                                                cp_t=vsc.enum_t(
+                                                    branch_hazard_e))
+            self.cp_sfp_special_values_on_fd_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fd_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision), type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+
+    @vsc.covergroup
+    class fsw_cg(object):
+        def __init__(self, precision):
+            super().__init__()
+
+            self.instr = None
+            self.cp_rs1 = vsc.coverpoint(lambda: self.instr.rs1,
+                                         cp_t=vsc.enum_t(riscv_reg_ex_zero_t))
+            self.cp_fs2 = vsc.coverpoint(lambda: self.instr.fs2,
+                                         cp_t=vsc.enum_t(riscv_reg_t))
+            self.cp_imm_sign = vsc.coverpoint(lambda: self.instr.imm_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_gpr_hazard = vsc.coverpoint(lambda: self.instr.gpr_hazard,
+                                                cp_t=vsc.enum_t(hazard_e))
+            self.cp_lsu_hazard = vsc.coverpoint(lambda: self.instr.lsu_hazard,
+                                                cp_t=vsc.enum_t(
+                                                    store_lsu_hazard_e))
+            self.cp_sfp_special_values_on_fs2_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs2_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+
+    @vsc.covergroup
+    class fsd_cg(object):
+        def __init__(self, precision):
+            super().__init__()
+
+            self.instr = None
+            self.cp_rs1 = vsc.coverpoint(lambda: self.instr.rs1,
+                                         cp_t=vsc.enum_t(riscv_reg_ex_zero_t))
+            self.cp_fs2 = vsc.coverpoint(lambda: self.instr.fs2,
+                                         cp_t=vsc.enum_t(riscv_reg_t))
+            self.cp_imm_sign = vsc.coverpoint(lambda: self.instr.imm_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_gpr_hazard = vsc.coverpoint(lambda: self.instr.gpr_hazard,
+                                                cp_t=vsc.enum_t(hazard_e))
+            self.cp_lsu_hazard = vsc.coverpoint(lambda: self.instr.lsu_hazard,
+                                                cp_t=vsc.enum_t(
+                                                    store_lsu_hazard_e))
+            self.cp_sfp_special_values_on_fs2_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs2_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+
+    @vsc.covergroup
+    class fadd_s_cg(object):
+        def __init__(self, precision):
+            super().__init__()
+
+            self.instr = None
+            self.cp_fs1 = vsc.coverpoint(lambda: self.instr.fs1,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs2 = vsc.coverpoint(lambda: self.instr.fs2,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fd = vsc.coverpoint(lambda: self.instr.fd,
+                                        cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs1_sign = vsc.coverpoint(lambda: self.instr.fs1_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fs2_sign = vsc.coverpoint(lambda: self.instr.fs2_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fd_sign = vsc.coverpoint(lambda: self.instr.fd_sign,
+                                             cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_gpr_hazard = vsc.coverpoint(lambda: self.instr.gpr_hazard,
+                                                cp_t=vsc.enum_t(hazard_e))
+            self.cp_sfp_special_values_on_fs1_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs1_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fs2_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs2_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fd_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fd_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+
+
+    @vsc.covergroup
+    class fadd_d_cg(object):
+        def __init__(self, precision):
+            super().__init__()
+
+            self.instr = None
+            self.cp_fs1 = vsc.coverpoint(lambda: self.instr.fs1,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs2 = vsc.coverpoint(lambda: self.instr.fs2,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fd = vsc.coverpoint(lambda: self.instr.fd,
+                                        cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs1_sign = vsc.coverpoint(lambda: self.instr.fs1_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fs2_sign = vsc.coverpoint(lambda: self.instr.fs2_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fd_sign = vsc.coverpoint(lambda: self.instr.fd_sign,
+                                             cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_gpr_hazard = vsc.coverpoint(lambda: self.instr.gpr_hazard,
+                                                cp_t=vsc.enum_t(hazard_e))
+            self.cp_sign_cross = vsc.cross([self.cp_fs1_sign,
+                                            self.cp_fs2_sign,
+                                            self.cp_fd_sign])
+            self.cp_sfp_special_values_on_fs1_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs1_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fs2_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs2_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fd_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fd_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+
+    @vsc.covergroup
+    class fsub_s_cg(object):
+        def __init__(self, precision):
+            super().__init__()
+
+            self.instr = None
+            self.cp_fs1 = vsc.coverpoint(lambda: self.instr.fs1,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs2 = vsc.coverpoint(lambda: self.instr.fs2,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fd = vsc.coverpoint(lambda: self.instr.fd,
+                                        cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs1_sign = vsc.coverpoint(lambda: self.instr.fs1_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fs2_sign = vsc.coverpoint(lambda: self.instr.fs2_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fd_sign = vsc.coverpoint(lambda: self.instr.fd_sign,
+                                             cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_gpr_hazard = vsc.coverpoint(lambda: self.instr.gpr_hazard,
+                                                cp_t=vsc.enum_t(hazard_e))
+            self.cp_sign_cross = vsc.cross([self.cp_fs1_sign,
+                                            self.cp_fs2_sign,
+                                            self.cp_fd_sign])
+            self.cp_sfp_special_values_on_fs1_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs1_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fs2_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs2_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fd_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fd_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+
+
+    @vsc.covergroup
+    class fsub_d_cg(object):
+        def __init__(self, precision):
+            super().__init__()
+
+            self.instr = None
+            self.cp_fs1 = vsc.coverpoint(lambda: self.instr.fs1,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs2 = vsc.coverpoint(lambda: self.instr.fs2,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fd = vsc.coverpoint(lambda: self.instr.fd,
+                                        cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs1_sign = vsc.coverpoint(lambda: self.instr.fs1_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fs2_sign = vsc.coverpoint(lambda: self.instr.fs2_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fd_sign = vsc.coverpoint(lambda: self.instr.fd_sign,
+                                             cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_gpr_hazard = vsc.coverpoint(lambda: self.instr.gpr_hazard,
+                                                cp_t=vsc.enum_t(hazard_e))
+            self.cp_sign_cross = vsc.cross([self.cp_fs1_sign,
+                                            self.cp_fs2_sign,
+                                            self.cp_fd_sign])
+            self.cp_sfp_special_values_on_fs1_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs1_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fs2_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs2_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fd_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fd_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+
+    @vsc.covergroup
+    class fmul_s_cg(object):
+        def __init__(self, precision):
+            super().__init__()
+
+            self.instr = None
+            self.cp_fs1 = vsc.coverpoint(lambda: self.instr.fs1,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs2 = vsc.coverpoint(lambda: self.instr.fs2,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fd = vsc.coverpoint(lambda: self.instr.fd,
+                                        cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs1_sign = vsc.coverpoint(lambda: self.instr.fs1_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fs2_sign = vsc.coverpoint(lambda: self.instr.fs2_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fd_sign = vsc.coverpoint(lambda: self.instr.fd_sign,
+                                             cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_gpr_hazard = vsc.coverpoint(lambda: self.instr.gpr_hazard,
+                                                cp_t=vsc.enum_t(hazard_e))
+            self.cp_sign_cross = vsc.cross([self.cp_fs1_sign,
+                                            self.cp_fs2_sign])
+            self.cp_sfp_special_values_on_fs1_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs1_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fs2_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs2_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fd_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fd_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+
+    @vsc.covergroup
+    class fmul_d_cg(object):
+        def __init__(self, precision):
+            super().__init__()
+
+            self.instr = None
+            self.cp_fs1 = vsc.coverpoint(lambda: self.instr.fs1,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs2 = vsc.coverpoint(lambda: self.instr.fs2,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fd = vsc.coverpoint(lambda: self.instr.fd,
+                                        cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs1_sign = vsc.coverpoint(lambda: self.instr.fs1_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fs2_sign = vsc.coverpoint(lambda: self.instr.fs2_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fd_sign = vsc.coverpoint(lambda: self.instr.fd_sign,
+                                             cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_gpr_hazard = vsc.coverpoint(lambda: self.instr.gpr_hazard,
+                                                cp_t=vsc.enum_t(hazard_e))
+            self.cp_sign_cross = vsc.cross([self.cp_fs1_sign,
+                                            self.cp_fs2_sign])
+            self.cp_sfp_special_values_on_fs1_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs1_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fs2_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs2_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fd_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fd_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+
+    @vsc.covergroup
+    class fdiv_s_cg(object):
+        def __init__(self, precision):
+            super().__init__()
+
+            self.instr = None
+            self.cp_fs1 = vsc.coverpoint(lambda: self.instr.fs1,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs2 = vsc.coverpoint(lambda: self.instr.fs2,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fd = vsc.coverpoint(lambda: self.instr.fd,
+                                        cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs1_sign = vsc.coverpoint(lambda: self.instr.fs1_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fs2_sign = vsc.coverpoint(lambda: self.instr.fs2_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fd_sign = vsc.coverpoint(lambda: self.instr.fd_sign,
+                                             cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_gpr_hazard = vsc.coverpoint(lambda: self.instr.gpr_hazard,
+                                                cp_t=vsc.enum_t(hazard_e))
+            self.cp_sign_cross = vsc.cross([self.cp_fs1_sign,
+                                            self.cp_fs2_sign])
+            self.cp_sfp_special_values_on_fs1_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs1_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                        options = dict(weight = precision),
+                                                                        type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fs2_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs2_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fd_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fd_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+
+    @vsc.covergroup
+    class fdiv_d_cg(object):
+        def __init__(self, precision):
+            super().__init__()
+
+            self.instr = None
+            self.cp_fs1 = vsc.coverpoint(lambda: self.instr.fs1,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs2 = vsc.coverpoint(lambda: self.instr.fs2,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fd = vsc.coverpoint(lambda: self.instr.fd,
+                                        cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs1_sign = vsc.coverpoint(lambda: self.instr.fs1_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fs2_sign = vsc.coverpoint(lambda: self.instr.fs2_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fd_sign = vsc.coverpoint(lambda: self.instr.fd_sign,
+                                             cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_gpr_hazard = vsc.coverpoint(lambda: self.instr.gpr_hazard,
+                                                cp_t=vsc.enum_t(hazard_e))
+            self.cp_sign_cross = vsc.cross([self.cp_fs1_sign,
+                                            self.cp_fs2_sign])
+            self.cp_sfp_special_values_on_fs1_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs1_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fs2_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs2_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fd_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fd_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+
+
+    @vsc.covergroup
+    class fsqrt_s_cg(object):
+        def __init__(self, precision):
+            super().__init__()
+
+            self.instr = None
+            self.cp_fs1 = vsc.coverpoint(lambda: self.instr.fs1,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fd = vsc.coverpoint(lambda: self.instr.fd,
+                                        cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs1_sign = vsc.coverpoint(lambda: self.instr.fs1_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fd_sign = vsc.coverpoint(lambda: self.instr.fd_sign,
+                                             cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_gpr_hazard = vsc.coverpoint(lambda: self.instr.gpr_hazard,
+                                                cp_t=vsc.enum_t(hazard_e))
+            self.cp_sfp_special_values_on_fs1_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs1_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.bit_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fd_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fd_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.bit_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+
+
+    @vsc.covergroup
+    class fsqrt_d_cg(object):
+        def __init__(self, precision):
+            super().__init__()
+
+            self.instr = None
+            self.cp_fs1 = vsc.coverpoint(lambda: self.instr.fs1,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fd = vsc.coverpoint(lambda: self.instr.fd,
+                                        cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs1_sign = vsc.coverpoint(lambda: self.instr.fs1_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fd_sign = vsc.coverpoint(lambda: self.instr.fd_sign,
+                                             cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_gpr_hazard = vsc.coverpoint(lambda: self.instr.gpr_hazard,
+                                                cp_t=vsc.enum_t(hazard_e))
+            self.cp_sfp_special_values_on_fs1_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs1_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fd_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fd_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+
+
+    @vsc.covergroup
+    class fmin_s_cg(object):
+        def __init__(self, precision):
+            super().__init__()
+
+            self.instr = None
+            self.cp_fs1 = vsc.coverpoint(lambda: self.instr.fs1,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs2 = vsc.coverpoint(lambda: self.instr.fs2,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fd = vsc.coverpoint(lambda: self.instr.fd,
+                                        cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs1_sign = vsc.coverpoint(lambda: self.instr.fs1_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fs2_sign = vsc.coverpoint(lambda: self.instr.fs2_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fd_sign = vsc.coverpoint(lambda: self.instr.fd_sign,
+                                             cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_gpr_hazard = vsc.coverpoint(lambda: self.instr.gpr_hazard,
+                                                cp_t=vsc.enum_t(hazard_e))
+            self.cp_sign_cross = vsc.cross([self.cp_fs1_sign,
+                                            self.cp_fs2_sign])
+            self.cp_sfp_special_values_on_fs1_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs1_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fs2_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs2_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fd_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fd_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+
+    @vsc.covergroup
+    class fmin_d_cg(object):
+        def __init__(self, precision):
+            super().__init__()
+
+            self.instr = None
+            self.cp_fs1 = vsc.coverpoint(lambda: self.instr.fs1,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs2 = vsc.coverpoint(lambda: self.instr.fs2,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fd = vsc.coverpoint(lambda: self.instr.fd,
+                                        cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs1_sign = vsc.coverpoint(lambda: self.instr.fs1_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fs2_sign = vsc.coverpoint(lambda: self.instr.fs2_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fd_sign = vsc.coverpoint(lambda: self.instr.fd_sign,
+                                             cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_gpr_hazard = vsc.coverpoint(lambda: self.instr.gpr_hazard,
+                                                cp_t=vsc.enum_t(hazard_e))
+            self.cp_sign_cross = vsc.cross([self.cp_fs1_sign,
+                                            self.cp_fs2_sign])
+            self.cp_sfp_special_values_on_fs1_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs1_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fs2_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs2_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fd_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fd_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+
+    @vsc.covergroup
+    class fmax_s_cg(object):
+        def __init__(self, precision):
+            super().__init__()
+
+            self.instr = None
+            self.cp_fs1 = vsc.coverpoint(lambda: self.instr.fs1,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs2 = vsc.coverpoint(lambda: self.instr.fs2,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fd = vsc.coverpoint(lambda: self.instr.fd,
+                                        cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs1_sign = vsc.coverpoint(lambda: self.instr.fs1_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fs2_sign = vsc.coverpoint(lambda: self.instr.fs2_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fd_sign = vsc.coverpoint(lambda: self.instr.fd_sign,
+                                             cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_gpr_hazard = vsc.coverpoint(lambda: self.instr.gpr_hazard,
+                                                cp_t=vsc.enum_t(hazard_e))
+            self.cp_sign_cross = vsc.cross([self.cp_fs1_sign,
+                                            self.cp_fs2_sign])
+            self.cp_sfp_special_values_on_fs1_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs1_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fs2_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs2_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fd_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fd_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+
+    @vsc.covergroup
+    class fmax_d_cg(object):
+        def __init__(self, precision):
+            super().__init__()
+
+            self.instr = None
+            self.cp_fs1 = vsc.coverpoint(lambda: self.instr.fs1,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs2 = vsc.coverpoint(lambda: self.instr.fs2,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fd = vsc.coverpoint(lambda: self.instr.fd,
+                                        cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs1_sign = vsc.coverpoint(lambda: self.instr.fs1_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fs2_sign = vsc.coverpoint(lambda: self.instr.fs2_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fd_sign = vsc.coverpoint(lambda: self.instr.fd_sign,
+                                             cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_gpr_hazard = vsc.coverpoint(lambda: self.instr.gpr_hazard,
+                                                cp_t=vsc.enum_t(hazard_e))
+            self.cp_sign_cross = vsc.cross([self.cp_fs1_sign,
+                                            self.cp_fs2_sign])
+            self.cp_sfp_special_values_on_fs1_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs1_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fs2_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs2_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fd_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fd_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+
+
+    @vsc.covergroup
+    class fmadd_s_cg(object):
+        def __init__(self, precision):
+            super().__init__()
+
+            self.instr = None
+            self.cp_fs1 = vsc.coverpoint(lambda: self.instr.fs1,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs2 = vsc.coverpoint(lambda: self.instr.fs2,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs3 = vsc.coverpoint(lambda: self.instr.fs3,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fd = vsc.coverpoint(lambda: self.instr.fd,
+                                        cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs1_sign = vsc.coverpoint(lambda: self.instr.fs1_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fs2_sign = vsc.coverpoint(lambda: self.instr.fs2_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fs3_sign = vsc.coverpoint(lambda: self.instr.fs3_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fd_sign = vsc.coverpoint(lambda: self.instr.fd_sign,
+                                             cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_gpr_hazard = vsc.coverpoint(lambda: self.instr.gpr_hazard,
+                                                cp_t=vsc.enum_t(hazard_e))
+            self.cp_sign_cross = vsc.cross([self.cp_fs1_sign,
+                                            self.cp_fs2_sign,
+                                            self.cp_fs3_sign,
+                                            self.cp_fd_sign])
+            self.cp_sfp_special_values_on_fs1_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs1_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fs2_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs2_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fs3_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs3_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs3_value = vsc.coverpoint(
+                lambda: self.instr.fs3_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs3_value = vsc.coverpoint(
+                lambda: self.instr.fs3_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs3_value = vsc.coverpoint(
+                lambda: self.instr.fs3_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fd_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fd_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+
+
+    @vsc.covergroup
+    class fmadd_d_cg(object):
+        def __init__(self, precision):
+            super().__init__()
+
+            self.instr = None
+            self.cp_fs1 = vsc.coverpoint(lambda: self.instr.fs1,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs2 = vsc.coverpoint(lambda: self.instr.fs2,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs3 = vsc.coverpoint(lambda: self.instr.fs3,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fd = vsc.coverpoint(lambda: self.instr.fd,
+                                        cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs1_sign = vsc.coverpoint(lambda: self.instr.fs1_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fs2_sign = vsc.coverpoint(lambda: self.instr.fs2_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fs3_sign = vsc.coverpoint(lambda: self.instr.fs3_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fd_sign = vsc.coverpoint(lambda: self.instr.fd_sign,
+                                             cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_gpr_hazard = vsc.coverpoint(lambda: self.instr.gpr_hazard,
+                                                cp_t=vsc.enum_t(hazard_e))
+            self.cp_sign_cross = vsc.cross([self.cp_fs1_sign,
+                                            self.cp_fs2_sign,
+                                            self.cp_fs3_sign,
+                                            self.cp_fd_sign])
+            self.cp_sfp_special_values_on_fs1_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs1_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fs2_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs2_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fs3_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs3_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs3_value = vsc.coverpoint(
+                lambda: self.instr.fs3_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs3_value = vsc.coverpoint(
+                lambda: self.instr.fs3_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs3_value = vsc.coverpoint(
+                lambda: self.instr.fs3_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fd_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fd_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+
+    @vsc.covergroup
+    class fnmadd_s_cg(object):
+        def __init__(self, precision):
+            super().__init__()
+
+            self.instr = None
+            self.cp_fs1 = vsc.coverpoint(lambda: self.instr.fs1,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs2 = vsc.coverpoint(lambda: self.instr.fs2,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs3 = vsc.coverpoint(lambda: self.instr.fs3,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fd = vsc.coverpoint(lambda: self.instr.fd,
+                                        cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs1_sign = vsc.coverpoint(lambda: self.instr.fs1_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fs2_sign = vsc.coverpoint(lambda: self.instr.fs2_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fs3_sign = vsc.coverpoint(lambda: self.instr.fs3_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fd_sign = vsc.coverpoint(lambda: self.instr.fd_sign,
+                                             cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_gpr_hazard = vsc.coverpoint(lambda: self.instr.gpr_hazard,
+                                                cp_t=vsc.enum_t(hazard_e))
+            self.cp_sign_cross = vsc.cross([self.cp_fs1_sign,
+                                            self.cp_fs2_sign,
+                                            self.cp_fs3_sign,
+                                            self.cp_fd_sign])
+            self.cp_sfp_special_values_on_fs1_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs1_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fs2_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs2_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fs3_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs3_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs3_value = vsc.coverpoint(
+                lambda: self.instr.fs3_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs3_value = vsc.coverpoint(
+                lambda: self.instr.fs3_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs3_value = vsc.coverpoint(
+                lambda: self.instr.fs3_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fd_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fd_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+
+
+    @vsc.covergroup
+    class fnmadd_d_cg(object):
+        def __init__(self, precision):
+            super().__init__()
+
+            self.instr = None
+            self.cp_fs1 = vsc.coverpoint(lambda: self.instr.fs1,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs2 = vsc.coverpoint(lambda: self.instr.fs2,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs3 = vsc.coverpoint(lambda: self.instr.fs3,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fd = vsc.coverpoint(lambda: self.instr.fd,
+                                        cp_t=vsc.enum_t(riscv_reg_t))
+            self.cp_fs1_sign = vsc.coverpoint(lambda: self.instr.fs1_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fs2_sign = vsc.coverpoint(lambda: self.instr.fs2_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fs3_sign = vsc.coverpoint(lambda: self.instr.fs3_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fd_sign = vsc.coverpoint(lambda: self.instr.fd_sign,
+                                             cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_gpr_hazard = vsc.coverpoint(lambda: self.instr.gpr_hazard,
+                                                cp_t=vsc.enum_t(hazard_e))
+            self.cp_sfp_special_values_on_fs1_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs1_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fs2_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs2_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fs3_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs3_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs3_value = vsc.coverpoint(
+                lambda: self.instr.fs3_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs3_value = vsc.coverpoint(
+                lambda: self.instr.fs3_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs3_value = vsc.coverpoint(
+                lambda: self.instr.fs3_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fd_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fd_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+
+
+    @vsc.covergroup
+    class fmsub_s_cg(object):
+        def __init__(self, precision):
+            super().__init__()
+
+            self.instr = None
+            self.cp_fs1 = vsc.coverpoint(lambda: self.instr.fs1,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs2 = vsc.coverpoint(lambda: self.instr.fs2,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs3 = vsc.coverpoint(lambda: self.instr.fs3,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fd = vsc.coverpoint(lambda: self.instr.fd,
+                                        cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs1_sign = vsc.coverpoint(lambda: self.instr.fs1_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fs2_sign = vsc.coverpoint(lambda: self.instr.fs2_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fs3_sign = vsc.coverpoint(lambda: self.instr.fs3_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fd_sign = vsc.coverpoint(lambda: self.instr.fd_sign,
+                                             cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_gpr_hazard = vsc.coverpoint(lambda: self.instr.gpr_hazard,
+                                                cp_t=vsc.enum_t(hazard_e))
+            self.cp_sign_cross = vsc.cross([self.cp_fs1_sign,
+                                            self.cp_fs2_sign,
+                                            self.cp_fs3_sign,
+                                            self.cp_fd_sign])
+            self.cp_sfp_special_values_on_fs1_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs1_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fs2_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs2_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fs3_value = vsc.coverpoint(lambda:
+                                                                     self.instr.fs3_value[31:0],
+                                                                     bins={"infinity":
+                                                                            vsc.bin_array(
+                                                                                [], 2139095040,
+                                                                                4286578688),
+                                                                            "largest":
+                                                                            vsc.bin_array(
+                                                                                [], 2139095039,
+                                                                                4286578687),
+                                                                            "zeros":
+                                                                            vsc.bin_array(
+                                                                                [], 0,
+                                                                                2147483648),
+                                                                            "NaN":
+                                                                            vsc.bin_array([],
+                                                                                          2139095041,
+                                                                                          2143289344
+                                                                                          )},
+                                                                            options = dict(weight = precision),
+                                                                            type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs3_value = vsc.coverpoint(
+                lambda: self.instr.fs3_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs3_value = vsc.coverpoint(
+                lambda: self.instr.fs3_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs3_value = vsc.coverpoint(
+                lambda: self.instr.fs3_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fd_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fd_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+
+
+    @vsc.covergroup
+    class fmsub_d_cg(object):
+        def __init__(self, precision):
+            super().__init__()
+
+            self.instr = None
+            self.cp_fs1 = vsc.coverpoint(lambda: self.instr.fs1,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs2 = vsc.coverpoint(lambda: self.instr.fs2,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs3 = vsc.coverpoint(lambda: self.instr.fs3,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fd = vsc.coverpoint(lambda: self.instr.fd,
+                                        cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs1_sign = vsc.coverpoint(lambda: self.instr.fs1_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fs2_sign = vsc.coverpoint(lambda: self.instr.fs2_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fs3_sign = vsc.coverpoint(lambda: self.instr.fs3_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fd_sign = vsc.coverpoint(lambda: self.instr.fd_sign,
+                                             cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_gpr_hazard = vsc.coverpoint(lambda: self.instr.gpr_hazard,
+                                                cp_t=vsc.enum_t(hazard_e))
+            self.cp_sign_cross = vsc.cross([self.cp_fs1_sign,
+                                            self.cp_fs2_sign,
+                                            self.cp_fs3_sign,
+                                            self.cp_fd_sign])
+            self.cp_sfp_special_values_on_fs1_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs1_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fs2_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs2_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fs3_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs3_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs3_value = vsc.coverpoint(
+                lambda: self.instr.fs3_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs3_value = vsc.coverpoint(
+                lambda: self.instr.fs3_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs3_value = vsc.coverpoint(
+                lambda: self.instr.fs3_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fd_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fd_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+
+    @vsc.covergroup
+    class fnmsub_s_cg(object):
+        def __init__(self, precision):
+            super().__init__()
+
+            self.instr = None
+            self.cp_fs1 = vsc.coverpoint(lambda: self.instr.fs1,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs2 = vsc.coverpoint(lambda: self.instr.fs2,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs3 = vsc.coverpoint(lambda: self.instr.fs3,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fd = vsc.coverpoint(lambda: self.instr.fd,
+                                        cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs1_sign = vsc.coverpoint(lambda: self.instr.fs1_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fs2_sign = vsc.coverpoint(lambda: self.instr.fs2_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fs3_sign = vsc.coverpoint(lambda: self.instr.fs3_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fd_sign = vsc.coverpoint(lambda: self.instr.fd_sign,
+                                             cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_gpr_hazard = vsc.coverpoint(lambda: self.instr.gpr_hazard,
+                                                cp_t=vsc.enum_t(hazard_e))
+            self.cp_sign_cross = vsc.cross([self.cp_fs1_sign,
+                                            self.cp_fs2_sign,
+                                            self.cp_fs3_sign,
+                                            self.cp_fd_sign])
+            self.cp_sfp_special_values_on_fs1_value = vsc.coverpoint(lambda:
+                                                                   self.instr.fs1_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs1_value = vsc.coverpoint(
+                lambda: self.instr.fs1_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fs2_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs2_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs2_value = vsc.coverpoint(
+                lambda: self.instr.fs2_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fs3_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs3_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                           options = dict(weight = precision),
+                                                                           type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fs3_value = vsc.coverpoint(
+                lambda: self.instr.fs3_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fs3_value = vsc.coverpoint(
+                lambda: self.instr.fs3_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fs3_value = vsc.coverpoint(
+                lambda: self.instr.fs3_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_sfp_special_values_on_fd_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fd_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+
+    @vsc.covergroup
+    class fnmsub_d_cg(object):
+        def __init__(self, precision):
+            super().__init__()
+
+            self.instr = None
+            self.cp_fs1 = vsc.coverpoint(lambda: self.instr.fs1,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs2 = vsc.coverpoint(lambda: self.instr.fs2,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs3 = vsc.coverpoint(lambda: self.instr.fs3,
+                                         cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fd = vsc.coverpoint(lambda: self.instr.fd,
+                                        cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_fs1_sign = vsc.coverpoint(lambda: self.instr.fs1_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fs2_sign = vsc.coverpoint(lambda: self.instr.fs2_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fs3_sign = vsc.coverpoint(lambda: self.instr.fs3_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_fd_sign = vsc.coverpoint(lambda: self.instr.fd_sign,
+                                             cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_gpr_hazard = vsc.coverpoint(lambda: self.instr.gpr_hazard,
+                                                cp_t=vsc.enum_t(hazard_e))
+            self.cp_sign_cross = vsc.cross([self.cp_fs1_sign,
+                                            self.cp_fs2_sign,
+                                            self.cp_fs3_sign,
+                                            self.cp_fd_sign])
+            self.cp_sfp_special_values_on_fs1_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fs1_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                              

same, let's get rid of constants.

aneels3

comment created time in 3 months

PullRequestReviewEvent

Pull request review commentgoogle/riscv-dv

[PyFlow]: Add support for RV32FD coverage

 def __init__(self):                                                   "Aligned"    : vsc.bin(1),
                                                   "Not-aligned": vsc.bin(0)
                                                    })
+    '''Floating instructions'''
+
+    @vsc.covergroup
+    class flw_cg(object):
+        def __init__(self, precision, ignore):
+            super().__init__()
+
+            self.instr = None
+            self.options.ignore = ignore
+            self.cp_rs1 = vsc.coverpoint(lambda: self.instr.rs1,
+                                         cp_t=vsc.enum_t(riscv_reg_ex_zero_t))
+            self.cp_fd = vsc.coverpoint(lambda: self.instr.fd,
+                                        cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_imm_sign = vsc.coverpoint(lambda: self.instr.imm_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_gpr_hazard = vsc.coverpoint(lambda: self.instr.gpr_hazard,
+                                                cp_t=vsc.enum_t(hazard_e))
+            self.cp_lsu_hazard = vsc.coverpoint(lambda: self.instr.lsu_hazard,
+                                                cp_t=vsc.enum_t(
+                                                    branch_hazard_e))
+            self.cp_sfp_special_values_on_fd_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fd_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,
+                                                                              4286578688),
+                                                                          "largest":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095039,
+                                                                              4286578687),
+                                                                          "zeros":
+                                                                          vsc.bin_array(
+                                                                              [], 0,
+                                                                              2147483648),
+                                                                          "NaN":
+                                                                          vsc.bin_array([],
+                                                                                        2139095041,
+                                                                                        2143289344
+                                                                                        )},
+                                                                          options = dict(weight = precision),
+                                                                          type_options = dict(weight = precision))
+            self.cp_sfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[30:pkg_ins.SINGLE_PRECISION_FRACTION_BITS] == 0,
+                cp_t =vsc.int32_t(), options = dict(weight = precision),type_options = dict(weight = precision))
+            self.cp_dfp_special_values_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value, bins={
+                    "infinity": vsc.bin_array([], 9218868437227405312, 18442240474082181120),
+                    "largest": vsc.bin_array([], 9218868437227405311, 18442240474082181119),
+                    "zeros": vsc.bin_array([], 0, 9223372036854775808),
+                    "NaN": vsc.bin_array([], 9218868437227405313, 9221120237041090560)},
+                    options = dict(weight = not precision),type_options = dict(weight = not precision))
+            self.cp_dfp_subnormal_on_fd_value = vsc.coverpoint(
+                lambda: self.instr.fd_value[62:pkg_ins.DOUBLE_PRECISION_FRACTION_BITS - 1] == 0,
+                cp_t=vsc.bit_t(), options = dict(weight = not precision),type_options = dict(weight = not precision))
+
+    @vsc.covergroup
+    class fld_cg(object):
+        def __init__(self, precision):
+            super().__init__()
+
+            self.instr = None
+            self.cp_rs1 = vsc.coverpoint(lambda: self.instr.rs1,
+                                         cp_t=vsc.enum_t(riscv_reg_ex_zero_t))
+            self.cp_fd = vsc.coverpoint(lambda: self.instr.fd,
+                                        cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_imm_sign = vsc.coverpoint(lambda: self.instr.imm_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_gpr_hazard = vsc.coverpoint(lambda: self.instr.gpr_hazard,
+                                                cp_t=vsc.enum_t(hazard_e))
+            self.cp_lsu_hazard = vsc.coverpoint(lambda: self.instr.lsu_hazard,
+                                                cp_t=vsc.enum_t(
+                                                    branch_hazard_e))
+            self.cp_sfp_special_values_on_fd_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fd_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,

same here and below.

aneels3

comment created time in 3 months

PullRequestReviewEvent

Pull request review commentgoogle/riscv-dv

[PyFlow]: Add support for RV32FD coverage

 def __init__(self):                                                   "Aligned"    : vsc.bin(1),
                                                   "Not-aligned": vsc.bin(0)
                                                    })
+    '''Floating instructions'''
+
+    @vsc.covergroup
+    class flw_cg(object):
+        def __init__(self, precision, ignore):
+            super().__init__()
+
+            self.instr = None
+            self.options.ignore = ignore
+            self.cp_rs1 = vsc.coverpoint(lambda: self.instr.rs1,
+                                         cp_t=vsc.enum_t(riscv_reg_ex_zero_t))
+            self.cp_fd = vsc.coverpoint(lambda: self.instr.fd,
+                                        cp_t=vsc.enum_t(riscv_fpr_t))
+            self.cp_imm_sign = vsc.coverpoint(lambda: self.instr.imm_sign,
+                                              cp_t=vsc.enum_t(operand_sign_e))
+            self.cp_gpr_hazard = vsc.coverpoint(lambda: self.instr.gpr_hazard,
+                                                cp_t=vsc.enum_t(hazard_e))
+            self.cp_lsu_hazard = vsc.coverpoint(lambda: self.instr.lsu_hazard,
+                                                cp_t=vsc.enum_t(
+                                                    branch_hazard_e))
+            self.cp_sfp_special_values_on_fd_value = vsc.coverpoint(lambda:
+                                                                    self.instr.fd_value[31:0],
+                                                                    bins={"infinity":
+                                                                          vsc.bin_array(
+                                                                              [], 2139095040,

Can we define these constants as parameters, then use the parameter name (or "parameter_name -1") instead?

aneels3

comment created time in 3 months

PullRequestReviewEvent

Pull request review commentgoogle/riscv-dv

[PyFlow]: Add support for RV32FD coverage

 def pre_randomize(self):             self.fd.rand_mode = bool(self.has_fd)      # coverage related functons-    def update_src_regs(self, operands = []):-        pass+    def update_src_regs(self, instruction, operands):+        if self.riscv_cov_ins is None:+            self.riscv_cov_ins = riscv_cov_instr()+        if instruction.category in ["LOAD", "CSR"]:+            self.riscv_cov_ins.update_src_regs(operands)+        if instruction.format.name == "I_FORMAT":+            logging.info("instr = {}".format(instruction.__dict__))+            if instruction.has_fs1:+                instruction.fs1 = self.get_fpr(operands[1])+                instruction.fs1_value.set_val(self.riscv_cov_ins.get_gpr_state(operands[1]))+            elif instruction.has_rs1:+                instruction.rs1 = self.riscv_cov_ins.get_gpr(operands[1])+                instruction.rs1_value = self.riscv_cov_ins.get_gpr_state(operands[1])+        elif instruction.format.name == "S_FORMAT":+            assert len(operands) == 3+            instruction.fs2 = self.get_fpr(operands[0])+            instruction.fs2_value.set_val(self.riscv_cov_ins.get_gpr_state(operands[0]))+            instruction.rs1 = self.riscv_cov_ins.get_gpr(operands[1])+            instruction.rs1_value = self.riscv_cov_ins.get_gpr_state(operands[1])+            instruction.imm = get_val(operands[2])+        elif instruction.format.name == "R_FORMAT":+            if len(operands) == 2 and instruction.instr.name in ["FSGNJ_S", "FSGNJX_S",+                                                          "FSGNJN_S", "FSGNJ_D",+                                                          "FSGNJX_D", "FSGNJN_D"]:

indent

aneels3

comment created time in 3 months

PullRequestReviewEvent
PullRequestReviewEvent

Pull request review commentgoogle/riscv-dv

[PyFlow]: Add support for RV32FD coverage

 def check_hazard_condition(self, pre_instr):         explicitly extract the destination register from the operands '''         if pre_instr.has_rd:             if ((self.has_rs1 and (self.rs1 == pre_instr.rd)) or-                    (self.has_rs2 and (self.rs1 == pre_instr.rd))):+                    (self.has_rs2 and (self.rs2 == pre_instr.rd))):

Good catch :)

aneels3

comment created time in 3 months

Pull request review commentgoogle/riscv-dv

[PyFlow]: Add support for RV32FD coverage

 def set_mode(self):             if self.format.name == "I_FORMAT":                 self.has_rs1 = 0 +    def set_fd_mode(self):+        # mode setting for F and D Instruction+        if self.format == riscv_instr_format_t.I_FORMAT:+            self.has_fs2 = 0+            if self.category == riscv_instr_category_t.LOAD:+                self.has_imm = 1+            elif self.instr.name in ['FMV_X_W', 'FMV_X_D', 'FCVT_W_S', 'FCVT_WU_S',+                                          'FCVT_L_S', 'FCVT_LU_S', 'FCVT_L_D', 'FCVT_LU_D',+                                          'FCVT_LU_S', 'FCVT_W_D', 'FCVT_WU_D']:

Please indent.

aneels3

comment created time in 3 months

PullRequestReviewEvent
more