anchor.diff:              `FSQRT_S:   tagged Valid (tagged Fpu FpuInst{func: FSqrt,    precision: Single});
   `endif
   
  +            `FLE_S:     tagged Valid (tagged Fpu FpuInst{func: FLe,      precision: Single});
  +            `FLT_S:     tagged Valid (tagged Fpu FpuInst{func: FLt,      precision: Single});
  +            `FEQ_S:     tagged Valid (tagged Fpu FpuInst{func: FEq,      precision: Single});
  +
  +            `FCVT_W_S:  tagged Valid (tagged Fpu FpuInst{func: FCvt_WF,  precision: Single});
  +            `FCVT_WU_S: tagged Valid (tagged Fpu FpuInst{func: FCvt_WUF, precision: Single});
  +
  +            `FMV_X_S:   tagged Valid (tagged Fpu FpuInst{func: FMv_XF,   precision: Single});
  +
  +            `FCLASS_S:  tagged Valid (tagged Fpu FpuInst{func: FClass,   precision: Single});
  +
  +            `FCVT_S_W:  tagged Valid (tagged Fpu FpuInst{func: FCvt_FW,  precision: Single});
  +            `FCVT_S_WU: tagged Valid (tagged Fpu FpuInst{func: FCvt_FWU, precision: Single});
  +            `FMV_S_X:   tagged Valid (tagged Fpu FpuInst{func: FMv_FX,   precision: Single});
  +
  +            // Floating-Point Memory instructions
  +            `FLW:       tagged Valid (tagged Mem RVMemInst{op: tagged Mem Ld, size: W, isUnsigned: True});
  +            `FSW:       tagged Valid (tagged Mem RVMemInst{op: tagged Mem St, size: W, isUnsigned: True});
  +
  +            // FMA instructions
  +            `FMADD_S:   tagged Valid (tagged Fpu FpuInst{func: FMAdd,  precision: Single});
  +            `FMSUB_S:   tagged Valid (tagged Fpu FpuInst{func: FMSub,  precision: Single});
  +            `FNMSUB_S:  tagged Valid (tagged Fpu FpuInst{func: FNMSub, precision: Single});
  +            `FNMADD_S:  tagged Valid (tagged Fpu FpuInst{func: FNMAdd, precision: Single});
  +
  +            default:    tagged Invalid;
  +        endcase);
  +endfunction
  +
  +function Maybe#(ExecFunc) toExecFuncRV64F(Instruction inst);
  +    return (case (inst) matches
  +            `FCVT_L_S:  tagged Valid (tagged Fpu FpuInst{func: FCvt_LF,  precision: Single});
  +            `FCVT_LU_S: tagged Valid (tagged Fpu FpuInst{func: FCvt_LUF, precision: Single});
  +            `FCVT_S_L:  tagged Valid (tagged Fpu FpuInst{func: FCvt_FL,  precision: Single});
  +            `FCVT_S_LU: tagged Valid (tagged Fpu FpuInst{func: FCvt_FLU, precision: Single});
  +
  +            default:    tagged Invalid;
  +        endcase);
  +endfunction
  +
  +function Maybe#(ExecFunc) toExecFuncRV32D(Instruction inst);
  +    return (case (inst) matches
               `FADD_D:    tagged Valid (tagged Fpu FpuInst{func: FAdd,     precision: Double});
               `FSUB_D:    tagged Valid (tagged Fpu FpuInst{func: FSub,     precision: Double});
               `FMUL_D:    tagged Valid (tagged Fpu FpuInst{func: FMul,     precision: Double});
  
positive.code:         endcase);
  endfunction
  
  // This returns a valid result if the instruction is legal, otherwise it
  // returns a tagged invalid.
  function Maybe#(RVDecodedInst) decodeInst(Instruction inst);
      Maybe#(ExecFunc) execFunc = toExecFuncI(inst);
      if (!isValid(execFunc)) begin
          execFunc = toExecFuncSupervisor(inst);
      end
  
  `ifdef m
      if (`m && !isValid(execFunc)) begin
          execFunc = toExecFuncM(inst);
      end
  `endif
  
  `ifdef a
      if (`a && !isValid(execFunc)) begin
          execFunc = toExecFuncA(inst);
      end
  `endif
  
  `ifdef f
      // TODO: simplify decoder if f is enabled but not d
      if (`f && !isValid(execFunc)) begin
          execFunc = toExecFuncFD(inst);
      end
  `endif
  
      if (execFunc matches tagged Valid .validExecFunc) begin
          InstType instType = toInstType(inst);
  
negative.code:         endcase);
  endfunction
  
  function Maybe#(ExecFunc) toExecFuncRV32F(Instruction inst);
      return (case (inst) matches
              `FADD_S:    tagged Valid (tagged Fpu FpuInst{func: FAdd,     precision: Single});
              `FSUB_S:    tagged Valid (tagged Fpu FpuInst{func: FSub,     precision: Single});
  