arch-riscv: Stop "using namespace std"

[gem5.git] / src / arch / riscv / isa / decoder.isa

diff --git a/src/arch/riscv/isa/decoder.isa b/src/arch/riscv/isa/decoder.isa
index daec4139b67150f817a8e55f8a219206fe8f943b..b7e316122814a0d2a36ca3f88c9fb921e5d6c132 100644 (file)
--- a/src/arch/riscv/isa/decoder.isa
+++ b/src/arch/riscv/isa/decoder.isa
@@ -2,6 +2,7 @@
 
 // Copyright (c) 2015 RISC-V Foundation
 // Copyright (c) 2017 The University of Virginia
+// Copyright (c) 2020 Barkhausen Institut
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -26,8 +27,6 @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Authors: Alec Roelke
 
 ////////////////////////////////////////////////////////////////////
 //
@@ -43,14 +42,19 @@ decode QUADRANT default Unknown::unknown() {
                   CIMM8<5:2> << 6;
         }}, {{
             if (machInst == 0)
-                fault = make_shared<IllegalInstFault>("zero instruction",
-                                                      machInst);
+                fault = std::make_shared<IllegalInstFault>("zero instruction",
+                                                           machInst);
             Rp2 = sp + imm;
         }}, uint64_t);
         format CompressedLoad {
             0x1: c_fld({{
                 offset = CIMM3 << 3 | CIMM2 << 6;
             }}, {{
+                STATUS status = xc->readMiscReg(MISCREG_STATUS);
+                if (status.fs == FPUStatus::OFF)
+                    fault = std::make_shared<IllegalInstFault>("FPU is off",
+                                                               machInst);
+
                 Fp2_bits = Mem;
             }}, {{
                 EA = Rp1 + offset;
@@ -76,6 +80,11 @@ decode QUADRANT default Unknown::unknown() {
             0x5: c_fsd({{
                 offset = CIMM3 << 3 | CIMM2 << 6;
             }}, {{
+                STATUS status = xc->readMiscReg(MISCREG_STATUS);
+                if (status.fs == FPUStatus::OFF)
+                    fault = std::make_shared<IllegalInstFault>("FPU is off",
+                                                               machInst);
+
                 Mem = Fp2_bits;
             }}, {{
                 EA = Rp1 + offset;
@@ -107,11 +116,11 @@ decode QUADRANT default Unknown::unknown() {
             }}, {{
                 if ((RC1 == 0) != (imm == 0)) {
                     if (RC1 == 0) {
-                        fault = make_shared<IllegalInstFault>("source reg x0",
-                                                              machInst);
+                        fault = std::make_shared<IllegalInstFault>(
+                                "source reg x0", machInst);
                     } else // imm == 0
-                        fault = make_shared<IllegalInstFault>("immediate = 0",
-                                                              machInst);
+                        fault = std::make_shared<IllegalInstFault>(
+                                "immediate = 0", machInst);
                 }
                 Rc1_sd = Rc1_sd + imm;
             }});
@@ -121,8 +130,8 @@ decode QUADRANT default Unknown::unknown() {
                     imm |= ~((uint64_t)0x1F);
             }}, {{
                 if (RC1 == 0) {
-                    fault = make_shared<IllegalInstFault>("source reg x0",
-                                                          machInst);
+                    fault = std::make_shared<IllegalInstFault>(
+                            "source reg x0", machInst);
                 }
                 Rc1_sd = (int32_t)Rc1_sd + imm;
             }});
@@ -132,8 +141,8 @@ decode QUADRANT default Unknown::unknown() {
                     imm |= ~((uint64_t)0x1F);
             }}, {{
                 if (RC1 == 0) {
-                    fault = make_shared<IllegalInstFault>("source reg x0",
-                                                          machInst);
+                    fault = std::make_shared<IllegalInstFault>(
+                            "source reg x0", machInst);
                 }
                 Rc1_sd = imm;
             }});
@@ -147,8 +156,8 @@ decode QUADRANT default Unknown::unknown() {
                         imm |= ~((int64_t)0x1FF);
                 }}, {{
                     if (imm == 0) {
-                        fault = make_shared<IllegalInstFault>("immediate = 0",
-                                                              machInst);
+                        fault = std::make_shared<IllegalInstFault>(
+                                "immediate = 0", machInst);
                     }
                     sp_sd = sp_sd + imm;
                 }});
@@ -158,12 +167,12 @@ decode QUADRANT default Unknown::unknown() {
                         imm |= ~((uint64_t)0x1FFFF);
                 }}, {{
                     if (RC1 == 0 || RC1 == 2) {
-                        fault = make_shared<IllegalInstFault>("source reg x0",
-                                                              machInst);
+                        fault = std::make_shared<IllegalInstFault>(
+                                "source reg x0", machInst);
                     }
                     if (imm == 0) {
-                        fault = make_shared<IllegalInstFault>("immediate = 0",
-                                                              machInst);
+                        fault = std::make_shared<IllegalInstFault>(
+                                "immediate = 0", machInst);
                     }
                     Rc1_sd = imm;
                 }});
@@ -175,8 +184,8 @@ decode QUADRANT default Unknown::unknown() {
                     imm = CIMM5 | (CIMM1 << 5);
                 }}, {{
                     if (imm == 0) {
-                        fault = make_shared<IllegalInstFault>("immediate = 0",
-                                                              machInst);
+                        fault = std::make_shared<IllegalInstFault>(
+                                "immediate = 0", machInst);
                     }
                     Rp1 = Rp1 >> imm;
                 }}, uint64_t);
@@ -184,8 +193,8 @@ decode QUADRANT default Unknown::unknown() {
                     imm = CIMM5 | (CIMM1 << 5);
                 }}, {{
                     if (imm == 0) {
-                        fault = make_shared<IllegalInstFault>("immediate = 0",
-                                                              machInst);
+                        fault = std::make_shared<IllegalInstFault>(
+                                "immediate = 0", machInst);
                     }
                     Rp1_sd = Rp1_sd >> imm;
                 }}, uint64_t);
@@ -247,12 +256,12 @@ decode QUADRANT default Unknown::unknown() {
             imm = CIMM5 | (CIMM1 << 5);
         }}, {{
             if (imm == 0) {
-                fault = make_shared<IllegalInstFault>("immediate = 0",
-                                                      machInst);
+                fault = std::make_shared<IllegalInstFault>(
+                        "immediate = 0", machInst);
             }
             if (RC1 == 0) {
-                fault = make_shared<IllegalInstFault>("source reg x0",
-                                                      machInst);
+                fault = std::make_shared<IllegalInstFault>(
+                        "source reg x0", machInst);
             }
             Rc1 = Rc1 << imm;
         }}, uint64_t);
@@ -272,8 +281,8 @@ decode QUADRANT default Unknown::unknown() {
                          CIMM5<1:0> << 6;
             }}, {{
                 if (RC1 == 0) {
-                    fault = make_shared<IllegalInstFault>("source reg x0",
-                                                          machInst);
+                    fault = std::make_shared<IllegalInstFault>(
+                            "source reg x0", machInst);
                 }
                 Rc1_sd = Mem_sw;
             }}, {{
@@ -285,8 +294,8 @@ decode QUADRANT default Unknown::unknown() {
                          CIMM5<2:0> << 6;
             }}, {{
                 if (RC1 == 0) {
-                    fault = make_shared<IllegalInstFault>("source reg x0",
-                                                          machInst);
+                    fault = std::make_shared<IllegalInstFault>(
+                            "source reg x0", machInst);
                 }
                 Rc1_sd = Mem_sd;
             }}, {{
@@ -297,15 +306,15 @@ decode QUADRANT default Unknown::unknown() {
             0x0: decode RC2 {
                 0x0: Jump::c_jr({{
                     if (RC1 == 0) {
-                        fault = make_shared<IllegalInstFault>("source reg x0",
-                                                              machInst);
+                        fault = std::make_shared<IllegalInstFault>(
+                                "source reg x0", machInst);
                     }
                     NPC = Rc1;
                 }}, IsIndirectControl, IsUncondControl, IsCall);
                 default: CROp::c_mv({{
                     if (RC1 == 0) {
-                        fault = make_shared<IllegalInstFault>("source reg x0",
-                                                              machInst);
+                        fault = std::make_shared<IllegalInstFault>(
+                                "source reg x0", machInst);
                     }
                     Rc1 = Rc2;
                 }});
@@ -313,17 +322,16 @@ decode QUADRANT default Unknown::unknown() {
             0x1: decode RC1 {
                 0x0: SystemOp::c_ebreak({{
                     if (RC2 != 0) {
-                        fault = make_shared<IllegalInstFault>("source reg x1",
-                                                              machInst);
+                        fault = std::make_shared<IllegalInstFault>(
+                                "source reg x1", machInst);
                     }
-                    fault = make_shared<BreakpointFault>(xc->pcState());
+                    fault = std::make_shared<BreakpointFault>(xc->pcState());
                 }}, IsSerializeAfter, IsNonSpeculative, No_OpClass);
                 default: decode RC2 {
                     0x0: Jump::c_jalr({{
                         if (RC1 == 0) {
-                            fault = make_shared<IllegalInstFault>
-                                                        ("source reg x0",
-                                                         machInst);
+                            fault = std::make_shared<IllegalInstFault>(
+                                    "source reg x0", machInst);
                         }
                         ra = NPC;
                         NPC = Rc1;
@@ -391,9 +399,20 @@ decode QUADRANT default Unknown::unknown() {
         0x01: decode FUNCT3 {
             format Load {
                 0x2: flw({{
+                    STATUS status = xc->readMiscReg(MISCREG_STATUS);
+                    if (status.fs == FPUStatus::OFF) {
+                        fault = std::make_shared<IllegalInstFault>(
+                                "FPU is off", machInst);
+                    }
+
                     Fd_bits = (uint64_t)Mem_uw;
                 }}, inst_flags=FloatMemReadOp);
                 0x3: fld({{
+                    STATUS status = xc->readMiscReg(MISCREG_STATUS);
+                    if (status.fs == FPUStatus::OFF)
+                        fault = std::make_shared<IllegalInstFault>(
+                                "FPU is off", machInst);
+
                     Fd_bits = Mem;
                 }}, inst_flags=FloatMemReadOp);
             }
@@ -402,7 +421,7 @@ decode QUADRANT default Unknown::unknown() {
         0x03: decode FUNCT3 {
             format FenceOp {
                 0x0: fence({{
-                }}, uint64_t, IsMemBarrier, No_OpClass);
+                }}, uint64_t, IsReadBarrier, IsWriteBarrier, No_OpClass);
                 0x1: fence_i({{
                 }}, uint64_t, IsNonSpeculative, IsSerializeAfter, No_OpClass);
             }
@@ -485,9 +504,19 @@ decode QUADRANT default Unknown::unknown() {
         0x09: decode FUNCT3 {
             format Store {
                 0x2: fsw({{
+                    STATUS status = xc->readMiscReg(MISCREG_STATUS);
+                    if (status.fs == FPUStatus::OFF)
+                        fault = std::make_shared<IllegalInstFault>(
+                                "FPU is off", machInst);
+
                     Mem_uw = (uint32_t)Fs2_bits;
                 }}, inst_flags=FloatMemWriteOp);
                 0x3: fsd({{
+                    STATUS status = xc->readMiscReg(MISCREG_STATUS);
+                    if (status.fs == FPUStatus::OFF)
+                        fault = std::make_shared<IllegalInstFault>(
+                                "FPU is off", machInst);
+
                     Mem_ud = Fs2_bits;
                 }}, inst_flags=FloatMemWriteOp);
             }
@@ -733,9 +762,10 @@ decode QUADRANT default Unknown::unknown() {
                     0x1: div({{
                         if (Rs2_sd == 0) {
                             Rd_sd = -1;
-                        } else if (Rs1_sd == numeric_limits<int64_t>::min()
+                        } else if (
+                                Rs1_sd == std::numeric_limits<int64_t>::min()
                                 && Rs2_sd == -1) {
-                            Rd_sd = numeric_limits<int64_t>::min();
+                            Rd_sd = std::numeric_limits<int64_t>::min();
                         } else {
                             Rd_sd = Rs1_sd/Rs2_sd;
                         }
@@ -747,7 +777,7 @@ decode QUADRANT default Unknown::unknown() {
                     }});
                     0x1: divu({{
                         if (Rs2 == 0) {
-                            Rd = numeric_limits<uint64_t>::max();
+                            Rd = std::numeric_limits<uint64_t>::max();
                         } else {
                             Rd = Rs1/Rs2;
                         }
@@ -763,7 +793,8 @@ decode QUADRANT default Unknown::unknown() {
                     0x1: rem({{
                         if (Rs2_sd == 0) {
                             Rd = Rs1_sd;
-                        } else if (Rs1_sd == numeric_limits<int64_t>::min()
+                        } else if (
+                                Rs1_sd == std::numeric_limits<int64_t>::min()
                                 && Rs2_sd == -1) {
                             Rd = 0;
                         } else {
@@ -809,9 +840,9 @@ decode QUADRANT default Unknown::unknown() {
                 0x4: divw({{
                     if (Rs2_sw == 0) {
                         Rd_sd = -1;
-                    } else if (Rs1_sw == numeric_limits<int32_t>::min()
+                    } else if (Rs1_sw == std::numeric_limits<int32_t>::min()
                             && Rs2_sw == -1) {
-                        Rd_sd = numeric_limits<int32_t>::min();
+                        Rd_sd = std::numeric_limits<int32_t>::min();
                     } else {
                         Rd_sd = Rs1_sw/Rs2_sw;
                     }
@@ -822,7 +853,7 @@ decode QUADRANT default Unknown::unknown() {
                     }});
                     0x1: divuw({{
                         if (Rs2_uw == 0) {
-                            Rd_sd = numeric_limits<uint64_t>::max();
+                            Rd_sd = std::numeric_limits<uint64_t>::max();
                         } else {
                             Rd_sd = (int32_t)(Rs1_uw/Rs2_uw);
                         }
@@ -834,7 +865,7 @@ decode QUADRANT default Unknown::unknown() {
                 0x6: remw({{
                     if (Rs2_sw == 0) {
                         Rd_sd = Rs1_sw;
-                    } else if (Rs1_sw == numeric_limits<int32_t>::min()
+                    } else if (Rs1_sw == std::numeric_limits<int32_t>::min()
                             && Rs2_sw == -1) {
                         Rd_sd = 0;
                     } else {
@@ -866,15 +897,15 @@ decode QUADRANT default Unknown::unknown() {
                                 || issignalingnan(fs3)) {
                             FFLAGS |= FloatInvalid;
                         }
-                        fd = numeric_limits<float>::quiet_NaN();
+                        fd = std::numeric_limits<float>::quiet_NaN();
                     } else if (std::isinf(fs1) || std::isinf(fs2) ||
                             std::isinf(fs3)) {
-                        if (signbit(fs1) == signbit(fs2)
+                        if (std::signbit(fs1) == std::signbit(fs2)
                                 && !std::isinf(fs3)) {
-                            fd = numeric_limits<float>::infinity();
-                        } else if (signbit(fs1) != signbit(fs2)
+                            fd = std::numeric_limits<float>::infinity();
+                        } else if (std::signbit(fs1) != std::signbit(fs2)
                                 && !std::isinf(fs3)) {
-                            fd = -numeric_limits<float>::infinity();
+                            fd = -std::numeric_limits<float>::infinity();
                         } else { // Fs3_sf is infinity
                             fd = fs3;
                         }
@@ -890,15 +921,15 @@ decode QUADRANT default Unknown::unknown() {
                                 || issignalingnan(Fs3)) {
                             FFLAGS |= FloatInvalid;
                         }
-                        Fd = numeric_limits<double>::quiet_NaN();
+                        Fd = std::numeric_limits<double>::quiet_NaN();
                     } else if (std::isinf(Fs1) || std::isinf(Fs2) ||
                             std::isinf(Fs3)) {
-                        if (signbit(Fs1) == signbit(Fs2)
+                        if (std::signbit(Fs1) == std::signbit(Fs2)
                                 && !std::isinf(Fs3)) {
-                            Fd = numeric_limits<double>::infinity();
-                        } else if (signbit(Fs1) != signbit(Fs2)
+                            Fd = std::numeric_limits<double>::infinity();
+                        } else if (std::signbit(Fs1) != std::signbit(Fs2)
                                 && !std::isinf(Fs3)) {
-                            Fd = -numeric_limits<double>::infinity();
+                            Fd = -std::numeric_limits<double>::infinity();
                         } else {
                             Fd = Fs3;
                         }
@@ -921,15 +952,15 @@ decode QUADRANT default Unknown::unknown() {
                                 || issignalingnan(fs3)) {
                             FFLAGS |= FloatInvalid;
                         }
-                        fd = numeric_limits<float>::quiet_NaN();
+                        fd = std::numeric_limits<float>::quiet_NaN();
                     } else if (std::isinf(fs1) || std::isinf(fs2) ||
                             std::isinf(fs3)) {
-                        if (signbit(fs1) == signbit(fs2)
+                        if (std::signbit(fs1) == std::signbit(fs2)
                                 && !std::isinf(fs3)) {
-                            fd = numeric_limits<float>::infinity();
-                        } else if (signbit(fs1) != signbit(fs2)
+                            fd = std::numeric_limits<float>::infinity();
+                        } else if (std::signbit(fs1) != std::signbit(fs2)
                                 && !std::isinf(fs3)) {
-                            fd = -numeric_limits<float>::infinity();
+                            fd = -std::numeric_limits<float>::infinity();
                         } else { // Fs3_sf is infinity
                             fd = -fs3;
                         }
@@ -945,15 +976,15 @@ decode QUADRANT default Unknown::unknown() {
                                 || issignalingnan(Fs3)) {
                             FFLAGS |= FloatInvalid;
                         }
-                        Fd = numeric_limits<double>::quiet_NaN();
+                        Fd = std::numeric_limits<double>::quiet_NaN();
                     } else if (std::isinf(Fs1) || std::isinf(Fs2) ||
                             std::isinf(Fs3)) {
-                        if (signbit(Fs1) == signbit(Fs2)
+                        if (std::signbit(Fs1) == std::signbit(Fs2)
                                 && !std::isinf(Fs3)) {
-                            Fd = numeric_limits<double>::infinity();
-                        } else if (signbit(Fs1) != signbit(Fs2)
+                            Fd = std::numeric_limits<double>::infinity();
+                        } else if (std::signbit(Fs1) != std::signbit(Fs2)
                                 && !std::isinf(Fs3)) {
-                            Fd = -numeric_limits<double>::infinity();
+                            Fd = -std::numeric_limits<double>::infinity();
                         } else {
                             Fd = -Fs3;
                         }
@@ -976,15 +1007,15 @@ decode QUADRANT default Unknown::unknown() {
                                 || issignalingnan(fs3)) {
                             FFLAGS |= FloatInvalid;
                         }
-                        fd = numeric_limits<float>::quiet_NaN();
+                        fd = std::numeric_limits<float>::quiet_NaN();
                     } else if (std::isinf(fs1) || std::isinf(fs2) ||
                             std::isinf(fs3)) {
-                        if (signbit(fs1) == signbit(fs2)
+                        if (std::signbit(fs1) == std::signbit(fs2)
                                 && !std::isinf(fs3)) {
-                            fd = -numeric_limits<float>::infinity();
-                        } else if (signbit(fs1) != signbit(fs2)
+                            fd = -std::numeric_limits<float>::infinity();
+                        } else if (std::signbit(fs1) != std::signbit(fs2)
                                 && !std::isinf(fs3)) {
-                            fd = numeric_limits<float>::infinity();
+                            fd = std::numeric_limits<float>::infinity();
                         } else { // Fs3_sf is infinity
                             fd = fs3;
                         }
@@ -1000,15 +1031,15 @@ decode QUADRANT default Unknown::unknown() {
                                 || issignalingnan(Fs3)) {
                             FFLAGS |= FloatInvalid;
                         }
-                        Fd = numeric_limits<double>::quiet_NaN();
+                        Fd = std::numeric_limits<double>::quiet_NaN();
                     } else if (std::isinf(Fs1) || std::isinf(Fs2)
                             || std::isinf(Fs3)) {
-                        if (signbit(Fs1) == signbit(Fs2)
+                        if (std::signbit(Fs1) == std::signbit(Fs2)
                                 && !std::isinf(Fs3)) {
-                            Fd = -numeric_limits<double>::infinity();
-                        } else if (signbit(Fs1) != signbit(Fs2)
+                            Fd = -std::numeric_limits<double>::infinity();
+                        } else if (std::signbit(Fs1) != std::signbit(Fs2)
                                 && !std::isinf(Fs3)) {
-                            Fd = numeric_limits<double>::infinity();
+                            Fd = std::numeric_limits<double>::infinity();
                         } else {
                             Fd = Fs3;
                         }
@@ -1031,15 +1062,15 @@ decode QUADRANT default Unknown::unknown() {
                                 || issignalingnan(fs3)) {
                             FFLAGS |= FloatInvalid;
                         }
-                        fd = numeric_limits<float>::quiet_NaN();
+                        fd = std::numeric_limits<float>::quiet_NaN();
                     } else if (std::isinf(fs1) || std::isinf(fs2) ||
                             std::isinf(fs3)) {
-                        if (signbit(fs1) == signbit(fs2)
+                        if (std::signbit(fs1) == std::signbit(fs2)
                                 && !std::isinf(fs3)) {
-                            fd = -numeric_limits<float>::infinity();
-                        } else if (signbit(fs1) != signbit(fs2)
+                            fd = -std::numeric_limits<float>::infinity();
+                        } else if (std::signbit(fs1) != std::signbit(fs2)
                                 && !std::isinf(fs3)) {
-                            fd = numeric_limits<float>::infinity();
+                            fd = std::numeric_limits<float>::infinity();
                         } else { // Fs3_sf is infinity
                             fd = -fs3;
                         }
@@ -1055,15 +1086,15 @@ decode QUADRANT default Unknown::unknown() {
                                 || issignalingnan(Fs3)) {
                             FFLAGS |= FloatInvalid;
                         }
-                        Fd = numeric_limits<double>::quiet_NaN();
+                        Fd = std::numeric_limits<double>::quiet_NaN();
                     } else if (std::isinf(Fs1) || std::isinf(Fs2) ||
                             std::isinf(Fs3)) {
-                        if (signbit(Fs1) == signbit(Fs2)
+                        if (std::signbit(Fs1) == std::signbit(Fs2)
                                 && !std::isinf(Fs3)) {
-                            Fd = -numeric_limits<double>::infinity();
-                        } else if (signbit(Fs1) != signbit(Fs2)
+                            Fd = -std::numeric_limits<double>::infinity();
+                        } else if (std::signbit(Fs1) != std::signbit(Fs2)
                                 && !std::isinf(Fs3)) {
-                            Fd = numeric_limits<double>::infinity();
+                            Fd = std::numeric_limits<double>::infinity();
                         } else {
                             Fd = -Fs3;
                         }
@@ -1083,7 +1114,7 @@ decode QUADRANT default Unknown::unknown() {
                         if (issignalingnan(fs1) || issignalingnan(fs2)) {
                             FFLAGS |= FloatInvalid;
                         }
-                        fd = numeric_limits<float>::quiet_NaN();
+                        fd = std::numeric_limits<float>::quiet_NaN();
                     } else {
                         fd = fs1 + fs2;
                     }
@@ -1094,7 +1125,7 @@ decode QUADRANT default Unknown::unknown() {
                         if (issignalingnan(Fs1) || issignalingnan(Fs2)) {
                             FFLAGS |= FloatInvalid;
                         }
-                        Fd = numeric_limits<double>::quiet_NaN();
+                        Fd = std::numeric_limits<double>::quiet_NaN();
                     } else {
                         Fd = Fs1 + Fs2;
                     }
@@ -1109,7 +1140,7 @@ decode QUADRANT default Unknown::unknown() {
                         if (issignalingnan(fs1) || issignalingnan(fs2)) {
                             FFLAGS |= FloatInvalid;
                         }
-                        fd = numeric_limits<float>::quiet_NaN();
+                        fd = std::numeric_limits<float>::quiet_NaN();
                     } else {
                         fd = fs1 - fs2;
                     }
@@ -1120,7 +1151,7 @@ decode QUADRANT default Unknown::unknown() {
                         if (issignalingnan(Fs1) || issignalingnan(Fs2)) {
                             FFLAGS |= FloatInvalid;
                         }
-                        Fd = numeric_limits<double>::quiet_NaN();
+                        Fd = std::numeric_limits<double>::quiet_NaN();
                     } else {
                         Fd = Fs1 - Fs2;
                     }
@@ -1135,7 +1166,7 @@ decode QUADRANT default Unknown::unknown() {
                         if (issignalingnan(fs1) || issignalingnan(fs2)) {
                             FFLAGS |= FloatInvalid;
                         }
-                        fd = numeric_limits<float>::quiet_NaN();
+                        fd = std::numeric_limits<float>::quiet_NaN();
                     } else {
                         fd = fs1*fs2;
                     }
@@ -1146,7 +1177,7 @@ decode QUADRANT default Unknown::unknown() {
                         if (issignalingnan(Fs1) || issignalingnan(Fs2)) {
                             FFLAGS |= FloatInvalid;
                         }
-                        Fd = numeric_limits<double>::quiet_NaN();
+                        Fd = std::numeric_limits<double>::quiet_NaN();
                     } else {
                         Fd = Fs1*Fs2;
                     }
@@ -1161,7 +1192,7 @@ decode QUADRANT default Unknown::unknown() {
                         if (issignalingnan(fs1) || issignalingnan(fs2)) {
                             FFLAGS |= FloatInvalid;
                         }
-                        fd = numeric_limits<float>::quiet_NaN();
+                        fd = std::numeric_limits<float>::quiet_NaN();
                     } else {
                         fd = fs1/fs2;
                     }
@@ -1172,7 +1203,7 @@ decode QUADRANT default Unknown::unknown() {
                         if (issignalingnan(Fs1) || issignalingnan(Fs2)) {
                             FFLAGS |= FloatInvalid;
                         }
-                        Fd = numeric_limits<double>::quiet_NaN();
+                        Fd = std::numeric_limits<double>::quiet_NaN();
                     } else {
                         Fd = Fs1/Fs2;
                     }
@@ -1185,7 +1216,7 @@ decode QUADRANT default Unknown::unknown() {
                         float fd;
 
                         if (issignalingnan(fs1)) {
-                            fd = numeric_limits<float>::signaling_NaN();
+                            fd = std::numeric_limits<float>::signaling_NaN();
                             feclearexcept(FE_INVALID);
                         } else {
                             fd = copysign(fs1, fs2);
@@ -1199,7 +1230,7 @@ decode QUADRANT default Unknown::unknown() {
                         float fd;
 
                         if (issignalingnan(fs1)) {
-                            fd = numeric_limits<float>::signaling_NaN();
+                            fd = std::numeric_limits<float>::signaling_NaN();
                             feclearexcept(FE_INVALID);
                         } else {
                             fd = copysign(fs1, -fs2);
@@ -1213,10 +1244,10 @@ decode QUADRANT default Unknown::unknown() {
                         float fd;
 
                         if (issignalingnan(fs1)) {
-                            fd = numeric_limits<float>::signaling_NaN();
+                            fd = std::numeric_limits<float>::signaling_NaN();
                             feclearexcept(FE_INVALID);
                         } else {
-                            fd = fs1*(signbit(fs2) ? -1.0 : 1.0);
+                            fd = fs1*(std::signbit(fs2) ? -1.0 : 1.0);
                         }
                         Fd_bits = (uint64_t)reinterpret_cast<uint32_t&>(fd);
                     }}, FloatMiscOp);
@@ -1224,7 +1255,7 @@ decode QUADRANT default Unknown::unknown() {
                 0x11: decode ROUND_MODE {
                     0x0: fsgnj_d({{
                         if (issignalingnan(Fs1)) {
-                            Fd = numeric_limits<double>::signaling_NaN();
+                            Fd = std::numeric_limits<double>::signaling_NaN();
                             feclearexcept(FE_INVALID);
                         } else {
                             Fd = copysign(Fs1, Fs2);
@@ -1232,7 +1263,7 @@ decode QUADRANT default Unknown::unknown() {
                     }}, FloatMiscOp);
                     0x1: fsgnjn_d({{
                         if (issignalingnan(Fs1)) {
-                            Fd = numeric_limits<double>::signaling_NaN();
+                            Fd = std::numeric_limits<double>::signaling_NaN();
                             feclearexcept(FE_INVALID);
                         } else {
                             Fd = copysign(Fs1, -Fs2);
@@ -1240,10 +1271,10 @@ decode QUADRANT default Unknown::unknown() {
                     }}, FloatMiscOp);
                     0x2: fsgnjx_d({{
                         if (issignalingnan(Fs1)) {
-                            Fd = numeric_limits<double>::signaling_NaN();
+                            Fd = std::numeric_limits<double>::signaling_NaN();
                             feclearexcept(FE_INVALID);
                         } else {
-                            Fd = Fs1*(signbit(Fs2) ? -1.0 : 1.0);
+                            Fd = Fs1*(std::signbit(Fs2) ? -1.0 : 1.0);
                         }
                     }}, FloatMiscOp);
                 }
@@ -1309,12 +1340,12 @@ decode QUADRANT default Unknown::unknown() {
                 }
                 0x20: fcvt_s_d({{
                     if (CONV_SGN != 1) {
-                        fault = make_shared<IllegalInstFault>("CONV_SGN != 1",
-                                                              machInst);
+                        fault = std::make_shared<IllegalInstFault>(
+                                "CONV_SGN != 1", machInst);
                     }
                     float fd;
                     if (issignalingnan(Fs1)) {
-                        fd = numeric_limits<float>::quiet_NaN();
+                        fd = std::numeric_limits<float>::quiet_NaN();
                         FFLAGS |= FloatInvalid;
                     } else {
                         fd = (float)Fs1;
@@ -1323,14 +1354,14 @@ decode QUADRANT default Unknown::unknown() {
                 }}, FloatCvtOp);
                 0x21: fcvt_d_s({{
                     if (CONV_SGN != 0) {
-                        fault = make_shared<IllegalInstFault>("CONV_SGN != 0",
-                                                              machInst);
+                        fault = std::make_shared<IllegalInstFault>(
+                                "CONV_SGN != 0", machInst);
                     }
                     uint32_t temp;
                     float fs1 = reinterpret_cast<float&>(temp = Fs1_bits);
 
                     if (issignalingnan(fs1)) {
-                        Fd = numeric_limits<double>::quiet_NaN();
+                        Fd = std::numeric_limits<double>::quiet_NaN();
                         FFLAGS |= FloatInvalid;
                     } else {
                         Fd = (double)fs1;
@@ -1338,8 +1369,8 @@ decode QUADRANT default Unknown::unknown() {
                 }}, FloatCvtOp);
                 0x2c: fsqrt_s({{
                     if (RS2 != 0) {
-                        fault = make_shared<IllegalInstFault>("source reg x1",
-                                                              machInst);
+                        fault = std::make_shared<IllegalInstFault>(
+                                "source reg x1", machInst);
                     }
                     uint32_t temp;
                     float fs1 = reinterpret_cast<float&>(temp = Fs1_bits);
@@ -1353,8 +1384,8 @@ decode QUADRANT default Unknown::unknown() {
                 }}, FloatSqrtOp);
                 0x2d: fsqrt_d({{
                     if (RS2 != 0) {
-                        fault = make_shared<IllegalInstFault>("source reg x1",
-                                                              machInst);
+                        fault = std::make_shared<IllegalInstFault>(
+                                "source reg x1", machInst);
                     }
                     Fd = sqrt(Fs1);
                 }}, FloatSqrtOp);
@@ -1424,13 +1455,15 @@ decode QUADRANT default Unknown::unknown() {
                         float fs1 = reinterpret_cast<float&>(temp = Fs1_bits);
 
                         if (std::isnan(fs1)) {
-                            Rd_sd = numeric_limits<int32_t>::max();
+                            Rd_sd = std::numeric_limits<int32_t>::max();
                             FFLAGS |= FloatInvalid;
-                        } else if (fs1 >= numeric_limits<int32_t>::max()) {
-                            Rd_sd = numeric_limits<int32_t>::max();
+                        } else if (fs1 >=
+                                float(std::numeric_limits<int32_t>::max())) {
+                            Rd_sd = std::numeric_limits<int32_t>::max();
                             FFLAGS |= FloatInvalid;
-                        } else if (fs1 <= numeric_limits<int32_t>::min()) {
-                            Rd_sd = numeric_limits<int32_t>::min();
+                        } else if (fs1 <=
+                                float(std::numeric_limits<int32_t>::min())) {
+                            Rd_sd = std::numeric_limits<int32_t>::min();
                             FFLAGS |= FloatInvalid;
                         } else {
                             Rd_sd = (int32_t)fs1;
@@ -1441,13 +1474,14 @@ decode QUADRANT default Unknown::unknown() {
                         float fs1 = reinterpret_cast<float&>(temp = Fs1_bits);
 
                         if (std::isnan(fs1)) {
-                            Rd = numeric_limits<uint64_t>::max();
+                            Rd = std::numeric_limits<uint64_t>::max();
                             FFLAGS |= FloatInvalid;
                         } else if (fs1 < 0.0) {
                             Rd = 0;
                             FFLAGS |= FloatInvalid;
-                        } else if (fs1 > numeric_limits<uint32_t>::max()) {
-                            Rd = numeric_limits<uint64_t>::max();
+                        } else if (fs1 >
+                                float(std::numeric_limits<uint32_t>::max())) {
+                            Rd = std::numeric_limits<uint64_t>::max();
                             FFLAGS |= FloatInvalid;
                         } else {
                             Rd = (uint32_t)fs1;
@@ -1458,13 +1492,15 @@ decode QUADRANT default Unknown::unknown() {
                         float fs1 = reinterpret_cast<float&>(temp = Fs1_bits);
 
                         if (std::isnan(fs1)) {
-                            Rd_sd = numeric_limits<int64_t>::max();
+                            Rd_sd = std::numeric_limits<int64_t>::max();
                             FFLAGS |= FloatInvalid;
-                        } else if (fs1 > numeric_limits<int64_t>::max()) {
-                            Rd_sd = numeric_limits<int64_t>::max();
+                        } else if (fs1 >
+                                float(std::numeric_limits<int64_t>::max())) {
+                            Rd_sd = std::numeric_limits<int64_t>::max();
                             FFLAGS |= FloatInvalid;
-                        } else if (fs1 < numeric_limits<int64_t>::min()) {
-                            Rd_sd = numeric_limits<int64_t>::min();
+                        } else if (fs1 <
+                                float(std::numeric_limits<int64_t>::min())) {
+                            Rd_sd = std::numeric_limits<int64_t>::min();
                             FFLAGS |= FloatInvalid;
                         } else {
                             Rd_sd = (int64_t)fs1;
@@ -1475,13 +1511,14 @@ decode QUADRANT default Unknown::unknown() {
                         float fs1 = reinterpret_cast<float&>(temp = Fs1_bits);
 
                         if (std::isnan(fs1)) {
-                            Rd = numeric_limits<uint64_t>::max();
+                            Rd = std::numeric_limits<uint64_t>::max();
                             FFLAGS |= FloatInvalid;
                         } else if (fs1 < 0.0) {
                             Rd = 0;
                             FFLAGS |= FloatInvalid;
-                        } else if (fs1 > numeric_limits<uint64_t>::max()) {
-                            Rd = numeric_limits<uint64_t>::max();
+                        } else if (fs1 >
+                                float(std::numeric_limits<uint64_t>::max())) {
+                            Rd = std::numeric_limits<uint64_t>::max();
                             FFLAGS |= FloatInvalid;
                         } else {
                             Rd = (uint64_t)fs1;
@@ -1491,13 +1528,15 @@ decode QUADRANT default Unknown::unknown() {
                 0x61: decode CONV_SGN {
                     0x0: fcvt_w_d({{
                         if (std::isnan(Fs1)) {
-                            Rd_sd = numeric_limits<int32_t>::max();
+                            Rd_sd = std::numeric_limits<int32_t>::max();
                             FFLAGS |= FloatInvalid;
-                        } else if (Fs1 > numeric_limits<int32_t>::max()) {
-                            Rd_sd = numeric_limits<int32_t>::max();
+                        } else if (Fs1 >
+                                float(std::numeric_limits<int32_t>::max())) {
+                            Rd_sd = std::numeric_limits<int32_t>::max();
                             FFLAGS |= FloatInvalid;
-                        } else if (Fs1 < numeric_limits<int32_t>::min()) {
-                            Rd_sd = numeric_limits<int32_t>::min();
+                        } else if (Fs1 <
+                                float(std::numeric_limits<int32_t>::min())) {
+                            Rd_sd = std::numeric_limits<int32_t>::min();
                             FFLAGS |= FloatInvalid;
                         } else {
                             Rd_sd = (int32_t)Fs1;
@@ -1505,13 +1544,14 @@ decode QUADRANT default Unknown::unknown() {
                     }}, FloatCvtOp);
                     0x1: fcvt_wu_d({{
                         if (std::isnan(Fs1)) {
-                            Rd = numeric_limits<uint64_t>::max();
+                            Rd = std::numeric_limits<uint64_t>::max();
                             FFLAGS |= FloatInvalid;
                         } else if (Fs1 < 0) {
                             Rd = 0;
                             FFLAGS |= FloatInvalid;
-                        } else if (Fs1 > numeric_limits<uint32_t>::max()) {
-                            Rd = numeric_limits<uint64_t>::max();
+                        } else if (Fs1 >
+                                float(std::numeric_limits<uint32_t>::max())) {
+                            Rd = std::numeric_limits<uint64_t>::max();
                             FFLAGS |= FloatInvalid;
                         } else {
                             Rd = (uint32_t)Fs1;
@@ -1519,13 +1559,15 @@ decode QUADRANT default Unknown::unknown() {
                     }}, FloatCvtOp);
                     0x2: fcvt_l_d({{
                         if (std::isnan(Fs1)) {
-                            Rd_sd = numeric_limits<int64_t>::max();
+                            Rd_sd = std::numeric_limits<int64_t>::max();
                             FFLAGS |= FloatInvalid;
-                        } else if (Fs1 > numeric_limits<int64_t>::max()) {
-                            Rd_sd = numeric_limits<int64_t>::max();
+                        } else if (Fs1 >
+                                float(std::numeric_limits<int64_t>::max())) {
+                            Rd_sd = std::numeric_limits<int64_t>::max();
                             FFLAGS |= FloatInvalid;
-                        } else if (Fs1 < numeric_limits<int64_t>::min()) {
-                            Rd_sd = numeric_limits<int64_t>::min();
+                        } else if (Fs1 <
+                                float(std::numeric_limits<int64_t>::min())) {
+                            Rd_sd = std::numeric_limits<int64_t>::min();
                             FFLAGS |= FloatInvalid;
                         } else {
                             Rd_sd = Fs1;
@@ -1533,13 +1575,14 @@ decode QUADRANT default Unknown::unknown() {
                     }}, FloatCvtOp);
                     0x3: fcvt_lu_d({{
                         if (std::isnan(Fs1)) {
-                            Rd = numeric_limits<uint64_t>::max();
+                            Rd = std::numeric_limits<uint64_t>::max();
                             FFLAGS |= FloatInvalid;
                         } else if (Fs1 < 0) {
                             Rd = 0;
                             FFLAGS |= FloatInvalid;
-                        } else if (Fs1 > numeric_limits<uint64_t>::max()) {
-                            Rd = numeric_limits<uint64_t>::max();
+                        } else if (Fs1 >
+                                float(std::numeric_limits<uint64_t>::max())) {
+                            Rd = std::numeric_limits<uint64_t>::max();
                             FFLAGS |= FloatInvalid;
                         } else {
                             Rd = Fs1;
@@ -1588,9 +1631,9 @@ decode QUADRANT default Unknown::unknown() {
                     0x1: fclass_s({{
                         uint32_t temp;
                         float fs1 = reinterpret_cast<float&>(temp = Fs1_bits);
-                        switch (fpclassify(fs1)) {
+                        switch (std::fpclassify(fs1)) {
                           case FP_INFINITE:
-                            if (signbit(fs1)) {
+                            if (std::signbit(fs1)) {
                                 Rd = 1 << 0;
                             } else {
                                 Rd = 1 << 7;
@@ -1604,21 +1647,21 @@ decode QUADRANT default Unknown::unknown() {
                             }
                             break;
                           case FP_ZERO:
-                            if (signbit(fs1)) {
+                            if (std::signbit(fs1)) {
                                 Rd = 1 << 3;
                             } else {
                                 Rd = 1 << 4;
                             }
                             break;
                           case FP_SUBNORMAL:
-                            if (signbit(fs1)) {
+                            if (std::signbit(fs1)) {
                                 Rd = 1 << 2;
                             } else {
                                 Rd = 1 << 5;
                             }
                             break;
                           case FP_NORMAL:
-                            if (signbit(fs1)) {
+                            if (std::signbit(fs1)) {
                                 Rd = 1 << 1;
                             } else {
                                 Rd = 1 << 6;
@@ -1635,9 +1678,9 @@ decode QUADRANT default Unknown::unknown() {
                         Rd = Fs1_bits;
                     }}, FloatCvtOp);
                     0x1: fclass_d({{
-                        switch (fpclassify(Fs1)) {
+                        switch (std::fpclassify(Fs1)) {
                           case FP_INFINITE:
-                            if (signbit(Fs1)) {
+                            if (std::signbit(Fs1)) {
                                 Rd = 1 << 0;
                             } else {
                                 Rd = 1 << 7;
@@ -1651,21 +1694,21 @@ decode QUADRANT default Unknown::unknown() {
                             }
                             break;
                           case FP_ZERO:
-                            if (signbit(Fs1)) {
+                            if (std::signbit(Fs1)) {
                                 Rd = 1 << 3;
                             } else {
                                 Rd = 1 << 4;
                             }
                             break;
                           case FP_SUBNORMAL:
-                            if (signbit(Fs1)) {
+                            if (std::signbit(Fs1)) {
                                 Rd = 1 << 2;
                             } else {
                                 Rd = 1 << 5;
                             }
                             break;
                           case FP_NORMAL:
-                            if (signbit(Fs1)) {
+                            if (std::signbit(Fs1)) {
                                 Rd = 1 << 1;
                             } else {
                                 Rd = 1 << 6;
@@ -1747,40 +1790,71 @@ decode QUADRANT default Unknown::unknown() {
 
         0x1c: decode FUNCT3 {
             format SystemOp {
-                0x0: decode FUNCT12 {
-                    0x0: ecall({{
-                        fault = make_shared<SyscallFault>(
+                0x0: decode FUNCT7 {
+                    0x0: decode RS2 {
+                        0x0: ecall({{
+                            fault = std::make_shared<SyscallFault>(
                                 (PrivilegeMode)xc->readMiscReg(MISCREG_PRV));
-                    }}, IsSerializeAfter, IsNonSpeculative, IsSyscall,
-                        No_OpClass);
-                    0x1: ebreak({{
-                        fault = make_shared<BreakpointFault>(xc->pcState());
-                    }}, IsSerializeAfter, IsNonSpeculative, No_OpClass);
-                    0x2: uret({{
-                        STATUS status = xc->readMiscReg(MISCREG_STATUS);
-                        status.uie = status.upie;
-                        status.upie = 1;
-                        xc->setMiscReg(MISCREG_STATUS, status);
-                        NPC = xc->readMiscReg(MISCREG_UEPC);
-                    }}, IsReturn);
-                    0x102: sret({{
-                        if (xc->readMiscReg(MISCREG_PRV) == PRV_U) {
-                            fault = make_shared<IllegalInstFault>(
-                                        "sret in user mode", machInst);
-                            NPC = NPC;
-                        } else {
+                        }}, IsSerializeAfter, IsNonSpeculative, IsSyscall,
+                            No_OpClass);
+                        0x1: ebreak({{
+                            fault = std::make_shared<BreakpointFault>(
+                                xc->pcState());
+                        }}, IsSerializeAfter, IsNonSpeculative, No_OpClass);
+                        0x2: uret({{
                             STATUS status = xc->readMiscReg(MISCREG_STATUS);
-                            xc->setMiscReg(MISCREG_PRV, status.spp);
-                            status.sie = status.spie;
-                            status.spie = 1;
-                            status.spp = PRV_U;
+                            status.uie = status.upie;
+                            status.upie = 1;
                             xc->setMiscReg(MISCREG_STATUS, status);
-                            NPC = xc->readMiscReg(MISCREG_SEPC);
+                            NPC = xc->readMiscReg(MISCREG_UEPC);
+                        }}, IsSerializeAfter, IsNonSpeculative, IsReturn);
+                    }
+                    0x8: decode RS2 {
+                        0x2: sret({{
+                            STATUS status = xc->readMiscReg(MISCREG_STATUS);
+                            auto pm = (PrivilegeMode)xc->readMiscReg(
+                                MISCREG_PRV);
+                            if (pm == PRV_U ||
+                                (pm == PRV_S && status.tsr == 1)) {
+                                fault = std::make_shared<IllegalInstFault>(
+                                            "sret in user mode or TSR enabled",
+                                            machInst);
+                                NPC = NPC;
+                            } else {
+                                xc->setMiscReg(MISCREG_PRV, status.spp);
+                                status.sie = status.spie;
+                                status.spie = 1;
+                                status.spp = PRV_U;
+                                xc->setMiscReg(MISCREG_STATUS, status);
+                                NPC = xc->readMiscReg(MISCREG_SEPC);
+                            }
+                        }}, IsSerializeAfter, IsNonSpeculative, IsReturn);
+                        0x5: wfi({{
+                            STATUS status = xc->readMiscReg(MISCREG_STATUS);
+                            auto pm = (PrivilegeMode)xc->readMiscReg(
+                                MISCREG_PRV);
+                            if (pm == PRV_U ||
+                                (pm == PRV_S && status.tw == 1)) {
+                                fault = std::make_shared<IllegalInstFault>(
+                                            "wfi in user mode or TW enabled",
+                                            machInst);
+                            }
+                            // don't do anything for now
+                        }}, No_OpClass);
+                    }
+                    0x9: sfence_vma({{
+                        STATUS status = xc->readMiscReg(MISCREG_STATUS);
+                        auto pm = (PrivilegeMode)xc->readMiscReg(MISCREG_PRV);
+                        if (pm == PRV_U || (pm == PRV_S && status.tvm == 1)) {
+                            fault = std::make_shared<IllegalInstFault>(
+                                        "sfence in user mode or TVM enabled",
+                                        machInst);
                         }
-                    }}, IsReturn);
-                    0x302: mret({{
+                        xc->tcBase()->getMMUPtr()->demapPage(Rs1, Rs2);
+                    }}, IsNonSpeculative, IsSerializeAfter, No_OpClass);
+                    0x18: mret({{
                         if (xc->readMiscReg(MISCREG_PRV) != PRV_M) {
-                            fault = make_shared<IllegalInstFault>(
+                            fault = std::make_shared<IllegalInstFault>(
                                         "mret at lower privilege", machInst);
                             NPC = NPC;
                         } else {
@@ -1792,35 +1866,37 @@ decode QUADRANT default Unknown::unknown() {
                             xc->setMiscReg(MISCREG_STATUS, status);
                             NPC = xc->readMiscReg(MISCREG_MEPC);
                         }
-                    }}, IsReturn);
+                    }}, IsSerializeAfter, IsNonSpeculative, IsReturn);
                 }
             }
             format CSROp {
                 0x1: csrrw({{
                     Rd = data;
                     data = Rs1;
-                }}, IsNonSpeculative, No_OpClass);
+                }}, IsSerializeAfter, IsNonSpeculative, No_OpClass);
                 0x2: csrrs({{
                     Rd = data;
                     data |= Rs1;
-                }}, IsNonSpeculative, No_OpClass);
+                }}, IsSerializeAfter, IsNonSpeculative, No_OpClass);
                 0x3: csrrc({{
                     Rd = data;
                     data &= ~Rs1;
-                }}, IsNonSpeculative, No_OpClass);
+                }}, IsSerializeAfter, IsNonSpeculative, No_OpClass);
                 0x5: csrrwi({{
                     Rd = data;
                     data = uimm;
-                }}, IsNonSpeculative, No_OpClass);
+                }}, IsSerializeAfter, IsNonSpeculative, No_OpClass);
                 0x6: csrrsi({{
                     Rd = data;
                     data |= uimm;
-                }}, IsNonSpeculative, No_OpClass);
+                }}, IsSerializeAfter, IsNonSpeculative, No_OpClass);
                 0x7: csrrci({{
                     Rd = data;
                     data &= ~uimm;
-                }}, IsNonSpeculative, No_OpClass);
+                }}, IsSerializeAfter, IsNonSpeculative, No_OpClass);
             }
         }
+
+        0x1e: M5Op::M5Op();
     }
 }