Functions

if ((!implemented?(ExtensionName::S)) && (!implemented?(ExtensionName::U)) && (!implemented?(ExtensionName::H))) {
  return PrivilegeMode::M;
} else {
  return current_mode;
}

return current_mode;

if (MXLEN == 32) {
  return 32;
} else {
  if (mode() == PrivilegeMode::M) {
    if (CSR[misa].MXL == $bits(XRegWidth::XLEN32)) {
      return 32;
    } else if (CSR[misa].MXL == $bits(XRegWidth::XLEN64)) {
      return 64;
    } else {
      unreachable();
    }
  } else if (implemented?(ExtensionName::S) && mode() == PrivilegeMode::S) {
    if (CSR[mstatus].SXL == $bits(XRegWidth::XLEN32)) {
      return 32;
    } else if (CSR[mstatus].SXL == $bits(XRegWidth::XLEN64)) {
      return 64;
    } else {
      unreachable();
    }
  } else if (implemented?(ExtensionName::U) && mode() == PrivilegeMode::U) {
    if (CSR[mstatus].UXL == $bits(XRegWidth::XLEN32)) {
      return 32;
    } else if (CSR[mstatus].UXL == $bits(XRegWidth::XLEN64)) {
      return 64;
    } else {
      unreachable();
    }
  } else if (implemented?(ExtensionName::H) && mode() == PrivilegeMode::VS) {
    if (CSR[hstatus].VSXL == $bits(XRegWidth::XLEN32)) {
      return 32;
    } else if (CSR[hstatus].VSXL == $bits(XRegWidth::XLEN64)) {
      return 64;
    } else {
      unreachable();
    }
  } else if (implemented?(ExtensionName::H) && mode() == PrivilegeMode::VU) {
    if (CSR[vsstatus].UXL == $bits(XRegWidth::XLEN32)) {
      return 32;
    } else if (CSR[vsstatus].UXL == $bits(XRegWidth::XLEN64)) {
      return 64;
    } else {
      unreachable();
    }
  } else {
    unreachable();
  }
}

if (mode() == PrivilegeMode::M) {
  return 64;
} else if (mode() == PrivilegeMode::S) {
  if (CSR[mstatus].SXL == $bits(XRegWidth::XLEN32)) {
    return 32;
  } else if (CSR[mstatus].SXL == $bits(XRegWidth::XLEN64)) {
    return 64;
  } else {
    unreachable();
  }
} else if (mode() == PrivilegeMode::U) {
  if (CSR[mstatus].UXL == $bits(XRegWidth::XLEN32)) {
    return 32;
  } else if (CSR[mstatus].UXL == $bits(XRegWidth::XLEN64)) {
    return 64;
  } else {
    unreachable();
  }
} else if (mode() == PrivilegeMode::VS) {
  if (CSR[hstatus].VSXL == $bits(XRegWidth::XLEN32)) {
    return 32;
  } else if (CSR[hstatus].VSXL == $bits(XRegWidth::XLEN64)) {
    return 64;
  } else {
    unreachable();
  }
} else if (mode() == PrivilegeMode::VU) {
  if (CSR[vsstatus].UXL == $bits(XRegWidth::XLEN32)) {
    return 32;
  } else if (CSR[vsstatus].UXL == $bits(XRegWidth::XLEN64)) {
    return 64;
  } else {
    unreachable();
  }
} else {
  unreachable();
}

return {2'b01, creg_idx};

return {2'b01, creg_idx};

if (first_extended_bit == MXLEN) {
  return value;
} else {
  Bits<1> sign = value[first_extended_bit - 1];
  for (U32 i = MXLEN - 1; i >= first_extended_bit; i--) {
    value[i] = sign;
  }
  return value;
}

if (first_extended_bit == 7'64) {
  return value;
} else {
  Bits<1> sign = value[first_extended_bit - 1];
  for (U32 i = 7'63; i >= first_extended_bit; i--) {
    value[i] = sign;
  }
  return value;
}

if (implemented?(ExtensionName::C) && (CSR[misa].C == 0x1)) {
  return 16;
} else {
  return 32;
}

return 16;

if (mode() == PrivilegeMode::M) {
  return PrivilegeMode::M;
} else if (implemented?(ExtensionName::S) && mode() == PrivilegeMode::HS) || (mode() == PrivilegeMode::U) {
  if (($bits(CSR[CSR[medeleg]]) & (MXLEN'1 << $bits(exception_code))) != 0) {
    return PrivilegeMode::HS;
  } else {
    return PrivilegeMode::M;
  }
} else if (implemented?(ExtensionName::H) && mode() == PrivilegeMode::VS) || (mode() == PrivilegeMode::VU) {
  if (($bits(CSR[CSR[medeleg]]) & (MXLEN'1 << $bits(exception_code))) != 0) {
    if (($bits(CSR[CSR[hedeleg]]) & (MXLEN'1 << $bits(exception_code))) != 0) {
      return PrivilegeMode::VS;
    } else {
      return PrivilegeMode::HS;
    }
  } else {
    return PrivilegeMode::M;
  }
} else {
  unreachable();
}

if (mode() == PrivilegeMode::M) {
  return PrivilegeMode::M;
} else if (mode() == PrivilegeMode::S) || (mode() == PrivilegeMode::U) {
  if (($bits(CSR[CSR[medeleg]]) & (MXLEN'1 << $bits(exception_code))) != 0) {
    return PrivilegeMode::S;
  } else {
    return PrivilegeMode::M;
  }
} else if (mode() == PrivilegeMode::VS) || (mode() == PrivilegeMode::VU) {
  if (($bits(CSR[CSR[medeleg]]) & (MXLEN'1 << $bits(exception_code))) != 0) {
    if (($bits(CSR[CSR[hedeleg]]) & (MXLEN'1 << $bits(exception_code))) != 0) {
      return PrivilegeMode::VS;
    } else {
      return PrivilegeMode::S;
    }
  } else {
    return PrivilegeMode::M;
  }
} else {
  unreachable();
}

return !(REPORT_VA_IN_MTVAL_ON_BREAKPOINT || REPORT_VA_IN_MTVAL_ON_LOAD_MISALIGNED || REPORT_VA_IN_MTVAL_ON_STORE_AMO_MISALIGNED || REPORT_VA_IN_MTVAL_ON_INSTRUCTION_MISALIGNED || REPORT_VA_IN_MTVAL_ON_LOAD_ACCESS_FAULT || REPORT_VA_IN_MTVAL_ON_STORE_AMO_ACCESS_FAULT || REPORT_VA_IN_MTVAL_ON_INSTRUCTION_ACCESS_FAULT || REPORT_VA_IN_MTVAL_ON_LOAD_PAGE_FAULT || REPORT_VA_IN_MTVAL_ON_STORE_AMO_PAGE_FAULT || REPORT_VA_IN_MTVAL_ON_INSTRUCTION_PAGE_FAULT || REPORT_ENCODING_IN_MTVAL_ON_ILLEGAL_INSTRUCTION || REPORT_CAUSE_IN_MTVAL_ON_SHADOW_STACK_SOFTWARE_CHECK || REPORT_CAUSE_IN_MTVAL_ON_LANDING_PAD_SOFTWARE_CHECK);

return false;

if (exception_code == ExceptionCode::Breakpoint) {
  return REPORT_VA_IN_MTVAL_ON_BREAKPOINT ? tval : 0;
} else if (exception_code == ExceptionCode::LoadAddressMisaligned) {
  return REPORT_VA_IN_MTVAL_ON_LOAD_MISALIGNED ? tval : 0;
} else if (exception_code == ExceptionCode::StoreAmoAddressMisaligned) {
  return REPORT_VA_IN_MTVAL_ON_STORE_AMO_MISALIGNED ? tval : 0;
} else if (exception_code == ExceptionCode::InstructionAddressMisaligned) {
  return REPORT_VA_IN_MTVAL_ON_INSTRUCTION_MISALIGNED ? tval : 0;
} else if (exception_code == ExceptionCode::LoadAccessFault) {
  return REPORT_VA_IN_MTVAL_ON_LOAD_ACCESS_FAULT ? tval : 0;
} else if (exception_code == ExceptionCode::StoreAmoAccessFault) {
  return REPORT_VA_IN_MTVAL_ON_STORE_AMO_ACCESS_FAULT ? tval : 0;
} else if (exception_code == ExceptionCode::InstructionAccessFault) {
  return REPORT_VA_IN_MTVAL_ON_INSTRUCTION_ACCESS_FAULT ? tval : 0;
} else if (exception_code == ExceptionCode::LoadPageFault) {
  return REPORT_VA_IN_MTVAL_ON_LOAD_PAGE_FAULT ? tval : 0;
} else if (exception_code == ExceptionCode::StoreAmoPageFault) {
  return REPORT_VA_IN_MTVAL_ON_STORE_AMO_PAGE_FAULT ? tval : 0;
} else if (exception_code == ExceptionCode::InstructionPageFault) {
  return REPORT_VA_IN_MTVAL_ON_INSTRUCTION_PAGE_FAULT ? tval : 0;
} else if (exception_code == ExceptionCode::IllegalInstruction) {
  return REPORT_ENCODING_IN_MTVAL_ON_ILLEGAL_INSTRUCTION ? tval : 0;
} else if (exception_code == ExceptionCode::SoftwareCheck) {
  return tval;
} else {
  return 0;
}

if (exception_code == ExceptionCode::Breakpoint) {
  return tval;
} else if (exception_code == ExceptionCode::LoadAddressMisaligned) {
  return tval;
} else if (exception_code == ExceptionCode::StoreAmoAddressMisaligned) {
  return tval;
} else if (exception_code == ExceptionCode::InstructionAddressMisaligned) {
  return tval;
} else if (exception_code == ExceptionCode::LoadAccessFault) {
  return tval;
} else if (exception_code == ExceptionCode::StoreAmoAccessFault) {
  return tval;
} else if (exception_code == ExceptionCode::InstructionAccessFault) {
  return tval;
} else if (exception_code == ExceptionCode::LoadPageFault) {
  return tval;
} else if (exception_code == ExceptionCode::StoreAmoPageFault) {
  return tval;
} else if (exception_code == ExceptionCode::InstructionPageFault) {
  return tval;
} else if (exception_code == ExceptionCode::IllegalInstruction) {
  return tval;
} else if (exception_code == ExceptionCode::SoftwareCheck) {
  return tval;
} else {
  return 0;
}

if (implemented?(ExtensionName::S)) {
  return !(REPORT_VA_IN_STVAL_ON_BREAKPOINT || REPORT_VA_IN_STVAL_ON_LOAD_MISALIGNED || REPORT_VA_IN_STVAL_ON_STORE_AMO_MISALIGNED || REPORT_VA_IN_STVAL_ON_INSTRUCTION_MISALIGNED || REPORT_VA_IN_STVAL_ON_LOAD_ACCESS_FAULT || REPORT_VA_IN_STVAL_ON_STORE_AMO_ACCESS_FAULT || REPORT_VA_IN_STVAL_ON_INSTRUCTION_ACCESS_FAULT || REPORT_VA_IN_STVAL_ON_LOAD_PAGE_FAULT || REPORT_VA_IN_STVAL_ON_STORE_AMO_PAGE_FAULT || REPORT_VA_IN_STVAL_ON_INSTRUCTION_PAGE_FAULT || REPORT_ENCODING_IN_STVAL_ON_ILLEGAL_INSTRUCTION || REPORT_CAUSE_IN_STVAL_ON_SHADOW_STACK_SOFTWARE_CHECK || REPORT_CAUSE_IN_STVAL_ON_LANDING_PAD_SOFTWARE_CHECK);
} else {
  return true;
}

return false;

if (exception_code == ExceptionCode::Breakpoint) {
  return REPORT_VA_IN_STVAL_ON_BREAKPOINT ? tval : 0;
} else if (exception_code == ExceptionCode::LoadAddressMisaligned) {
  return REPORT_VA_IN_STVAL_ON_LOAD_MISALIGNED ? tval : 0;
} else if (exception_code == ExceptionCode::StoreAmoAddressMisaligned) {
  return REPORT_VA_IN_STVAL_ON_STORE_AMO_MISALIGNED ? tval : 0;
} else if (exception_code == ExceptionCode::InstructionAddressMisaligned) {
  return REPORT_VA_IN_STVAL_ON_INSTRUCTION_MISALIGNED ? tval : 0;
} else if (exception_code == ExceptionCode::LoadAccessFault) {
  return REPORT_VA_IN_STVAL_ON_LOAD_ACCESS_FAULT ? tval : 0;
} else if (exception_code == ExceptionCode::StoreAmoAccessFault) {
  return REPORT_VA_IN_STVAL_ON_STORE_AMO_ACCESS_FAULT ? tval : 0;
} else if (exception_code == ExceptionCode::InstructionAccessFault) {
  return REPORT_VA_IN_STVAL_ON_INSTRUCTION_ACCESS_FAULT ? tval : 0;
} else if (exception_code == ExceptionCode::LoadPageFault) {
  return REPORT_VA_IN_STVAL_ON_LOAD_PAGE_FAULT ? tval : 0;
} else if (exception_code == ExceptionCode::StoreAmoPageFault) {
  return REPORT_VA_IN_STVAL_ON_STORE_AMO_PAGE_FAULT ? tval : 0;
} else if (exception_code == ExceptionCode::InstructionPageFault) {
  return REPORT_VA_IN_STVAL_ON_INSTRUCTION_PAGE_FAULT ? tval : 0;
} else if (exception_code == ExceptionCode::IllegalInstruction) {
  return REPORT_ENCODING_IN_STVAL_ON_ILLEGAL_INSTRUCTION ? tval : 0;
} else if (exception_code == ExceptionCode::SoftwareCheck) {
  return tval;
} else {
  return 0;
}

if (exception_code == ExceptionCode::Breakpoint) {
  return tval;
} else if (exception_code == ExceptionCode::LoadAddressMisaligned) {
  return tval;
} else if (exception_code == ExceptionCode::StoreAmoAddressMisaligned) {
  return tval;
} else if (exception_code == ExceptionCode::InstructionAddressMisaligned) {
  return tval;
} else if (exception_code == ExceptionCode::LoadAccessFault) {
  return tval;
} else if (exception_code == ExceptionCode::StoreAmoAccessFault) {
  return tval;
} else if (exception_code == ExceptionCode::InstructionAccessFault) {
  return tval;
} else if (exception_code == ExceptionCode::LoadPageFault) {
  return tval;
} else if (exception_code == ExceptionCode::StoreAmoPageFault) {
  return tval;
} else if (exception_code == ExceptionCode::InstructionPageFault) {
  return tval;
} else if (exception_code == ExceptionCode::IllegalInstruction) {
  return tval;
} else if (exception_code == ExceptionCode::SoftwareCheck) {
  return tval;
} else {
  return 0;
}

if (implemented?(ExtensionName::H)) {
  return !(REPORT_VA_IN_VSTVAL_ON_BREAKPOINT || REPORT_VA_IN_VSTVAL_ON_LOAD_MISALIGNED || REPORT_VA_IN_VSTVAL_ON_STORE_AMO_MISALIGNED || REPORT_VA_IN_VSTVAL_ON_INSTRUCTION_MISALIGNED || REPORT_VA_IN_VSTVAL_ON_LOAD_ACCESS_FAULT || REPORT_VA_IN_VSTVAL_ON_STORE_AMO_ACCESS_FAULT || REPORT_VA_IN_VSTVAL_ON_INSTRUCTION_ACCESS_FAULT || REPORT_VA_IN_VSTVAL_ON_LOAD_PAGE_FAULT || REPORT_VA_IN_VSTVAL_ON_STORE_AMO_PAGE_FAULT || REPORT_VA_IN_VSTVAL_ON_INSTRUCTION_PAGE_FAULT || REPORT_ENCODING_IN_VSTVAL_ON_ILLEGAL_INSTRUCTION || REPORT_CAUSE_IN_VSTVAL_ON_SHADOW_STACK_SOFTWARE_CHECK || REPORT_CAUSE_IN_VSTVAL_ON_LANDING_PAD_SOFTWARE_CHECK);
} else {
  return true;
}

return false;

if (exception_code == ExceptionCode::Breakpoint) {
  return REPORT_VA_IN_VSTVAL_ON_BREAKPOINT ? tval : 0;
} else if (exception_code == ExceptionCode::LoadAddressMisaligned) {
  return REPORT_VA_IN_VSTVAL_ON_LOAD_MISALIGNED ? tval : 0;
} else if (exception_code == ExceptionCode::StoreAmoAddressMisaligned) {
  return REPORT_VA_IN_VSTVAL_ON_STORE_AMO_MISALIGNED ? tval : 0;
} else if (exception_code == ExceptionCode::InstructionAddressMisaligned) {
  return REPORT_VA_IN_VSTVAL_ON_INSTRUCTION_MISALIGNED ? tval : 0;
} else if (exception_code == ExceptionCode::LoadAccessFault) {
  return REPORT_VA_IN_VSTVAL_ON_LOAD_ACCESS_FAULT ? tval : 0;
} else if (exception_code == ExceptionCode::StoreAmoAccessFault) {
  return REPORT_VA_IN_VSTVAL_ON_STORE_AMO_ACCESS_FAULT ? tval : 0;
} else if (exception_code == ExceptionCode::InstructionAccessFault) {
  return REPORT_VA_IN_VSTVAL_ON_INSTRUCTION_ACCESS_FAULT ? tval : 0;
} else if (exception_code == ExceptionCode::LoadPageFault) {
  return REPORT_VA_IN_VSTVAL_ON_LOAD_PAGE_FAULT ? tval : 0;
} else if (exception_code == ExceptionCode::StoreAmoPageFault) {
  return REPORT_VA_IN_VSTVAL_ON_STORE_AMO_PAGE_FAULT ? tval : 0;
} else if (exception_code == ExceptionCode::InstructionPageFault) {
  return REPORT_VA_IN_VSTVAL_ON_INSTRUCTION_PAGE_FAULT ? tval : 0;
} else if (exception_code == ExceptionCode::IllegalInstruction) {
  return REPORT_ENCODING_IN_VSTVAL_ON_ILLEGAL_INSTRUCTION ? tval : 0;
} else if (exception_code == ExceptionCode::SoftwareCheck) {
  return tval;
} else {
  return 0;
}

if (exception_code == ExceptionCode::Breakpoint) {
  return tval;
} else if (exception_code == ExceptionCode::LoadAddressMisaligned) {
  return tval;
} else if (exception_code == ExceptionCode::StoreAmoAddressMisaligned) {
  return tval;
} else if (exception_code == ExceptionCode::InstructionAddressMisaligned) {
  return tval;
} else if (exception_code == ExceptionCode::LoadAccessFault) {
  return tval;
} else if (exception_code == ExceptionCode::StoreAmoAccessFault) {
  return tval;
} else if (exception_code == ExceptionCode::InstructionAccessFault) {
  return tval;
} else if (exception_code == ExceptionCode::LoadPageFault) {
  return tval;
} else if (exception_code == ExceptionCode::StoreAmoPageFault) {
  return tval;
} else if (exception_code == ExceptionCode::InstructionPageFault) {
  return tval;
} else if (exception_code == ExceptionCode::IllegalInstruction) {
  return tval;
} else if (exception_code == ExceptionCode::SoftwareCheck) {
  return tval;
} else {
  return 0;
}

Bits<MXLEN> pending_ints = CSR[CSR[mip]].sw_read() & $bits(CSR[CSR[mie]]);
if (pending_ints == 0) {
  pending_and_enabled_interrupts = 0;
  return ;
}
Boolean HAS_MIDELEG = implemented_version?(ExtensionName::S, "<= 1.9.1") || (implemented_version?(ExtensionName::S, "> 1.9.1") && implemented_version?(ExtensionName::Sm, "> 1.9.1"));
Bits<MXLEN> mmode_enabled_ints = mode() == PrivilegeMode::M) && (CSR[mstatus].MIE == 1'b0 ? 0 : ($bits(CSR[CSR[mie]]) & (HAS_MIDELEG ? ~$bits(CSR[CSR[mideleg]]) : ~MXLEN'0));
Bits<MXLEN> mmode_pending_and_enabled = pending_ints & mmode_enabled_ints;
if (mmode_pending_and_enabled != 0) {
  pending_and_enabled_interrupts = mmode_pending_and_enabled;
  return ;
}
if (CSR[misa].S == 1'b1) {
  Bits<MXLEN> smode_enabled_ints = mode() == PrivilegeMode::M) || (CSR[mstatus].SIE == 1'b0 ? 0 : $bits(CSR[CSR[mie]]) & ($bits(CSR[CSR[mideleg]]));
  Bits<MXLEN> smode_pending_and_enabled = pending_ints & smode_enabled_ints;
  if (smode_pending_and_enabled != 0) {
    pending_and_enabled_interrupts = smode_pending_and_enabled;
    return ;
  }
}
pending_and_enabled_interrupts = 0;

Bits<MXLEN> pending_ints = CSR[CSR[mip]].sw_read() & $bits(CSR[CSR[mie]]);
if (pending_ints == 0) {
  pending_and_enabled_interrupts = 0;
  return ;
}
Boolean HAS_MIDELEG = true;
Bits<MXLEN> mmode_enabled_ints = mode() == PrivilegeMode::M) && (CSR[mstatus].MIE == 1'b0 ? 0 : ($bits(CSR[CSR[mie]]) & (~$bits(CSR[CSR[mideleg]])));
Bits<MXLEN> mmode_pending_and_enabled = pending_ints & mmode_enabled_ints;
if (mmode_pending_and_enabled != 0) {
  pending_and_enabled_interrupts = mmode_pending_and_enabled;
  return ;
}
Bits<MXLEN> smode_enabled_ints = mode() == PrivilegeMode::M) || (CSR[mstatus].SIE == 1'b0 ? 0 : $bits(CSR[CSR[mie]]) & ($bits(CSR[CSR[mideleg]]));
Bits<MXLEN> smode_pending_and_enabled = pending_ints & smode_enabled_ints;
if (smode_pending_and_enabled != 0) {
  pending_and_enabled_interrupts = smode_pending_and_enabled;
  return ;
}
pending_and_enabled_interrupts = 0;

if (new_mode != current_mode) {
  notify_mode_change(new_mode, current_mode);
  current_mode = new_mode;
  refresh_pending_interrupts();
}

if (new_mode != current_mode) {
  notify_mode_change(new_mode, current_mode);
  current_mode = new_mode;
  refresh_pending_interrupts();
}

PrivilegeMode handling_mode = exception_handling_mode(exception_code);
if (handling_mode == PrivilegeMode::M) {
  CSR[mepc].PC = $pc;
  if (!mtval_readonly?()) {
    CSR[mtval].VALUE = mtval_for(exception_code, tval);
  }
  $pc = {CSR[mtvec].BASE, 2'b00};
  CSR[mcause].INT = 1'b0;
  CSR[mcause].CODE = $bits(exception_code);
  if (implemented?(ExtensionName::H) && CSR[misa].H == 1) {
    CSR[mtval2].VALUE = 0;
    CSR[mtinst].VALUE = 0;
    if (from_mode == PrivilegeMode::VU || from_mode == PrivilegeMode::VS) {
      if (MXLEN == 32) {
        CSR[mstatush].MPV = 1;
      } else {
        CSR[mstatus].MPV = 1;
      }
    } else {
      if (MXLEN == 32) {
        CSR[mstatush].MPV = 0;
      } else {
        CSR[mstatus].MPV = 0;
      }
    }
  }
  CSR[mstatus].MPP = $bits(from_mode);
} else if (CSR[misa].S == 1 && (handling_mode == PrivilegeMode::S)) {
  CSR[sepc].PC = $pc;
  if (!stval_readonly?()) {
    CSR[stval].VALUE = stval_for(exception_code, tval);
  }
  $pc = {CSR[stvec].BASE, 2'b00};
  CSR[scause].INT = 1'b0;
  CSR[scause].CODE = $bits(exception_code);
  CSR[mstatus].SPP = $bits(from_mode)[0];
  if (CSR[misa].H == 1) {
    CSR[htval].VALUE = 0;
    CSR[htinst].VALUE = 0;
    CSR[hstatus].SPV = $bits(from_mode)[2];
    if (from_mode == PrivilegeMode::VU || from_mode == PrivilegeMode::VS) {
      CSR[hstatus].SPV = 1;
      if (exception_code == ExceptionCode::Breakpoint) && (REPORT_VA_IN_STVAL_ON_BREAKPOINT || exception_code == ExceptionCode::LoadAddressMisaligned) && (REPORT_VA_IN_STVAL_ON_LOAD_MISALIGNED || exception_code == ExceptionCode::StoreAmoAddressMisaligned) && (REPORT_VA_IN_STVAL_ON_STORE_AMO_MISALIGNED || exception_code == ExceptionCode::InstructionAddressMisaligned) && (REPORT_VA_IN_STVAL_ON_INSTRUCTION_MISALIGNED || exception_code == ExceptionCode::LoadAccessFault) && (REPORT_VA_IN_STVAL_ON_LOAD_ACCESS_FAULT || exception_code == ExceptionCode::StoreAmoAccessFault) && (REPORT_VA_IN_STVAL_ON_STORE_AMO_ACCESS_FAULT || exception_code == ExceptionCode::InstructionAccessFault) && (REPORT_VA_IN_STVAL_ON_INSTRUCTION_ACCESS_FAULT || exception_code == ExceptionCode::LoadPageFault) && (REPORT_VA_IN_STVAL_ON_LOAD_PAGE_FAULT || exception_code == ExceptionCode::StoreAmoPageFault) && (REPORT_VA_IN_STVAL_ON_STORE_AMO_PAGE_FAULT || exception_code == ExceptionCode::InstructionPageFault) && (REPORT_VA_IN_STVAL_ON_INSTRUCTION_PAGE_FAULT) {
        CSR[hstatus].GVA = 1;
      } else {
        CSR[hstatus].GVA = 0;
      }
      CSR[hstatus].SPVP = $bits(from_mode)[0];
    } else {
      CSR[hstatus].SPV = 0;
      CSR[hstatus].GVA = 0;
    }
  }
} else if (CSR[misa].H == 1 && (handling_mode == PrivilegeMode::VS)) {
  CSR[vsepc].PC = $pc;
  if (!vstval_readonly?()) {
    CSR[vstval].VALUE = vstval_for(exception_code, tval);
  }
  $pc = {CSR[vstvec].BASE, 2'b00};
  CSR[vscause].INT = 1'b0;
  CSR[vscause].CODE = $bits(exception_code);
  CSR[vsstatus].SPP = $bits(from_mode)[0];
}
set_mode(handling_mode);
abort_current_instruction();

PrivilegeMode handling_mode = exception_handling_mode(exception_code);
if (handling_mode == PrivilegeMode::M) {
  CSR[mepc].PC = $pc;
  CSR[mtval].VALUE = mtval_for(exception_code, tval);
  $pc = {CSR[mtvec].BASE, 2'b00};
  CSR[mcause].INT = 1'b0;
  CSR[mcause].CODE = $bits(exception_code);
  CSR[mtval2].VALUE = 0;
  CSR[mtinst].VALUE = 0;
  if (from_mode == PrivilegeMode::VU || from_mode == PrivilegeMode::VS) {
    CSR[mstatus].MPV = 1;
  } else {
    CSR[mstatus].MPV = 0;
  }
  CSR[mstatus].MPP = $bits(from_mode);
} else if ((handling_mode == PrivilegeMode::S)) {
  CSR[sepc].PC = $pc;
  CSR[stval].VALUE = stval_for(exception_code, tval);
  $pc = {CSR[stvec].BASE, 2'b00};
  CSR[scause].INT = 1'b0;
  CSR[scause].CODE = $bits(exception_code);
  CSR[mstatus].SPP = $bits(from_mode)[0];
  CSR[htval].VALUE = 0;
  CSR[htinst].VALUE = 0;
  CSR[hstatus].SPV = $bits(from_mode)[2];
  if (from_mode == PrivilegeMode::VU || from_mode == PrivilegeMode::VS) {
    CSR[hstatus].SPV = 1;
    if ((exception_code == ExceptionCode::Breakpoint) || (exception_code == ExceptionCode::LoadAddressMisaligned) || (exception_code == ExceptionCode::StoreAmoAddressMisaligned) || (exception_code == ExceptionCode::InstructionAddressMisaligned) || (exception_code == ExceptionCode::LoadAccessFault) || (exception_code == ExceptionCode::StoreAmoAccessFault) || (exception_code == ExceptionCode::InstructionAccessFault) || (exception_code == ExceptionCode::LoadPageFault) || (exception_code == ExceptionCode::StoreAmoPageFault) || (exception_code == ExceptionCode::InstructionPageFault)) {
      CSR[hstatus].GVA = 1;
    } else {
      CSR[hstatus].GVA = 0;
    }
    CSR[hstatus].SPVP = $bits(from_mode)[0];
  } else {
    CSR[hstatus].SPV = 0;
    CSR[hstatus].GVA = 0;
  }
} else if ((handling_mode == PrivilegeMode::VS)) {
  CSR[vsepc].PC = $pc;
  CSR[vstval].VALUE = vstval_for(exception_code, tval);
  $pc = {CSR[vstvec].BASE, 2'b00};
  CSR[vscause].INT = 1'b0;
  CSR[vscause].CODE = $bits(exception_code);
  CSR[vsstatus].SPP = $bits(from_mode)[0];
}
set_mode(handling_mode);
abort_current_instruction();

if (!PRECISE_SYNCHRONOUS_EXCEPTIONS) {
  unpredictable("Imprecise synchronous exception");
} else {
  raise_precise(exception_code, from_mode, tval);
}

raise_precise(exception_code, from_mode, tval);

if ((ialign() == 16) && target_addr & 0x1) != 0 {
  raise(ExceptionCode::InstructionAddressMisaligned, mode(), target_addr);
} else if ((ialign() == 32) && (target_addr & 0x3) != 0) {
  raise(ExceptionCode::InstructionAddressMisaligned, mode(), target_addr);
}
$pc = target_addr;

if (target_addr & 0x1) != 0 {
  raise(ExceptionCode::InstructionAddressMisaligned, mode(), target_addr);
}
$pc = target_addr;

return true if (N == 8);
XReg Mask = (N / 8) - 1;
return (value & ~Mask) == value;

return true if (N == 8);
XReg Mask = (N / 8) - 1;
return (value & ~Mask) == value;

if (implemented?(ExtensionName::H)) {
  return (MXLEN == 32) ? CSR[mstatush].MPV : CSR[mstatus].MPV;
} else {
  assert(false, "TODO");
  unreachable();
}

return CSR[mstatus].MPV;

if (mode() == PrivilegeMode::M) {
  if (CSR[misa].U == 1 && CSR[mstatus].MPRV == 1) {
    if (CSR[mstatus].MPP == 0b00) {
      if (implemented?(ExtensionName::H) && CSR[misa].H == 1 && mpv() == 0b1) {
        return PrivilegeMode::VU;
      } else {
        return PrivilegeMode::U;
      }
    } else if (CSR[misa].S == 1 && CSR[mstatus].MPP == 0b01) {
      if (implemented?(ExtensionName::H) && CSR[misa].H == 1 && mpv() == 0b1) {
        return PrivilegeMode::VS;
      } else {
        return PrivilegeMode::S;
      }
    }
  }
}
return mode();

if (mode() == PrivilegeMode::M) {
  if (CSR[mstatus].MPRV == 1) {
    if (CSR[mstatus].MPP == 0b00) {
      if (mpv() == 0b1) {
        return PrivilegeMode::VU;
      } else {
        return PrivilegeMode::U;
      }
    } else if (CSR[mstatus].MPP == 0b01) {
      if (mpv() == 0b1) {
        return PrivilegeMode::VS;
      } else {
        return PrivilegeMode::S;
      }
    }
  }
}
return mode();

PrivilegeMode effective_mode = effective_ldst_mode();
if (effective_mode == PrivilegeMode::M) {
  return SatpMode::Bare;
}
if (CSR[misa].H == 1'b1) {
  if (effective_mode == PrivilegeMode::VS || effective_mode == PrivilegeMode::VU) {
    Bits<4> mode_val = CSR[vsatp].MODE;
    if (mode_val == $bits(SatpMode::Bare)) {
      return SatpMode::Bare;
    } else if (mode_val == $bits(SatpMode::Sv32)) {
      if (MXLEN == 64) {
        if ((effective_mode == PrivilegeMode::VS) && (CSR[hstatus].VSXL != $bits(XRegWidth::XLEN32))) {
          return SatpMode::Reserved;
        }
        if ((effective_mode == PrivilegeMode::VU) && (CSR[vsstatus].UXL != $bits(XRegWidth::XLEN32))) {
          return SatpMode::Reserved;
        }
      }
      if (!SV32_VSMODE_TRANSLATION) {
        return SatpMode::Reserved;
      }
      return SatpMode::Sv32;
    } else if ((MXLEN == 64) && (mode_val == $bits(SatpMode::Sv39))) {
      if (effective_mode == PrivilegeMode::VS && CSR[hstatus].VSXL != $bits(XRegWidth::XLEN64)) {
        return SatpMode::Reserved;
      }
      if (effective_mode == PrivilegeMode::VU && CSR[vsstatus].UXL != $bits(XRegWidth::XLEN64)) {
        return SatpMode::Reserved;
      }
      if (!SV39_VSMODE_TRANSLATION) {
        return SatpMode::Reserved;
      }
      return SatpMode::Sv39;
    } else if ((MXLEN == 64) && (mode_val == $bits(SatpMode::Sv48))) {
      if (effective_mode == PrivilegeMode::VS && CSR[hstatus].VSXL != $bits(XRegWidth::XLEN64)) {
        return SatpMode::Reserved;
      }
      if (effective_mode == PrivilegeMode::VU && CSR[vsstatus].UXL != $bits(XRegWidth::XLEN64)) {
        return SatpMode::Reserved;
      }
      if (!SV48_VSMODE_TRANSLATION) {
        return SatpMode::Reserved;
      }
      return SatpMode::Sv48;
    } else if ((MXLEN == 64) && (mode_val == $bits(SatpMode::Sv57))) {
      if (effective_mode == PrivilegeMode::VS && CSR[hstatus].VSXL != $bits(XRegWidth::XLEN64)) {
        return SatpMode::Reserved;
      }
      if (effective_mode == PrivilegeMode::VU && CSR[vsstatus].UXL != $bits(XRegWidth::XLEN64)) {
        return SatpMode::Reserved;
      }
      if (!SV57_VSMODE_TRANSLATION) {
        return SatpMode::Reserved;
      }
      return SatpMode::Sv57;
    } else {
      return SatpMode::Reserved;
    }
  } else {
    return SatpMode::Reserved;
  }
} else if (CSR[misa].S == 1'b1) {
  assert(effective_mode == PrivilegeMode::S || effective_mode == PrivilegeMode::U, "unexpected priv mode");
  Bits<4> mode_val = CSR[satp].MODE;
  if (mode_val == $bits(SatpMode::Bare)) {
    return SatpMode::Bare;
  } else if (mode_val == $bits(SatpMode::Sv32)) {
    if (MXLEN == 64) {
      if (effective_mode == PrivilegeMode::S && CSR[mstatus].SXL != $bits(XRegWidth::XLEN32)) {
        return SatpMode::Reserved;
      }
      if (effective_mode == PrivilegeMode::U && CSR[sstatus].UXL != $bits(XRegWidth::XLEN32)) {
        return SatpMode::Reserved;
      }
    }
    if (!implemented?(ExtensionName::Sv32)) {
      return SatpMode::Reserved;
    }
    return SatpMode::Sv32;
  } else if ((MXLEN == 64) && (mode_val == $bits(SatpMode::Sv39))) {
    if (effective_mode == PrivilegeMode::S && CSR[mstatus].SXL != $bits(XRegWidth::XLEN64)) {
      return SatpMode::Reserved;
    }
    if (effective_mode == PrivilegeMode::U && CSR[sstatus].UXL != $bits(XRegWidth::XLEN64)) {
      return SatpMode::Reserved;
    }
    if (!implemented?(ExtensionName::Sv39)) {
      return SatpMode::Reserved;
    }
    return SatpMode::Sv39;
  } else if ((MXLEN == 64) && (mode_val == $bits(SatpMode::Sv48))) {
    if (effective_mode == PrivilegeMode::S && CSR[mstatus].SXL != $bits(XRegWidth::XLEN64)) {
      return SatpMode::Reserved;
    }
    if (effective_mode == PrivilegeMode::U && CSR[sstatus].UXL != $bits(XRegWidth::XLEN64)) {
      return SatpMode::Reserved;
    }
    if (!implemented?(ExtensionName::Sv48)) {
      return SatpMode::Reserved;
    }
    return SatpMode::Sv48;
  } else if ((MXLEN == 64) && (mode_val == $bits(SatpMode::Sv57))) {
    if (effective_mode == PrivilegeMode::S && CSR[mstatus].SXL != $bits(XRegWidth::XLEN64)) {
      return SatpMode::Reserved;
    }
    if (effective_mode == PrivilegeMode::U && CSR[sstatus].UXL != $bits(XRegWidth::XLEN64)) {
      return SatpMode::Reserved;
    }
    if (!implemented?(ExtensionName::Sv57)) {
      return SatpMode::Reserved;
    }
    return SatpMode::Sv57;
  } else {
    return SatpMode::Reserved;
  }
} else {
  return SatpMode::Reserved;
}

PrivilegeMode effective_mode = effective_ldst_mode();
if (effective_mode == PrivilegeMode::M) {
  return SatpMode::Bare;
}
if (effective_mode == PrivilegeMode::VS || effective_mode == PrivilegeMode::VU) {
  Bits<4> mode_val = CSR[vsatp].MODE;
  if (mode_val == $bits(SatpMode::Bare)) {
    return SatpMode::Bare;
  } else if (mode_val == $bits(SatpMode::Sv32)) {
    if ((effective_mode == PrivilegeMode::VS) && (CSR[hstatus].VSXL != $bits(XRegWidth::XLEN32))) {
      return SatpMode::Reserved;
    }
    if ((effective_mode == PrivilegeMode::VU) && (CSR[vsstatus].UXL != $bits(XRegWidth::XLEN32))) {
      return SatpMode::Reserved;
    }
    if (!SV32_VSMODE_TRANSLATION) {
      return SatpMode::Reserved;
    }
    return SatpMode::Sv32;
  } else if ((mode_val == $bits(SatpMode::Sv39))) {
    if (effective_mode == PrivilegeMode::VS && CSR[hstatus].VSXL != $bits(XRegWidth::XLEN64)) {
      return SatpMode::Reserved;
    }
    if (effective_mode == PrivilegeMode::VU && CSR[vsstatus].UXL != $bits(XRegWidth::XLEN64)) {
      return SatpMode::Reserved;
    }

    return SatpMode::Sv39;
  } else if ((mode_val == $bits(SatpMode::Sv48))) {
    if (effective_mode == PrivilegeMode::VS && CSR[hstatus].VSXL != $bits(XRegWidth::XLEN64)) {
      return SatpMode::Reserved;
    }
    if (effective_mode == PrivilegeMode::VU && CSR[vsstatus].UXL != $bits(XRegWidth::XLEN64)) {
      return SatpMode::Reserved;
    }

    return SatpMode::Sv48;
  } else if ((mode_val == $bits(SatpMode::Sv57))) {
    if (effective_mode == PrivilegeMode::VS && CSR[hstatus].VSXL != $bits(XRegWidth::XLEN64)) {
      return SatpMode::Reserved;
    }
    if (effective_mode == PrivilegeMode::VU && CSR[vsstatus].UXL != $bits(XRegWidth::XLEN64)) {
      return SatpMode::Reserved;
    }

    return SatpMode::Sv57;
  } else {
    return SatpMode::Reserved;
  }
} else {
  return SatpMode::Reserved;
}

if (for_final_vs_pte) {
  if (op == MemoryOperation::Fetch) {
    if (TINST_VALUE_ON_FINAL_INSTRUCTION_GUEST_PAGE_FAULT == "always zero") {
      return 0;
    } else {
      assert(TINST_VALUE_ON_FINAL_INSTRUCTION_GUEST_PAGE_FAULT == "always pseudoinstruction", "Instruction guest page faults can only report zero/pseudo instruction in tval");
      return 0x00002000;
    }
  } else if (op == MemoryOperation::Read) {
    if (TINST_VALUE_ON_FINAL_LOAD_GUEST_PAGE_FAULT == "always zero") {
      return 0;
    } else if (TINST_VALUE_ON_FINAL_LOAD_GUEST_PAGE_FAULT == "always pseudoinstruction") {
      if (($array_size(VSXLEN) == 1 && VSXLEN[0] == 32) || MXLEN == 64) && (CSR[hstatus].VSXL == $bits(XRegWidth::XLEN32)) {
        return 0x00002000;
      } else {
        return 0x00003000;
      }
    } else if (TINST_VALUE_ON_FINAL_LOAD_GUEST_PAGE_FAULT == "always transformed standard instruction") {
      return tinst_transform(encoding, 0);
    } else {
      unpredictable("Custom value written into htinst/mtinst");
      return 0;
    }
  } else if (op == MemoryOperation::Write || op == MemoryOperation::ReadModifyWrite) {
    if (TINST_VALUE_ON_FINAL_STORE_AMO_GUEST_PAGE_FAULT == "always zero") {
      return 0;
    } else if (TINST_VALUE_ON_FINAL_STORE_AMO_GUEST_PAGE_FAULT == "always pseudoinstruction") {
      if (($array_size(VSXLEN) == 1 && VSXLEN[0] == 32) || MXLEN == 64) && (CSR[hstatus].VSXL == $bits(XRegWidth::XLEN32)) {
        return 0x00002020;
      } else {
        return 0x00003020;
      }
    } else if (TINST_VALUE_ON_FINAL_STORE_AMO_GUEST_PAGE_FAULT == "always transformed standard instruction") {
      return tinst_transform(encoding, 0);
    } else {
      unpredictable("Custom value written into htinst/mtinst");
      return 0;
    }
  }
} else {
  if (REPORT_GPA_IN_TVAL_ON_INTERMEDIATE_GUEST_PAGE_FAULT) {
    if (($array_size(VSXLEN) == 1 && VSXLEN[0] == 32) || MXLEN == 64) && (CSR[hstatus].VSXL == $bits(XRegWidth::XLEN32)) {
      return 0x00002000;
    } else if (($array_size(VSXLEN) == 1 && VSXLEN[0] == 64) || MXLEN == 64) && (CSR[hstatus].VSXL == $bits(XRegWidth::XLEN64)) {
      return 0x00003000;
    }
  }
}
return 0;

if (for_final_vs_pte) {
  if (op == MemoryOperation::Fetch) {
    return 0;
  } else if (op == MemoryOperation::Read) {
    return tinst_transform(encoding, 0);
  } else if (op == MemoryOperation::Write || op == MemoryOperation::ReadModifyWrite) {
    return tinst_transform(encoding, 0);
  }
} else {
  if (false || (CSR[hstatus].VSXL == $bits(XRegWidth::XLEN32))) {
    return 0x00002000;
  } else if (($array_size([7'64]) == 1) || (CSR[hstatus].VSXL == $bits(XRegWidth::XLEN64))) {
    return 0x00003000;
  }
}
return 0;

ExceptionCode code;
Boolean write_gpa_in_tval;
if (op == MemoryOperation::Read) {
  code = ExceptionCode::LoadGuestPageFault;
  write_gpa_in_tval = REPORT_GPA_IN_TVAL_ON_LOAD_GUEST_PAGE_FAULT;
} else if (op == MemoryOperation::Write || op == MemoryOperation::ReadModifyWrite) {
  code = ExceptionCode::StoreAmoGuestPageFault;
  write_gpa_in_tval = REPORT_GPA_IN_TVAL_ON_STORE_AMO_GUEST_PAGE_FAULT;
} else {
  assert(op == MemoryOperation::Fetch, "unexpected memory operation");
  code = ExceptionCode::InstructionGuestPageFault;
  write_gpa_in_tval = REPORT_GPA_IN_TVAL_ON_INSTRUCTION_GUEST_PAGE_FAULT;
}
PrivilegeMode handling_mode = exception_handling_mode(code);
if (handling_mode == PrivilegeMode::S) {
  CSR[htval].VALUE = write_gpa_in_tval ? (gpa >> 2) : 0;
  CSR[htinst].VALUE = tinst_value;
  CSR[sepc].PC = $pc;
  if (!stval_readonly?()) {
    CSR[stval].VALUE = stval_for(code, gva);
  }
  $pc = {CSR[stvec].BASE, 2'b00};
  CSR[scause].INT = 1'b0;
  CSR[scause].CODE = $bits(code);
  CSR[hstatus].GVA = 1;
  CSR[hstatus].SPV = 1;
  CSR[hstatus].SPVP = $bits(from_mode)[0];
  CSR[mstatus].SPP = $bits(from_mode)[0];
} else {
  assert(handling_mode == PrivilegeMode::M, "unexpected privilege mode");
  CSR[mtval2].VALUE = write_gpa_in_tval ? (gpa >> 2) : 0;
  CSR[mtinst].VALUE = tinst_value;
  CSR[mstatus].MPP = $bits(from_mode)[1:0];
  if (MXLEN == 64) {
    CSR[mstatus].MPV = 1;
  } else {
    CSR[mstatush].MPV = 1;
  }
}
set_mode(handling_mode);
abort_current_instruction();

ExceptionCode code;
Boolean write_gpa_in_tval;
if (op == MemoryOperation::Read) {
  code = ExceptionCode::LoadGuestPageFault;
  write_gpa_in_tval = true;
} else if (op == MemoryOperation::Write || op == MemoryOperation::ReadModifyWrite) {
  code = ExceptionCode::StoreAmoGuestPageFault;
  write_gpa_in_tval = true;
} else {
  assert(op == MemoryOperation::Fetch, "unexpected memory operation");
  code = ExceptionCode::InstructionGuestPageFault;
  write_gpa_in_tval = true;
}
PrivilegeMode handling_mode = exception_handling_mode(code);
if (handling_mode == PrivilegeMode::S) {
  CSR[htval].VALUE = write_gpa_in_tval ? (gpa >> 2) : 0;
  CSR[htinst].VALUE = tinst_value;
  CSR[sepc].PC = $pc;
  CSR[stval].VALUE = stval_for(code, gva);
  $pc = {CSR[stvec].BASE, 2'b00};
  CSR[scause].INT = 1'b0;
  CSR[scause].CODE = $bits(code);
  CSR[hstatus].GVA = 1;
  CSR[hstatus].SPV = 1;
  CSR[hstatus].SPVP = $bits(from_mode)[0];
  CSR[mstatus].SPP = $bits(from_mode)[0];
} else {
  assert(handling_mode == PrivilegeMode::M, "unexpected privilege mode");
  CSR[mtval2].VALUE = write_gpa_in_tval ? (gpa >> 2) : 0;
  CSR[mtinst].VALUE = tinst_value;
  CSR[mstatus].MPP = $bits(from_mode)[1:0];
  CSR[mstatus].MPV = 1;
}
set_mode(handling_mode);
abort_current_instruction();

Bits<12> pmpcfg0_addr = 0x3a0;
Bits<12> pmpaddr0_addr = 0x3b0;
for (U32 i = 0; i < NUM_PMP_ENTRIES; i++) {
  Bits<12> pmpcfg_idx = pmpcfg0_addr + (i / 8) * 2;
  Bits<6> shamt = (i % 8) * 8;
  Csr pmpcfg_csr = direct_csr_lookup(pmpcfg_idx);
  PmpCfg cfg = (csr_hw_read(pmpcfg_csr) >> shamt)[7:0];
  Bits<12> pmpaddr_idx = pmpaddr0_addr + i;
  Csr pmpaddr_csr = direct_csr_lookup(pmpaddr_idx);
  Bits<64> pmpaddr_csr_value = csr_sw_read(pmpaddr_csr);
  Bits<PHYS_ADDR_WIDTH> range_base = 0;
  Bits<PHYS_ADDR_WIDTH> range_limit = 0;
  if (cfg.A == $bits(PmpCfg_A::TOR)) {
    if (i == 0) {
      range_base = 0;
    } else {
      Csr tor_pmpaddr_csr = direct_csr_lookup(pmpaddr_idx - 1);
      range_base = (csr_sw_read(tor_pmpaddr_csr))[PHYS_ADDR_WIDTH - 1:0];
    }
    range_limit = (pmpaddr_csr_value)[PHYS_ADDR_WIDTH - 1:0] - 1;
  } else if (cfg.A == $bits(PmpCfg_A::NAPOT)) {
    Bits<PHYS_ADDR_WIDTH - 1> pmpaddr_value = pmpaddr_csr_value[PHYS_ADDR_WIDTH - 1:0];
    Bits<PHYS_ADDR_WIDTH - 1> mask = pmpaddr_value ^ (pmpaddr_value + 1);
    range_base = (pmpaddr_value & ~mask);
    range_limit = range_base + mask;
  } else if (cfg.A == $bits(PmpCfg_A::NA4)) {
    range_base = pmpaddr_csr_value[PHYS_ADDR_WIDTH - 1:0];
    range_limit = range_base + 3;
  }
  if (paddr {
    return PmpMatchResult::FullMatch, cfg;
  } else if (! {
    return PmpMatchResult::PartialMatch, -;
  }
}
return PmpMatchResult::NoMatch, -;

Bits<12> pmpcfg0_addr = 0x3a0;
Bits<12> pmpaddr0_addr = 0x3b0;
for (U32 i = 0; i < 7'16; i++) {
  Bits<12> pmpcfg_idx = 12'h3a0 + (i / 8) * 2;
  Bits<6> shamt = (i % 8) * 8;
  Csr pmpcfg_csr = direct_csr_lookup(pmpcfg_idx);
  PmpCfg cfg = (csr_hw_read(pmpcfg_csr) >> shamt)[7:0];
  Bits<12> pmpaddr_idx = 12'h3b0 + i;
  Csr pmpaddr_csr = direct_csr_lookup(pmpaddr_idx);
  Bits<64> pmpaddr_csr_value = csr_sw_read(pmpaddr_csr);
  Bits<PHYS_ADDR_WIDTH> range_base = 0;
  Bits<PHYS_ADDR_WIDTH> range_limit = 0;
  if (cfg.A == $bits(PmpCfg_A::TOR)) {
    if (i == 0) {
      range_base = 0;
    } else {
      Csr tor_pmpaddr_csr = direct_csr_lookup(pmpaddr_idx - 1);
      range_base = (csr_sw_read(tor_pmpaddr_csr))[7'55:0];
    }
    range_limit = pmpaddr_csr_value[7'55:0] - 1;
  } else if (cfg.A == $bits(PmpCfg_A::NAPOT)) {
    Bits<PHYS_ADDR_WIDTH - 1> pmpaddr_value = pmpaddr_csr_value[7'55:0];
    Bits<PHYS_ADDR_WIDTH - 1> mask = pmpaddr_value ^ (pmpaddr_value + 1);
    range_base = (pmpaddr_value & ~mask);
    range_limit = range_base + mask;
  } else if (cfg.A == $bits(PmpCfg_A::NA4)) {
    range_base = pmpaddr_csr_value[7'55:0];
    range_limit = range_base + 3;
  }
  if (paddr {
    return PmpMatchResult::FullMatch, cfg;
  } else if (! {
    return PmpMatchResult::PartialMatch, -;
  }
}
return PmpMatchResult::NoMatch, -;

if (MXLEN == 64) {
  return pmp_match_64(paddr, access_size);
} else {
  return pmp_match_32(paddr, access_size);
}

return pmp_match_64(paddr, access_size);

PrivilegeMode mode = effective_ldst_mode();
PmpMatchResult match_result;
PmpCfg cfg;
(match_result, cfg = pmp_match(paddr, access_size));
if (match_result == PmpMatchResult::FullMatch) {
  if (mode == PrivilegeMode::M && (cfg.L == 0)) {
    return true;
  }
  if (type == MemoryOperation::Write && (cfg.W == 0)) {
    return false;
  } else if (type == MemoryOperation::Read && (cfg.R == 0)) {
    return false;
  } else if (type == MemoryOperation::Fetch && (cfg.X == 0)) {
    return false;
  }
} else if (match_result == PmpMatchResult::NoMatch) {
  if (mode == PrivilegeMode::M) {
    return true;
  } else {
    return false;
  }
} else {
  assert(match_result == PmpMatchResult::PartialMatch, "PMP matching logic error");
  return false;
}
return true;

PrivilegeMode mode = effective_ldst_mode();
PmpMatchResult match_result;
PmpCfg cfg;
(match_result, cfg = pmp_match(paddr, access_size));
if (match_result == PmpMatchResult::FullMatch) {
  if (mode == PrivilegeMode::M && (cfg.L == 0)) {
    return true;
  }
  if (type == MemoryOperation::Write && (cfg.W == 0)) {
    return false;
  } else if (type == MemoryOperation::Read && (cfg.R == 0)) {
    return false;
  } else if (type == MemoryOperation::Fetch && (cfg.X == 0)) {
    return false;
  }
} else if (match_result == PmpMatchResult::NoMatch) {
  if (mode == PrivilegeMode::M) {
    return true;
  } else {
    return false;
  }
} else {
  assert(match_result == PmpMatchResult::PartialMatch, "PMP matching logic error");
  return false;
}
return true;

if (paddr > 1 `<< PHYS_ADDR_WIDTH) - access_size {
  raise(fault_type, from_mode, vaddr);
}
if (NUM_PMP_ENTRIES > 0) {
  if (!pmp_check(paddr[PHYS_ADDR_WIDTH - 1:0], access_size, type)) {
    raise(fault_type, from_mode, vaddr);
  }
}

if (paddr > (57'h100000000000000 - access_size)) {
  raise(fault_type, from_mode, vaddr);
}
if (!pmp_check(paddr[7'55:0], access_size, type)) {
  raise(fault_type, from_mode, vaddr);
}

if (len == 8) {
  return read_physical_memory_8(paddr);
} else if (len == 16) {
  return read_physical_memory_16(paddr);
} else if (len == 32) {
  return read_physical_memory_32(paddr);
} else if (len == 64) {
  return read_physical_memory_64(paddr);
} else {
  assert(false, "Invalid len");
  return 0;
}

if (len == 8) {
  return read_physical_memory_8(paddr);
} else if (len == 16) {
  return read_physical_memory_16(paddr);
} else if (len == 32) {
  return read_physical_memory_32(paddr);
} else if (len == 64) {
  return read_physical_memory_64(paddr);
} else {
  assert(false, "Invalid len");
  return 0;
}

Bits<PA_SIZE> ppn;
TranslationResult result;
U32 VPN_SIZE = (LEVELS == 2) ? 10 : 9;
ExceptionCode access_fault_code = op == MemoryOperation::Read ? ExceptionCode::LoadAccessFault : (op == MemoryOperation::Fetch ? ExceptionCode::InstructionAccessFault : ExceptionCode::StoreAmoAccessFault);
ExceptionCode page_fault_code = op == MemoryOperation::Read ? ExceptionCode::LoadGuestPageFault : (op == MemoryOperation::Fetch ? ExceptionCode::InstructionGuestPageFault : ExceptionCode::StoreAmoGuestPageFault);
Boolean mxr = for_final_vs_pte && (CSR[mstatus].MXR == 1);
Boolean pbmte = implemented?(ExtensionName::Svpbmt) && CSR[menvcfg].PBMTE == 1;
Boolean adue = implemented?(ExtensionName::Svadu) && CSR[menvcfg].ADUE == 1;
Bits<32> tinst = tinst_value_for_guest_page_fault(op, encoding, for_final_vs_pte);
U32 max_gpa_width = LEVELS * VPN_SIZE + 2 + 12;
if (gpaddr >> max_gpa_width != 0) {
  raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
}
ppn = CSR[hgatp].PPN;
for (U32 i = (LEVELS - 1); i >= 0; i--) {
  U32 this_vpn_size = (i == (LEVELS - 1)) ? VPN_SIZE + 2 : VPN_SIZE;
  U32 vpn = (gpaddr >> (12 + VPN_SIZE * i)) & 1 << this_vpn_size) - 1);   Bits<PA_SIZE> pte_paddr = (ppn << 12) + (vpn * (PTESIZE / 8;
  if (!pma_applies?(PmaAttribute::HardwarePageTableRead, pte_paddr, PTESIZE)) {
    raise(access_fault_code, PrivilegeMode::U, vaddr);
  }
  access_check(pte_paddr, PTESIZE, vaddr, MemoryOperation::Read, access_fault_code, effective_mode);
  XReg pte = read_physical_memory(PTESIZE, pte_paddr);
  PteFlags pte_flags = pte[9:0];
  if (xlen() == 64) {
    if ((VA_SIZE != 32) && (pte[58:54] != 0)) {
      raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
    }
    if (!implemented?(ExtensionName::Svrsw60t59b)) {
      if ((PTESIZE >= 64) && pte[60:59] != 0) {
        raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
      }
    }
    if (!implemented?(ExtensionName::Svnapot)) {
      if ((PTESIZE >= 64) && pte[63] != 0) {
        raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
      }
    }
    if ((PTESIZE >= 64) && !pbmte && (pte[62:61] != 0)) {
      raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
    }
    if ((PTESIZE >= 64) && pbmte && (pte[62:61] == 3)) {
      raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
    }
  }
  if (pte_flags.V == 0) {
    raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
  }
  if (pte_flags.R == 0 && pte_flags.W == 1) {
    raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
  }
  if (pte_flags.R == 1 || pte_flags.X == 1) {
    if (pte_flags.U == 0) {
      raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
    }
    if (op == MemoryOperation::Write) || (op == MemoryOperation::ReadModifyWrite && (pte_flags.W == 0)) {
      raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
    } else if ((op == MemoryOperation::Fetch) && (pte_flags.X == 0)) {
      raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
    } else if ((op == MemoryOperation::Read) || (op == MemoryOperation::ReadModifyWrite)) {
      if (!mxr) && (pte_flags.R == 0 || mxr) && (pte_flags.X == 0 && pte_flags.R == 0) {
        raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
      }
    }
    if ((i > 0) && (pte[(i - 1) * VPN_SIZE:0] != 0)) {
      raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
    }
    if ((pte_flags.A == 0) || pte_flags.D == 0) && ((op == MemoryOperation::Write) || (op == MemoryOperation::ReadModifyWrite)) {
      if (adue) {
        if (!pma_applies?(PmaAttribute::RsrvEventual, pte_paddr, PTESIZE)) {
          raise(access_fault_code, PrivilegeMode::U, vaddr);
        }
        if (!pma_applies?(PmaAttribute::HardwarePageTableWrite, pte_paddr, PTESIZE)) {
          raise(access_fault_code, PrivilegeMode::U, vaddr);
        }
        access_check(pte_paddr, PTESIZE, vaddr, MemoryOperation::Write, access_fault_code, effective_mode);
        Boolean success;
        Bits<PTESIZE> updated_pte;
        if (pte_flags.D == 0 && (op == MemoryOperation::Write || op == MemoryOperation::ReadModifyWrite)) {
          updated_pte = pte | 0b11000000;
        } else {
          updated_pte = pte | 0b01000000;
        }
        if (PTESIZE == 32) {
          success = atomic_check_then_write_32(pte_paddr, pte, updated_pte);
        } else if (PTESIZE == 64) {
          success = atomic_check_then_write_64(pte_paddr, pte, updated_pte);
        } else {
          assert(false, "Unexpected PTESIZE");
          unreachable();
        }
        if (!success) {
          i = i + 1;
        } else {
          result.paddr = pte_paddr;
          if ((xlen() == 64) && (PTESIZE >= 64)) {
            result.pbmt = $enum(Pbmt, pte[62:61]);
          }
          result.pte_flags = pte_flags;
          return result;
        }
      } else {
        raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
      }
    }
  } else {
    if (i == 0) {
      raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
    }
    if (pte_flags.D == 1 || pte_flags.A == 1 || pte_flags.U == 1) {
      raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
    }
    if (xlen() == 64) {
      if ((VA_SIZE != 32) && (pte[62:61] != 0)) {
        raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
      }
      if ((VA_SIZE != 32) && pte[63] != 0) {
        raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
      }
    }
    ppn = pte[PA_SIZE - 3:10] << 12;
  }
}
unreachable();

Bits<PA_SIZE> ppn;
TranslationResult result;
U32 VPN_SIZE = (LEVELS == 2) ? 10 : 9;
ExceptionCode access_fault_code = op == MemoryOperation::Read ? ExceptionCode::LoadAccessFault : (op == MemoryOperation::Fetch ? ExceptionCode::InstructionAccessFault : ExceptionCode::StoreAmoAccessFault);
ExceptionCode page_fault_code = op == MemoryOperation::Read ? ExceptionCode::LoadGuestPageFault : (op == MemoryOperation::Fetch ? ExceptionCode::InstructionGuestPageFault : ExceptionCode::StoreAmoGuestPageFault);
Boolean mxr = for_final_vs_pte && (CSR[mstatus].MXR == 1);
Boolean pbmte = false;
Boolean adue = false;
Bits<32> tinst = tinst_value_for_guest_page_fault(op, encoding, for_final_vs_pte);
U32 max_gpa_width = LEVELS * VPN_SIZE + 2 + 12;
if (gpaddr >> max_gpa_width != 0) {
  raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
}
ppn = CSR[hgatp].PPN;
for (U32 i = (LEVELS - 1); i >= 0; i--) {
  U32 this_vpn_size = (i == (LEVELS - 1)) ? VPN_SIZE + 2 : VPN_SIZE;
  U32 vpn = (gpaddr >> (12 + VPN_SIZE * i)) & 1 << this_vpn_size) - 1);   Bits<PA_SIZE> pte_paddr = (ppn << 12) + (vpn * (PTESIZE / 8;
  if (!pma_applies?(PmaAttribute::HardwarePageTableRead, pte_paddr, PTESIZE)) {
    raise(access_fault_code, PrivilegeMode::U, vaddr);
  }
  access_check(pte_paddr, PTESIZE, vaddr, MemoryOperation::Read, access_fault_code, effective_mode);
  XReg pte = read_physical_memory(PTESIZE, pte_paddr);
  PteFlags pte_flags = pte[9:0];
  if (xlen() == 64) {
    if ((VA_SIZE != 32) && (pte[58:54] != 0)) {
      raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
    }
    if ((PTESIZE >= 64) && pte[60:59] != 0) {
      raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
    }
    if ((PTESIZE >= 64) && pte[63] != 0) {
      raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
    }
    if ((PTESIZE >= 64) && (pte[62:61] != 0)) {
      raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
    }
    if (false && (pte[62:61] == 3)) {
      raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
    }
  }
  if (pte_flags.V == 0) {
    raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
  }
  if (pte_flags.R == 0 && pte_flags.W == 1) {
    raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
  }
  if (pte_flags.R == 1 || pte_flags.X == 1) {
    if (pte_flags.U == 0) {
      raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
    }
    if (op == MemoryOperation::Write) || (op == MemoryOperation::ReadModifyWrite && (pte_flags.W == 0)) {
      raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
    } else if ((op == MemoryOperation::Fetch) && (pte_flags.X == 0)) {
      raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
    } else if ((op == MemoryOperation::Read) || (op == MemoryOperation::ReadModifyWrite)) {
      if (!mxr) && (pte_flags.R == 0 || (mxr && (pte_flags.X == 0 && pte_flags.R == 0))) {
        raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
      }
    }
    if ((i > 0) && (pte[(i - 1) * VPN_SIZE:0] != 0)) {
      raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
    }
    if ((pte_flags.A == 0) || pte_flags.D == 0) && ((op == MemoryOperation::Write) || (op == MemoryOperation::ReadModifyWrite)) {
      raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
    }
  } else {
    if (i == 0) {
      raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
    }
    if (pte_flags.D == 1 || pte_flags.A == 1 || pte_flags.U == 1) {
      raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
    }
    if (xlen() == 64) {
      if ((VA_SIZE != 32) && (pte[62:61] != 0)) {
        raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
      }
      if ((VA_SIZE != 32) && pte[63] != 0) {
        raise_guest_page_fault(op, gpaddr, vaddr, tinst, effective_mode);
      }
    }
    ppn = pte[PA_SIZE - 3:10] << 12;
  }
}
unreachable();

if (encoding[1:0] == 0b11) {
  if (encoding[6:2] == 5'b00001) {
    return {{12{1'b0}}, addr_offset, encoding[14:0]};
  } else if (encoding[6:2] == 5'b01000) {
    return {{7{1'b0}}, encoding[24:20], addr_offset, encoding[14:12], {5{1'b0}}, encoding[6:0]};
  } else if (encoding[6:2] == 5'b01011) {
    return {encoding[31:20], addr_offset, encoding[14:0]};
  } else if (encoding[6:2] == 5'b00011) {
    return {encoding[31:20], addr_offset, encoding[14:0]};
  } else {
    assert(false, "Bad transform");
    unreachable();
  }
} else {
  assert(false, "TODO: compressed instruction");
  unreachable();
}

if (encoding[1:0] == 0b11) {
  if (encoding[6:2] == 5'b00001) {
    return {12'0, addr_offset, encoding[14:0]};
  } else if (encoding[6:2] == 5'b01000) {
    return {7'0, encoding[24:20], addr_offset, encoding[14:12], 5'0, encoding[6:0]};
  } else if (encoding[6:2] == 5'b01011) {
    return {encoding[31:20], addr_offset, encoding[14:0]};
  } else if (encoding[6:2] == 5'b00011) {
    return {encoding[31:20], addr_offset, encoding[14:0]};
  } else {
    assert(false, "Bad transform");
    unreachable();
  }
} else {
  assert(false, "TODO: compressed instruction");
  unreachable();
}

TranslationResult result;
if (!implemented?(ExtensionName::H) || effective_mode == PrivilegeMode::S || effective_mode == PrivilegeMode::U) {
  result.paddr = gpaddr;
  return result;
}
Boolean mxr = CSR[mstatus].MXR == 1;
if (GSTAGE_MODE_BARE && CSR[hgatp].MODE == $bits(HgatpMode::Bare)) {
  result.paddr = gpaddr;
  return result;
} else if (SV32X4_TRANSLATION && CSR[hgatp].MODE == $bits(HgatpMode::Sv32x4)) {
  return gstage_page_walk(32, 34, 32, 2, gpaddr, vaddr, op, effective_mode, false, encoding);
} else if (SV39X4_TRANSLATION && CSR[hgatp].MODE == $bits(HgatpMode::Sv39x4)) {
  return gstage_page_walk(39, 56, 64, 3, gpaddr, vaddr, op, effective_mode, false, encoding);
} else if (SV48X4_TRANSLATION && CSR[hgatp].MODE == $bits(HgatpMode::Sv48x4)) {
  return gstage_page_walk(48, 56, 64, 4, gpaddr, vaddr, op, effective_mode, false, encoding);
} else if (SV57X4_TRANSLATION && CSR[hgatp].MODE == $bits(HgatpMode::Sv57x4)) {
  return gstage_page_walk(57, 56, 64, 5, gpaddr, vaddr, op, effective_mode, false, encoding);
} else {
  if (op == MemoryOperation::Read) {
    raise_guest_page_fault(op, gpaddr, vaddr, tinst_value_for_guest_page_fault(op, encoding, true), effective_mode);
  } else if (op == MemoryOperation::Write || op == MemoryOperation::ReadModifyWrite) {
    raise_guest_page_fault(op, gpaddr, vaddr, tinst_value_for_guest_page_fault(op, encoding, true), effective_mode);
  } else {
    assert(op == MemoryOperation::Fetch, "unexpected memory op");
    raise_guest_page_fault(op, gpaddr, vaddr, tinst_value_for_guest_page_fault(op, encoding, true), effective_mode);
  }
}

TranslationResult result;
if (effective_mode == PrivilegeMode::S || effective_mode == PrivilegeMode::U) {
  result.paddr = gpaddr;
  return result;
}
Boolean mxr = CSR[mstatus].MXR == 1;
if (CSR[hgatp].MODE == $bits(HgatpMode::Bare)) {
  result.paddr = gpaddr;
  return result;
} else if (SV32X4_TRANSLATION && CSR[hgatp].MODE == $bits(HgatpMode::Sv32x4)) {
  return gstage_page_walk(32, 34, 32, 2, gpaddr, vaddr, op, effective_mode, false, encoding);
} else if (CSR[hgatp].MODE == $bits(HgatpMode::Sv39x4)) {
  return gstage_page_walk(39, 56, 64, 3, gpaddr, vaddr, op, effective_mode, false, encoding);
} else if (CSR[hgatp].MODE == $bits(HgatpMode::Sv48x4)) {
  return gstage_page_walk(48, 56, 64, 4, gpaddr, vaddr, op, effective_mode, false, encoding);
} else {
  if (op == MemoryOperation::Read) {
    raise_guest_page_fault(op, gpaddr, vaddr, tinst_value_for_guest_page_fault(op, encoding, true), effective_mode);
  } else if (op == MemoryOperation::Write || op == MemoryOperation::ReadModifyWrite) {
    raise_guest_page_fault(op, gpaddr, vaddr, tinst_value_for_guest_page_fault(op, encoding, true), effective_mode);
  } else {
    assert(op == MemoryOperation::Fetch, "unexpected memory op");
    raise_guest_page_fault(op, gpaddr, vaddr, tinst_value_for_guest_page_fault(op, encoding, true), effective_mode);
  }
}

Bits<PA_SIZE> ppn;
TranslationResult result;
U32 VPN_SIZE = (LEVELS == 2) ? 10 : 9;
ExceptionCode access_fault_code = op == MemoryOperation::Read ? ExceptionCode::LoadAccessFault : (op == MemoryOperation::Fetch ? ExceptionCode::InstructionAccessFault : ExceptionCode::StoreAmoAccessFault);
ExceptionCode page_fault_code = op == MemoryOperation::Read ? ExceptionCode::LoadPageFault : (op == MemoryOperation::Fetch ? ExceptionCode::InstructionPageFault : ExceptionCode::StoreAmoPageFault);
Boolean sse = false;
Boolean adue;
if (CSR[misa].H == 1 && (effective_mode == PrivilegeMode::VS || effective_mode == PrivilegeMode::VU)) {
  adue = implemented?(ExtensionName::Svadu) && CSR[henvcfg].ADUE == 1;
} else {
  adue = implemented?(ExtensionName::Svadu) && CSR[menvcfg].ADUE == 1;
}
Boolean pbmte;
if ((xlen() == 32) || VA_SIZE == 32) {
  pbmte = false;
} else {
  if (CSR[misa].H == 1 && (effective_mode == PrivilegeMode::VS || effective_mode == PrivilegeMode::VU)) {
    pbmte = implemented?(ExtensionName::Svpbmt) && CSR[henvcfg].PBMTE == 1;
  } else {
    pbmte = implemented?(ExtensionName::Svpbmt) && CSR[menvcfg].PBMTE == 1;
  }
}
Boolean mxr;
if (CSR[misa].H == 1 && (effective_mode == PrivilegeMode::VS || effective_mode == PrivilegeMode::VU)) {
  mxr = (CSR[mstatus].MXR == 1) || (CSR[vsstatus].MXR == 1);
  ppn = CSR[vsatp].PPN;
} else {
  mxr = CSR[mstatus].MXR == 1;
  ppn = CSR[satp].PPN;
}
Boolean sum;
if (CSR[misa].H == 1 && (effective_mode == PrivilegeMode::VS)) {
  sum = CSR[vsstatus].SUM == 1;
} else {
  sum = CSR[mstatus].SUM == 1;
}
if ((VA_SIZE < xlen()) && (vaddr[xlen() - 1:VA_SIZE] != {xlen() - VA_SIZE{vaddr[VA_SIZE - 1]}})) {
  raise(page_fault_code, mode(), vaddr);
}
for (U32 I = (LEVELS - 1); I >= 0; I--) {
  U32 vpn = (vaddr >> (12 + VPN_SIZE * I)) & 1 `<< VPN_SIZE) - 1);   Bits<PA_SIZE> pte_gpaddr = (ppn << 12) + (vpn * (PTESIZE / 8;
  TranslationResult pte_phys = translate_gstage(pte_gpaddr, vaddr, MemoryOperation::Read, effective_mode, encoding);
  if (!pma_applies?(PmaAttribute::HardwarePageTableRead, pte_phys.paddr, PTESIZE)) {
    raise(access_fault_code, mode(), vaddr);
  }
  access_check(pte_phys.paddr, PTESIZE, vaddr, MemoryOperation::Read, access_fault_code, effective_mode);
  XReg pte = read_physical_memory(PTESIZE, pte_phys.paddr);
  PteFlags pte_flags = pte[9:0];
  Boolean ss_page = (pte_flags.R == 0) && (pte_flags.W == 1) && (pte_flags.X == 0);
  if ((xlen() == 64) && (VA_SIZE != 32) && (pte[58:54] != 0)) {
    raise(page_fault_code, mode(), vaddr);
  }
  if (pte_flags.V == 0) {
    raise(page_fault_code, mode(), vaddr);
  }
  if (!sse) {
    if ((pte_flags.R == 0) && (pte_flags.W == 1)) {
      raise(page_fault_code, mode(), vaddr);
    }
  }
  if (xlen() == 64) {
    if (pbmte) {
      if (pte[62:61] == 3) {
        raise(page_fault_code, mode(), vaddr);
      }
    } else {
      if ((PTESIZE >= 64) && (pte[62:61] != 0)) {
        raise(page_fault_code, mode(), vaddr);
      }
    }
    if (!implemented?(ExtensionName::Svrsw60t59b)) {
      if ((PTESIZE >= 64) && pte[60:59] != 0) {
        raise(page_fault_code, mode(), vaddr);
      }
    }
    if (!implemented?(ExtensionName::Svnapot)) {
      if ((PTESIZE >= 64) && (pte[63] != 0)) {
        raise(page_fault_code, mode(), vaddr);
      }
    }
  }
  if (pte_flags.R == 1 || pte_flags.X == 1) {
    Bits<PA_SIZE> paddr_base = pte[PA_SIZE - 3:I * VPN_SIZE + 10] `<< (I * VPN_SIZE + 12);
    Bits<PA_SIZE> offset = vaddr[I * VPN_SIZE + 11:0];
    if (op == MemoryOperation::Read || op == MemoryOperation::ReadModifyWrite) {
      if (!mxr) && (pte_flags.R == 0 || mxr) && (pte_flags.X == 0 && pte_flags.R == 0) {
        raise(page_fault_code, mode(), vaddr);
      }
      if (effective_mode == PrivilegeMode::U && pte_flags.U == 0) {
        raise(page_fault_code, mode(), vaddr);
      } else if (CSR[misa].H == 1 && effective_mode == PrivilegeMode::VU && pte_flags.U == 0) {
        raise(page_fault_code, mode(), vaddr);
      } else if (effective_mode == PrivilegeMode::S && pte_flags.U == 1 && !sum) {
        raise(page_fault_code, mode(), vaddr);
      } else if (effective_mode == PrivilegeMode::VS && pte_flags.U == 1 && !sum) {
        raise(page_fault_code, mode(), vaddr);
      }
    }
    if (op == MemoryOperation::Write) || (op == MemoryOperation::ReadModifyWrite && (pte_flags.W == 0)) {
      raise(page_fault_code, mode(), vaddr);
    } else if ((op == MemoryOperation::Fetch) && (pte_flags.X == 0)) {
      raise(page_fault_code, mode(), vaddr);
    } else if ((op == MemoryOperation::Fetch) && ss_page) {
      raise(page_fault_code, mode(), vaddr);
    }
    raise(page_fault_code, mode(), vaddr) if ;
    if ((pte_flags.A == 0) || pte_flags.D == 0) && ((op == MemoryOperation::Write) || (op == MemoryOperation::ReadModifyWrite)) {
      if (adue) {
        TranslationResult pte_phys = translate_gstage(pte_gpaddr, vaddr, MemoryOperation::Write, effective_mode, encoding);
        if (!pma_applies?(PmaAttribute::RsrvEventual, pte_phys.paddr, PTESIZE)) {
          raise(access_fault_code, effective_mode, vaddr);
        }
        if (!pma_applies?(PmaAttribute::HardwarePageTableWrite, pte_phys.paddr, PTESIZE)) {
          raise(access_fault_code, effective_mode, vaddr);
        }
        access_check(pte_phys.paddr, PTESIZE, vaddr, MemoryOperation::Write, access_fault_code, effective_mode);
        Boolean success;
        Bits<PTESIZE> updated_pte;
        if (pte_flags.D == 0 && (op == MemoryOperation::Write || op == MemoryOperation::ReadModifyWrite)) {
          updated_pte = pte | 0b11000000;
        } else {
          updated_pte = pte | 0b01000000;
        }
        if (PTESIZE == 32) {
          success = atomic_check_then_write_32(pte_phys.paddr, pte, updated_pte);
        } else if (PTESIZE == 64) {
          success = atomic_check_then_write_64(pte_phys.paddr, pte, updated_pte);
        } else {
          assert(false, "Unexpected PTESIZE");
          unreachable();
        }
        if (!success) {
          I = I + 1;
        } else {
          TranslationResult pte_phys = translate_gstage(paddr_base + offset, vaddr, op, effective_mode, encoding);
          result.paddr = pte_phys.paddr;
          if (xlen() == 64) {
            result.pbmt = pte_phys.pbmt == Pbmt::PMA ? $enum(Pbmt, pte[62:61]) : pte_phys.pbmt;
          }
          result.pte_flags = pte_flags;
          return result;
        }
      } else {
        raise(page_fault_code, mode(), vaddr);
      }
    }
    TranslationResult pte_phys = translate_gstage(paddr_base + offset, vaddr, op, effective_mode, encoding);
    result.paddr = pte_phys.paddr;
    if (xlen() == 64 && PTESIZE >= 64) {
      result.pbmt = pte_phys.pbmt == Pbmt::PMA ? $enum(Pbmt, pte[62:61]) : pte_phys.pbmt;
    }
    result.pte_flags = pte_flags;
    return result;
  } else {
    if (I == 0) {
      raise(page_fault_code, mode(), vaddr);
    }
    if (pte_flags.D == 1 || pte_flags.A == 1 || pte_flags.U == 1) {
      raise(page_fault_code, mode(), vaddr);
    }
    if ((xlen() == 64) && (VA_SIZE != 32) && (pte[62:61] != 0)) {
      raise(page_fault_code, mode(), vaddr);
    }
    if ((xlen() == 64) && (VA_SIZE != 32) && pte[63] != 0) {
      raise(page_fault_code, mode(), vaddr);
    }
    ppn = pte[PA_SIZE - 3:10];
  }
}
unreachable();

Bits<PA_SIZE> ppn;
TranslationResult result;
U32 VPN_SIZE = (LEVELS == 2) ? 10 : 9;
ExceptionCode access_fault_code = op == MemoryOperation::Read ? ExceptionCode::LoadAccessFault : (op == MemoryOperation::Fetch ? ExceptionCode::InstructionAccessFault : ExceptionCode::StoreAmoAccessFault);
ExceptionCode page_fault_code = op == MemoryOperation::Read ? ExceptionCode::LoadPageFault : (op == MemoryOperation::Fetch ? ExceptionCode::InstructionPageFault : ExceptionCode::StoreAmoPageFault);
Boolean sse = false;
Boolean adue;
if ((effective_mode == PrivilegeMode::VS || effective_mode == PrivilegeMode::VU)) {
  adue = false;
} else {
  adue = false;
}
Boolean pbmte;
if ((xlen() == 32) || VA_SIZE == 32) {
  pbmte = false;
} else {
  if ((effective_mode == PrivilegeMode::VS || effective_mode == PrivilegeMode::VU)) {
    pbmte = false;
  } else {
    pbmte = false;
  }
}
Boolean mxr;
if ((effective_mode == PrivilegeMode::VS || effective_mode == PrivilegeMode::VU)) {
  mxr = (CSR[mstatus].MXR == 1) || (CSR[vsstatus].MXR == 1);
  ppn = CSR[vsatp].PPN;
} else {
  mxr = CSR[mstatus].MXR == 1;
  ppn = CSR[satp].PPN;
}
Boolean sum;
if ((effective_mode == PrivilegeMode::VS)) {
  sum = CSR[vsstatus].SUM == 1;
} else {
  sum = CSR[mstatus].SUM == 1;
}
if ((VA_SIZE < xlen()) && (vaddr[xlen() - 1:VA_SIZE] != {xlen() - VA_SIZE{vaddr[VA_SIZE - 1]}})) {
  raise(page_fault_code, mode(), vaddr);
}
for (U32 I = (LEVELS - 1); I >= 0; I--) {
  U32 vpn = (vaddr >> (12 + VPN_SIZE * I)) & 1 `<< VPN_SIZE) - 1);   Bits<PA_SIZE> pte_gpaddr = (ppn << 12) + (vpn * (PTESIZE / 8;
  TranslationResult pte_phys = translate_gstage(pte_gpaddr, vaddr, MemoryOperation::Read, effective_mode, encoding);
  if (!pma_applies?(PmaAttribute::HardwarePageTableRead, pte_phys.paddr, PTESIZE)) {
    raise(access_fault_code, mode(), vaddr);
  }
  access_check(pte_phys.paddr, PTESIZE, vaddr, MemoryOperation::Read, access_fault_code, effective_mode);
  XReg pte = read_physical_memory(PTESIZE, pte_phys.paddr);
  PteFlags pte_flags = pte[9:0];
  Boolean ss_page = (pte_flags.R == 0) && (pte_flags.W == 1) && (pte_flags.X == 0);
  if ((xlen() == 64) && (VA_SIZE != 32) && (pte[58:54] != 0)) {
    raise(page_fault_code, mode(), vaddr);
  }
  if (pte_flags.V == 0) {
    raise(page_fault_code, mode(), vaddr);
  }
  if ((pte_flags.R == 0) && (pte_flags.W == 1)) {
    raise(page_fault_code, mode(), vaddr);
  }
  if (xlen() == 64) {
    if (pbmte) {
      if (pte[62:61] == 3) {
        raise(page_fault_code, mode(), vaddr);
      }
    } else {
      if ((PTESIZE >= 64) && (pte[62:61] != 0)) {
        raise(page_fault_code, mode(), vaddr);
      }
    }
    if ((PTESIZE >= 64) && pte[60:59] != 0) {
      raise(page_fault_code, mode(), vaddr);
    }
    if ((PTESIZE >= 64) && (pte[63] != 0)) {
      raise(page_fault_code, mode(), vaddr);
    }
  }
  if (pte_flags.R == 1 || pte_flags.X == 1) {
    Bits<PA_SIZE> paddr_base = pte[PA_SIZE - 3:I * VPN_SIZE + 10] `<< (I * VPN_SIZE + 12);
    Bits<PA_SIZE> offset = vaddr[I * VPN_SIZE + 11:0];
    if (op == MemoryOperation::Read || op == MemoryOperation::ReadModifyWrite) {
      if (!mxr) && (pte_flags.R == 0 || (mxr && (pte_flags.X == 0 && pte_flags.R == 0))) {
        raise(page_fault_code, mode(), vaddr);
      }
      if (effective_mode == PrivilegeMode::U && pte_flags.U == 0) {
        raise(page_fault_code, mode(), vaddr);
      } else if (effective_mode == PrivilegeMode::VU && pte_flags.U == 0) {
        raise(page_fault_code, mode(), vaddr);
      } else if (effective_mode == PrivilegeMode::S && pte_flags.U == 1 && !sum) {
        raise(page_fault_code, mode(), vaddr);
      } else if (effective_mode == PrivilegeMode::VS && pte_flags.U == 1 && !sum) {
        raise(page_fault_code, mode(), vaddr);
      }
    }
    if (op == MemoryOperation::Write) || (op == MemoryOperation::ReadModifyWrite && (pte_flags.W == 0)) {
      raise(page_fault_code, mode(), vaddr);
    } else if ((op == MemoryOperation::Fetch) && (pte_flags.X == 0)) {
      raise(page_fault_code, mode(), vaddr);
    } else if ((op == MemoryOperation::Fetch) && ss_page) {
      raise(page_fault_code, mode(), vaddr);
    }
    raise(page_fault_code, mode(), vaddr) if ;
    if ((pte_flags.A == 0) || pte_flags.D == 0) && ((op == MemoryOperation::Write) || (op == MemoryOperation::ReadModifyWrite)) {
      if (adue) {
        TranslationResult pte_phys = translate_gstage(pte_gpaddr, vaddr, MemoryOperation::Write, effective_mode, encoding);
        if (!pma_applies?(PmaAttribute::RsrvEventual, pte_phys.paddr, PTESIZE)) {
          raise(access_fault_code, effective_mode, vaddr);
        }
        if (!pma_applies?(PmaAttribute::HardwarePageTableWrite, pte_phys.paddr, PTESIZE)) {
          raise(access_fault_code, effective_mode, vaddr);
        }
        access_check(pte_phys.paddr, PTESIZE, vaddr, MemoryOperation::Write, access_fault_code, effective_mode);
        Boolean success;
        Bits<PTESIZE> updated_pte;
        if (pte_flags.D == 0 && (op == MemoryOperation::Write || op == MemoryOperation::ReadModifyWrite)) {
          updated_pte = pte | 0b11000000;
        } else {
          updated_pte = pte | 0b01000000;
        }
        if (PTESIZE == 32) {
          success = atomic_check_then_write_32(pte_phys.paddr, pte, updated_pte);
        } else if (PTESIZE == 64) {
          success = atomic_check_then_write_64(pte_phys.paddr, pte, updated_pte);
        } else {
          assert(false, "Unexpected PTESIZE");
          unreachable();
        }
        if (!success) {
          I = I + 1;
        } else {
          TranslationResult pte_phys = translate_gstage(paddr_base + offset, vaddr, op, effective_mode, encoding);
          result.paddr = pte_phys.paddr;
          if (xlen() == 64) {
            result.pbmt = pte_phys.pbmt == Pbmt::PMA ? $enum(Pbmt, pte[62:61]) : pte_phys.pbmt;
          }
          result.pte_flags = pte_flags;
          return result;
        }
      } else {
        raise(page_fault_code, mode(), vaddr);
      }
    }
    TranslationResult pte_phys = translate_gstage(paddr_base + offset, vaddr, op, effective_mode, encoding);
    result.paddr = pte_phys.paddr;
    if (xlen() == 64 && PTESIZE >= 64) {
      result.pbmt = pte_phys.pbmt == Pbmt::PMA ? $enum(Pbmt, pte[62:61]) : pte_phys.pbmt;
    }
    result.pte_flags = pte_flags;
    return result;
  } else {
    if (I == 0) {
      raise(page_fault_code, mode(), vaddr);
    }
    if (pte_flags.D == 1 || pte_flags.A == 1 || pte_flags.U == 1) {
      raise(page_fault_code, mode(), vaddr);
    }
    if ((xlen() == 64) && (VA_SIZE != 32) && (pte[62:61] != 0)) {
      raise(page_fault_code, mode(), vaddr);
    }
    if ((xlen() == 64) && (VA_SIZE != 32) && pte[63] != 0) {
      raise(page_fault_code, mode(), vaddr);
    }
    ppn = pte[PA_SIZE - 3:10];
  }
}
unreachable();

Boolean cached_translation_valid;
CachedTranslationResult cached_translation_result;
cached_translation_result = cached_translation(vaddr, op);
if (cached_translation_result.valid) {
  return cached_translation_result.result;
}
TranslationResult result;
if (effective_mode == PrivilegeMode::M) {
  result.paddr = vaddr;
  return result;
}
SatpMode translation_mode = current_translation_mode(effective_mode);
if (translation_mode == SatpMode::Reserved) {
  if (op == MemoryOperation::Read) {
    raise(ExceptionCode::LoadPageFault, mode(), vaddr);
  } else if (op == MemoryOperation::Write || op == MemoryOperation::ReadModifyWrite) {
    raise(ExceptionCode::StoreAmoPageFault, mode(), vaddr);
  } else {
    assert(op == MemoryOperation::Fetch, "Unexpected memory operation");
    raise(ExceptionCode::InstructionPageFault, mode(), vaddr);
  }
}
if (translation_mode == SatpMode::Bare) {
  result.paddr = vaddr;
} else if (xlen() == 32 && translation_mode == SatpMode::Sv32) {
  result = stage1_page_walk(32, 34, 32, 2, vaddr, op, effective_mode, encoding);
} else if (xlen() == 64 && translation_mode == SatpMode::Sv39) {
  result = stage1_page_walk(39, 56, 64, 3, vaddr, op, effective_mode, encoding);
} else if (xlen() == 64 && translation_mode == SatpMode::Sv48) {
  result = stage1_page_walk(48, 56, 64, 4, vaddr, op, effective_mode, encoding);
} else if (xlen() == 64 && translation_mode == SatpMode::Sv57) {
  result = stage1_page_walk(57, 56, 64, 5, vaddr, op, effective_mode, encoding);
} else {
  assert(false, "Unexpected SatpMode");
  unreachable();
}
maybe_cache_translation(vaddr, op, result);
return result;

Boolean cached_translation_valid;
CachedTranslationResult cached_translation_result;
cached_translation_result = cached_translation(vaddr, op);
if (cached_translation_result.valid) {
  return cached_translation_result.result;
}
TranslationResult result;
if (effective_mode == PrivilegeMode::M) {
  result.paddr = vaddr;
  return result;
}
SatpMode translation_mode = current_translation_mode(effective_mode);
if (translation_mode == SatpMode::Reserved) {
  if (op == MemoryOperation::Read) {
    raise(ExceptionCode::LoadPageFault, mode(), vaddr);
  } else if (op == MemoryOperation::Write || op == MemoryOperation::ReadModifyWrite) {
    raise(ExceptionCode::StoreAmoPageFault, mode(), vaddr);
  } else {
    assert(op == MemoryOperation::Fetch, "Unexpected memory operation");
    raise(ExceptionCode::InstructionPageFault, mode(), vaddr);
  }
}
if (translation_mode == SatpMode::Bare) {
  result.paddr = vaddr;
} else if (xlen() == 32 && translation_mode == SatpMode::Sv32) {
  result = stage1_page_walk(32, 34, 32, 2, vaddr, op, effective_mode, encoding);
} else if (xlen() == 64 && translation_mode == SatpMode::Sv39) {
  result = stage1_page_walk(39, 56, 64, 3, vaddr, op, effective_mode, encoding);
} else if (xlen() == 64 && translation_mode == SatpMode::Sv48) {
  result = stage1_page_walk(48, 56, 64, 4, vaddr, op, effective_mode, encoding);
} else if (xlen() == 64 && translation_mode == SatpMode::Sv57) {
  result = stage1_page_walk(57, 56, 64, 5, vaddr, op, effective_mode, encoding);
} else {
  assert(false, "Unexpected SatpMode");
  unreachable();
}
maybe_cache_translation(vaddr, op, result);
return result;

TranslationResult result;
if (CSR[misa].S == 1) {
  result = translate(virtual_address, MemoryOperation::Read, effective_ldst_mode(), encoding);
} else {
  result.paddr = virtual_address;
}
access_check(result.paddr, LEN, virtual_address, MemoryOperation::Read, ExceptionCode::LoadAccessFault, effective_ldst_mode());
if (rl == 1'b1) {
  memory_model_release();
}
XReg value = read_physical_memory(LEN, result.paddr);
if (aq == 1'b1) {
  memory_model_acquire();
}
return value;

TranslationResult result;
result = translate(virtual_address, MemoryOperation::Read, effective_ldst_mode(), encoding);
access_check(result.paddr, LEN, virtual_address, MemoryOperation::Read, ExceptionCode::LoadAccessFault, effective_ldst_mode());
if (rl == 1'b1) {
  memory_model_release();
}
XReg value = read_physical_memory(LEN, result.paddr);
if (aq == 1'b1) {
  memory_model_acquire();
}
return value;

Boolean aligned = is_naturally_aligned(LEN, virtual_address);
XReg physical_address;
if (aligned) {
  return read_memory_aligned(LEN, virtual_address, encoding, 1'b0, 1'b0);
}
if (MISALIGNED_MAX_ATOMICITY_GRANULE_SIZE > 0) {
  assert(MISALIGNED_LDST_EXCEPTION_PRIORITY == "low", "Invalid config: can't mix low-priority misaligned exceptions with large atomicity granule");
  physical_address = (CSR[misa].S == 1) ? translate(virtual_address, MemoryOperation::Read, effective_ldst_mode(), encoding).paddr : virtual_address;
  if (misaligned_is_atomic?(LEN, physical_address)) {
    access_check(physical_address, LEN, virtual_address, MemoryOperation::Read, ExceptionCode::LoadAccessFault, effective_ldst_mode());
    return read_physical_memory(LEN, physical_address);
  }
}
if (!MISALIGNED_LDST) {
  if (MISALIGNED_LDST_EXCEPTION_PRIORITY == "low") {
    physical_address = (CSR[misa].S == 1) ? translate(virtual_address, MemoryOperation::Read, effective_ldst_mode(), encoding).paddr : virtual_address;
    access_check(physical_address, LEN, virtual_address, MemoryOperation::Read, ExceptionCode::LoadAccessFault, effective_ldst_mode());
  }
  raise(ExceptionCode::LoadAddressMisaligned, mode(), virtual_address);
} else {
  if (MISALIGNED_SPLIT_STRATEGY == "sequential_bytes") {
    XReg result = 0;
    for (U32 I = 0; I < (LEN / 8); I++) {
      result = result | (read_memory_aligned(8, virtual_address + I, encoding, 1'b0, 1'b0) `<< (8 * I));
    }
    return result;
  } else if (MISALIGNED_SPLIT_STRATEGY == "custom") {
    unpredictable("An implementation is free to break a misaligned access any way, leading to unpredictable behavior when any part of the misaligned access causes an exception");
    return 0;
  }
}
return 0;

Boolean aligned = is_naturally_aligned(LEN, virtual_address);
XReg physical_address;
if (aligned) {
  return read_memory_aligned(LEN, virtual_address, encoding, 1'b0, 1'b0);
}

XReg result = 0;
for (U32 I = 0; I < (LEN / 8); I++) {
  result = result | (read_memory_aligned(8, virtual_address + I, encoding, 1'b0, 1'b0) `<< (8 * I));
}
return result;

if (len == 8) {
  write_physical_memory_8(paddr, value);
} else if (len == 16) {
  write_physical_memory_16(paddr, value);
} else if (len == 32) {
  write_physical_memory_32(paddr, value);
} else if (len == 64) {
  write_physical_memory_64(paddr, value);
} else {
  assert(false, "Invalid len");
}

if (len == 8) {
  write_physical_memory_8(paddr, value);
} else if (len == 16) {
  write_physical_memory_16(paddr, value);
} else if (len == 32) {
  write_physical_memory_32(paddr, value);
} else if (len == 64) {
  write_physical_memory_64(paddr, value);
} else {
  assert(false, "Invalid len");
}

XReg physical_address;
physical_address = (CSR[misa].S == 1) ? translate(virtual_address, MemoryOperation::Write, effective_ldst_mode(), encoding).paddr : virtual_address;
access_check(physical_address, LEN, virtual_address, MemoryOperation::Write, ExceptionCode::StoreAmoAccessFault, effective_ldst_mode());
if (rl == 1'b1) {
  memory_model_release();
}
write_physical_memory(LEN, physical_address, value);
if (aq == 1'b1) {
  memory_model_acquire();
}

XReg physical_address;
physical_address = translate(virtual_address, MemoryOperation::Write, effective_ldst_mode(), encoding).paddr;
access_check(physical_address, LEN, virtual_address, MemoryOperation::Write, ExceptionCode::StoreAmoAccessFault, effective_ldst_mode());
if (rl == 1'b1) {
  memory_model_release();
}
write_physical_memory(LEN, physical_address, value);
if (aq == 1'b1) {
  memory_model_acquire();
}

Boolean aligned = is_naturally_aligned(LEN, virtual_address);
XReg physical_address;
if (aligned) {
  write_memory_aligned(LEN, virtual_address, value, encoding, 1'b0, 1'b0);
  return ;
}
if (MISALIGNED_MAX_ATOMICITY_GRANULE_SIZE > 0) {
  assert(MISALIGNED_LDST_EXCEPTION_PRIORITY == "low", "Invalid config: can't mix low-priority misaligned exceptions with large atomicity granule");
  physical_address = (CSR[misa].S == 1) ? translate(virtual_address, MemoryOperation::Write, effective_ldst_mode(), encoding).paddr : virtual_address;
  if (misaligned_is_atomic?(LEN, physical_address)) {
    access_check(physical_address, LEN, virtual_address, MemoryOperation::Write, ExceptionCode::StoreAmoAccessFault, effective_ldst_mode());
    write_physical_memory(LEN, physical_address, value);
    return ;
  }
}
if (!MISALIGNED_LDST) {
  if (MISALIGNED_LDST_EXCEPTION_PRIORITY == "low") {
    physical_address = (CSR[misa].S == 1) ? translate(virtual_address, MemoryOperation::Write, effective_ldst_mode(), encoding).paddr : virtual_address;
    access_check(physical_address, LEN, virtual_address, MemoryOperation::Write, ExceptionCode::StoreAmoAccessFault, effective_ldst_mode());
  }
  raise(ExceptionCode::StoreAmoAddressMisaligned, mode(), virtual_address);
} else {
  if (MISALIGNED_SPLIT_STRATEGY == "sequential_bytes") {
    for (U32 I = 0; I < (LEN / 8); I++) {
      write_memory_aligned(8, virtual_address + I, (value >> (8 * I))[7:0], encoding, 1'b0, 1'b0);
    }
  } else if (MISALIGNED_SPLIT_STRATEGY == "custom") {
    unpredictable("An implementation is free to break a misaligned access any way, leading to unpredictable behavior when any part of the misaligned access causes an exception");
  }
}

Boolean aligned = is_naturally_aligned(LEN, virtual_address);
XReg physical_address;
if (aligned) {
  write_memory_aligned(LEN, virtual_address, value, encoding, 1'b0, 1'b0);
  return ;
}

for (U32 I = 0; I < (LEN / 8); I++) {
  write_memory_aligned(8, virtual_address + I, (value >> (8 * I))[7:0], encoding, 1'b0, 1'b0);
}

if (MUTABLE_MISA_F && CSR[misa].F == 0) {
  raise(ExceptionCode::IllegalInstruction, mode(), encoding);
}
if (CSR[mstatus].FS == 0) {
  raise(ExceptionCode::IllegalInstruction, mode(), encoding);
}

if (CSR[mstatus].FS == 0) {
  raise(ExceptionCode::IllegalInstruction, mode(), encoding);
}

if (rm == $bits(RoundingMode::RNE)) {
  return RoundingMode::RNE;
} else if (rm == $bits(RoundingMode::RTZ)) {
  return RoundingMode::RTZ;
} else if (rm == $bits(RoundingMode::RDN)) {
  return RoundingMode::RDN;
} else if (rm == $bits(RoundingMode::RUP)) {
  return RoundingMode::RUP;
} else if (rm == $bits(RoundingMode::RMM)) {
  return RoundingMode::RMM;
} else if (rm == $bits(RoundingMode::DYN)) {
  return $enum(RoundingMode, CSR[fcsr].FRM);
} else {
  raise(ExceptionCode::IllegalInstruction, mode(), encoding);
}

if (rm == $bits(RoundingMode::RNE)) {
  return RoundingMode::RNE;
} else if (rm == $bits(RoundingMode::RTZ)) {
  return RoundingMode::RTZ;
} else if (rm == $bits(RoundingMode::RDN)) {
  return RoundingMode::RDN;
} else if (rm == $bits(RoundingMode::RUP)) {
  return RoundingMode::RUP;
} else if (rm == $bits(RoundingMode::RMM)) {
  return RoundingMode::RMM;
} else if (rm == $bits(RoundingMode::DYN)) {
  return $enum(RoundingMode, CSR[fcsr].FRM);
} else {
  raise(ExceptionCode::IllegalInstruction, mode(), encoding);
}

return a[31];

return a[31];

return (sp_value[30:23] == 0b11111111) && (sp_value[22] == 0) && (sp_value[21:0] != 0);

return (sp_value[30:23] == 0b11111111) && (sp_value[22] == 0) && (sp_value[21:0] != 0);

return a[30:23];

return a[30:23];

return a[22:0];

return a[22:0];

return (sign `<< 31) + (exp `<< 23) + sig;

return (sign `<< 31) + (exp `<< 23) + sig;

Bits<8> roundIncrement = 0x40;
if ((mode != RoundingMode::RNE) && (mode != RoundingMode::RMM)) {
  roundIncrement = (mode == sign != 0) ? RoundingMode::RDN : RoundingMode::RUP ? 0x7F : 0;
}
Bits<8> roundBits = sig & 0x7f;
if (0xFD <= exp) {
  if ($signed(exp) < 's0) {
    Boolean isTiny = ($signed(exp) < -8's1) || (sig + roundIncrement < 0x80000000);
    sig = softfloat_shiftRightJam32(sig, -exp);
    exp = 0;
    roundBits = sig & 0x7F;
    if (isTiny && (roundBits != 0)) {
      set_fp_flag(FpFlag::UF);
    }
  } else if ('shFD < $signed(exp) || (0x80000000 <= sig + roundIncrement)) {
    set_fp_flag(FpFlag::OF);
    set_fp_flag(FpFlag::NX);
    return packToF32UI(sign, 0xFF, 0) - roundIncrement == 0) ? 1 : 0);   } } sig = (sig + roundIncrement) {
  sig = sig & ~32'b1;
}
if (sig == 0) {
  exp = 0;
}
return packToF32UI(sign, exp, sig);

Bits<8> roundIncrement = 0x40;
if ((mode != RoundingMode::RNE) && (mode != RoundingMode::RMM)) {
  roundIncrement = (mode == sign != 0) ? RoundingMode::RDN : RoundingMode::RUP ? 0x7F : 0;
}
Bits<8> roundBits = sig & 0x7f;
if (0xFD <= exp) {
  if ($signed(exp) < 's0) {
    Boolean isTiny = ($signed(exp) < 8'-1) || (sig + roundIncrement < 0x80000000);
    sig = softfloat_shiftRightJam32(sig, -exp);
    exp = 0;
    roundBits = sig & 0x7F;
    if (isTiny && (roundBits != 0)) {
      set_fp_flag(FpFlag::UF);
    }
  } else if ('shFD < $signed(exp) || (0x80000000 <= sig + roundIncrement)) {
    set_fp_flag(FpFlag::OF);
    set_fp_flag(FpFlag::NX);
    return packToF32UI(sign, 0xFF, 0) - roundIncrement == 0) ? 1 : 0);   } } sig = (sig + roundIncrement) {
  sig = sig & 32'hfffffffe;
}
if (sig == 0) {
  exp = 0;
}
return packToF32UI(sign, exp, sig);

if (is_sp_signaling_nan?(a) || is_sp_signaling_nan?(b)) {
  set_fp_flag(FpFlag::NV);
}
Bits<16> expA = expF32UI(a);
Bits<32> sigA = fracF32UI(a);
Bits<16> expB = expF32UI(b);
Bits<32> sigB = fracF32UI(b);
U32 sigZ;
U32 z;
Bits<1> signZ;
Bits<8> expZ;
Bits<16> expDiff = expA - expB;
if (expDiff == 16'd0) {
  if (expA == 8'd0) {
    z = a + b;
    return z;
  }
  if (expA == 8'hFF) {
    if ((sigA != 8'd0) || (sigB != 8'd0)) {
      return SP_CANONICAL_NAN;
    }
    return a;
  }
  signZ = signF32UI(a);
  expZ = expA;
  sigZ = 32'h01000000 + sigA + sigB;
  if (sigZ & 0x1) == 0) && (expZ < 8'hFE {
    sigZ = sigZ >> 1;
    return (32'h0 + (signZ << 31) + (expZ << 23) + sigZ);
  }
  sigZ = sigZ << 6;
} else {
  signZ = signF32UI(a);
  sigA = sigA << 6;
  sigB = sigB << 6;
  if ($signed(expDiff) < 0s) {
    if (expB == 8'hFF) {
      if (sigB != 0) {
        return SP_CANONICAL_NAN;
      }
      return packToF32UI(signZ, 8'hFF, 23'h0);
    }
    expZ = expB;
    sigA = (expA == 0) ? 2 * sigA : (sigA + 0x20000000);
    sigA = softfloat_shiftRightJam32(sigA, -expDiff);
  } else {
    if (expA == 8'hFF) {
      if (sigA != 0) {
        return SP_CANONICAL_NAN;
      }
      return a;
    }
    expZ = expA;
    sigB = (expB == 0) ? 2 * sigB : (sigB + 0x20000000);
    sigB = softfloat_shiftRightJam32(sigB, expDiff);
  }
  sigZ = 0x20000000 + sigA + sigB;
  if (sigZ < 0x40000000) {
    expZ = expZ - 1;
    sigZ = sigZ << 1;
  }
}
return softfloat_roundPackToF32(signZ, expZ, sigZ, mode);

if (is_sp_signaling_nan?(a) || is_sp_signaling_nan?(b)) {
  set_fp_flag(FpFlag::NV);
}
Bits<16> expA = expF32UI(a);
Bits<32> sigA = fracF32UI(a);
Bits<16> expB = expF32UI(b);
Bits<32> sigB = fracF32UI(b);
U32 sigZ;
U32 z;
Bits<1> signZ;
Bits<8> expZ;
Bits<16> expDiff = expA - expB;
if (expDiff == 16'd0) {
  if (expA == 8'd0) {
    z = a + b;
    return z;
  }
  if (expA == 8'hFF) {
    if ((sigA != 8'd0) || (sigB != 8'd0)) {
      return 32'h7fc00000;
    }
    return a;
  }
  signZ = signF32UI(a);
  expZ = expA;
  sigZ = 32'h01000000 + sigA + sigB;
  if (sigZ & 0x1) == 0) && (expZ < 8'hFE {
    sigZ = sigZ >> 1;
    return (32'h0 + (signZ << 31) + (expZ << 23) + sigZ);
  }
  sigZ = sigZ << 6;
} else {
  signZ = signF32UI(a);
  sigA = sigA << 6;
  sigB = sigB << 6;
  if ($signed(expDiff) < 0s) {
    if (expB == 8'hFF) {
      if (sigB != 0) {
        return 32'h7fc00000;
      }
      return packToF32UI(signZ, 8'hFF, 23'h0);
    }
    expZ = expB;
    sigA = (expA == 0) ? 2 * sigA : (sigA + 0x20000000);
    sigA = softfloat_shiftRightJam32(sigA, -expDiff);
  } else {
    if (expA == 8'hFF) {
      if (sigA != 0) {
        return 32'h7fc00000;
      }
      return a;
    }
    expZ = expA;
    sigB = (expB == 0) ? 2 * sigB : (sigB + 0x20000000);
    sigB = softfloat_shiftRightJam32(sigB, expDiff);
  }
  sigZ = 0x20000000 + sigA + sigB;
  if (sigZ < 0x40000000) {
    expZ = expZ - 1;
    sigZ = sigZ << 1;
  }
}
return softfloat_roundPackToF32(signZ, expZ, sigZ, mode);

U32 a_xor_b = a ^ b;
if (signF32UI(a_xor_b) == 1) {
  return softfloat_subMagsF32(a, b, mode);
} else {
  return softfloat_addMagsF32(a, b, mode);
}

U32 a_xor_b = a ^ b;
if (signF32UI(a_xor_b) == 1) {
  return softfloat_subMagsF32(a, b, mode);
} else {
  return softfloat_addMagsF32(a, b, mode);
}

if (HW_MSTATUS_FS_DIRTY_UPDATE == "precise") {
  CSR[mstatus].FS = 3;
} else if (HW_MSTATUS_FS_DIRTY_UPDATE == "imprecise") {
  unpredictable("The hart may or may not update mstatus.FS now");
}

CSR[mstatus].FS = 3;

return sp_value == SP_NEG_INF;

return sp_value == 32'hff800000;

return (sp_value[31] == 1) && (sp_value[30:23] != 0b11111111) && (sp_value[30:23] != 0b00000000);

return (sp_value[31] == 1) && (sp_value[30:23] != 0b11111111) && (sp_value[30:23] != 0b00000000);

return (sp_value[31] == 1) && (sp_value[30:23] == 0) && (sp_value[22:0] != 0);

return (sp_value[31] == 1) && (sp_value[30:23] == 0) && (sp_value[22:0] != 0);

return sp_value == SP_NEG_ZERO;

return sp_value == 32'h80000000;

return sp_value == SP_POS_ZERO;

return sp_value == 32'0;

return (sp_value[31] == 0) && (sp_value[30:23] == 0) && (sp_value[22:0] != 0);

return (sp_value[31] == 0) && (sp_value[30:23] == 0) && (sp_value[22:0] != 0);

return (sp_value[31] == 0) && (sp_value[30:23] != 0b11111111) && (sp_value[30:23] != 0b00000000);

return (sp_value[31] == 0) && (sp_value[30:23] != 0b11111111) && (sp_value[30:23] != 0b00000000);

return sp_value == SP_POS_INF;

return sp_value == 32'h7f800000;

return (sp_value[30:23] == 0b11111111) && (sp_value[22] == 1);

return (sp_value[30:23] == 0b11111111) && (sp_value[22] == 1);

if (flag == FpFlag::NX) {
  CSR[fcsr].NX = 1;
} else if (flag == FpFlag::UF) {
  CSR[fcsr].UF = 1;
} else if (flag == FpFlag::OF) {
  CSR[fcsr].OF = 1;
} else if (flag == FpFlag::DZ) {
  CSR[fcsr].DZ = 1;
} else if (flag == FpFlag::NV) {
  CSR[fcsr].NV = 1;
}

if (flag == FpFlag::NX) {
  CSR[fcsr].NX = 1;
} else if (flag == FpFlag::UF) {
  CSR[fcsr].UF = 1;
} else if (flag == FpFlag::OF) {
  CSR[fcsr].OF = 1;
} else if (flag == FpFlag::DZ) {
  CSR[fcsr].DZ = 1;
} else if (flag == FpFlag::NV) {
  CSR[fcsr].NV = 1;
}

TwoU64s z;
if (dist < 64) {
  z.u1 = a >> dist;
  z.u2 = a << (-dist & 63);
} else {
  z.u1 = 0;
  z.u2 = (dist == 64) ? a : ((a != 0) ? 1 : 0);
}
z.u2 = z.u2 | ((extra != 0) ? 1 : 0);
return z;

TwoU64s z;
if (dist < 64) {
  z.u1 = a >> dist;
  z.u2 = a << (-dist & 63);
} else {
  z.u1 = 0;
  z.u2 = (dist == 64) ? a : ((a != 0) ? 1 : 0);
}
z.u2 = z.u2 | ((extra != 0) ? 1 : 0);
return z;

Bits<64> z;
Boolean needs_increment = false;
if ((roundingMode == RoundingMode::RMM) || (roundingMode == RoundingMode::RNE)) {
  if (64'h8000000000000000 <= sigExtra) {
    needs_increment = true;
  }
} else {
  if ((sigExtra != 0) && sign != 0) ? (roundingMode == RoundingMode::RDN) : (roundingMode == RoundingMode::RUP) {
    needs_increment = true;
  }
}
if (needs_increment) {
  sig = sig + 1;
  if (sig == 0) {
    set_fp_flag(FpFlag::NV);
    return (sign == 1) ? I64_NEG_OVERFLOW : I64_POS_OVERFLOW;
  }
  if ((sigExtra == 64'h8000000000000000) && (roundingMode == RoundingMode::RNE)) {
    sig = sig & ~64'h1;
  }
}
z = (sign == 1) ? -sig : sig;
if ((z != 0) && (($signed(z) < 0s) ? 1 : 0) ^ sign) == 1 {
  set_fp_flag(FpFlag::NV);
  return (sign == 1) ? I64_NEG_OVERFLOW : I64_POS_OVERFLOW;
}
if (sigExtra != 0) {
  set_fp_flag(FpFlag::NX);
}
return z;

Bits<64> z;
Boolean needs_increment = false;
if ((roundingMode == RoundingMode::RMM) || (roundingMode == RoundingMode::RNE)) {
  if (64'h8000000000000000 <= sigExtra) {
    needs_increment = true;
  }
} else {
  if ((sigExtra != 0) && sign != 0) ? (roundingMode == RoundingMode::RDN) : (roundingMode == RoundingMode::RUP) {
    needs_increment = true;
  }
}
if (needs_increment) {
  sig = sig + 1;
  if (sig == 0) {
    set_fp_flag(FpFlag::NV);
    return (sign == 1) ? 64'h8000000000000000 : 64'h7fffffffffffffff;
  }
  if ((sigExtra == 64'h8000000000000000) && (roundingMode == RoundingMode::RNE)) {
    sig = sig & 64'hfffffffffffffffe;
  }
}
z = (sign == 1) ? -sig : sig;
if ((z != 0) && (($signed(z) < 0s) ? 1 : 0) ^ sign) == 1 {
  set_fp_flag(FpFlag::NV);
  return (sign == 1) ? 64'h8000000000000000 : 64'h7fffffffffffffff;
}
if (sigExtra != 0) {
  set_fp_flag(FpFlag::NX);
}
return z;

Bits<1> sign = signF32UI(a);
Bits<16> exp = expF32UI(a);
Bits<32> sig = fracF32UI(a);
Bits<16> shiftDist = 16'hBE - exp;
Bits<64> sig64;
Bits<64> extra;
if ($signed(shiftDist) < 0s) {
  set_fp_flag(FpFlag::NV);
  if ((exp == 16'hFF) && (sig != 0)) {
    return I64_NAN;
  } else {
    return (sign == 1) ? I64_NEG_OVERFLOW : I64_POS_OVERFLOW;
  }
}
if (exp != 0) {
  sig = sig | 32'h00800000;
}
sig64 = sig `<< 40;
extra = 0;
if (shiftDist != 0) {
  TwoU64s sig64Extra = softfloat_shiftRightJam64Extra(sig64, 0, $signed(shiftDist));
  sig64 = sig64Extra.u1;
  extra = sig64Extra.u2;
}
return softfloat_roundToI64(sign, sig64, extra, mode);

Bits<1> sign = signF32UI(a);
Bits<16> exp = expF32UI(a);
Bits<32> sig = fracF32UI(a);
Bits<16> shiftDist = 16'hBE - exp;
Bits<64> sig64;
Bits<64> extra;
if ($signed(shiftDist) < 0s) {
  set_fp_flag(FpFlag::NV);
  if ((exp == 16'hFF) && (sig != 0)) {
    return 64'h7fffffffffffffff;
  } else {
    return (sign == 1) ? 64'h8000000000000000 : 64'h7fffffffffffffff;
  }
}
if (exp != 0) {
  sig = sig | 32'h00800000;
}
sig64 = sig `<< 40;
extra = 0;
if (shiftDist != 0) {
  TwoU64s sig64Extra = softfloat_shiftRightJam64Extra(sig64, 0, $signed(shiftDist));
  sig64 = sig64Extra.u1;
  extra = sig64Extra.u2;
}
return softfloat_roundToI64(sign, sig64, extra, mode);

Boolean needs_increment = false;
if ((roundingMode == RoundingMode::RMM) || (roundingMode == RoundingMode::RNE)) {
  if (64'h8000000000000000 <= sigExtra) {
    needs_increment = true;
  }
} else {
  if (sign != 0) {
    if ((sig | sigExtra) == 0) {
      return 0;
    }
    if (roundingMode == RoundingMode::RDN) {
      set_fp_flag(FpFlag::NV);
      if (sign == 1) {
        return UI64_NEG_OVERFLOW;
      } else {
        return UI64_POS_OVERFLOW;
      }
    }
  } else {
    if ((roundingMode == RoundingMode::RUP) && (sigExtra != 0)) {
      needs_increment = true;
    }
  }
}
if (needs_increment) {
  sig = sig + 1;
  if (sig == 0) {
    set_fp_flag(FpFlag::NV);
    if (sign == 1) {
      return UI64_NEG_OVERFLOW;
    } else {
      return UI64_POS_OVERFLOW;
    }
  }
  if ((sigExtra == 64'h8000000000000000) && (roundingMode == RoundingMode::RNE)) {
    sig = sig & ~64'h1;
  }
}
if ((sign != 0) && (sig != 0)) {
  set_fp_flag(FpFlag::NV);
  if (sign == 1) {
    return UI64_NEG_OVERFLOW;
  } else {
    return UI64_POS_OVERFLOW;
  }
}
if (sigExtra != 0) {
  set_fp_flag(FpFlag::NX);
}
return sig;

Boolean needs_increment = false;
if ((roundingMode == RoundingMode::RMM) || (roundingMode == RoundingMode::RNE)) {
  if (64'h8000000000000000 <= sigExtra) {
    needs_increment = true;
  }
} else {
  if (sign != 0) {
    if ((sig | sigExtra) == 0) {
      return 0;
    }
    if (roundingMode == RoundingMode::RDN) {
      set_fp_flag(FpFlag::NV);
      if (sign == 1) {
        return 64'0;
      } else {
        return 64'hffffffffffffffff;
      }
    }
  } else {
    if ((roundingMode == RoundingMode::RUP) && (sigExtra != 0)) {
      needs_increment = true;
    }
  }
}
if (needs_increment) {
  sig = sig + 1;
  if (sig == 0) {
    set_fp_flag(FpFlag::NV);
    if (sign == 1) {
      return 64'0;
    } else {
      return 64'hffffffffffffffff;
    }
  }
  if ((sigExtra == 64'h8000000000000000) && (roundingMode == RoundingMode::RNE)) {
    sig = sig & 64'hfffffffffffffffe;
  }
}
if ((sign != 0) && (sig != 0)) {
  set_fp_flag(FpFlag::NV);
  if (sign == 1) {
    return 64'0;
  } else {
    return 64'hffffffffffffffff;
  }
}
if (sigExtra != 0) {
  set_fp_flag(FpFlag::NX);
}
return sig;

Bits<1> sign = signF32UI(a);
Bits<16> exp = expF32UI(a);
Bits<32> sig = fracF32UI(a);
Bits<16> shiftDist;
Bits<64> sig64, extra;
shiftDist = 16'hBE - exp;
if ($signed(shiftDist) < 0s) {
  set_fp_flag(FpFlag::NV);
  if ((exp == 0xFF) && (sig != 0)) {
    return UI64_NAN;
  } else if (sign != 0) {
    return UI64_NEG_OVERFLOW;
  } else {
    return UI64_POS_OVERFLOW;
  }
}
if (exp != 0) {
  sig = sig | 32'h00800000;
}
sig64 = sig `<< 40;
extra = 0;
if (shiftDist != 0) {
  TwoU64s sig64Extra = softfloat_shiftRightJam64Extra(sig64, 0, $signed(shiftDist));
  sig64 = sig64Extra.u1;
  extra = sig64Extra.u2;
}
return softfloat_roundToUI64(sign, sig64, extra, mode);

Bits<1> sign = signF32UI(a);
Bits<16> exp = expF32UI(a);
Bits<32> sig = fracF32UI(a);
Bits<16> shiftDist;
Bits<64> sig64, extra;
shiftDist = 16'hBE - exp;
if ($signed(shiftDist) < 0s) {
  set_fp_flag(FpFlag::NV);
  if ((exp == 0xFF) && (sig != 0)) {
    return 64'hffffffffffffffff;
  } else if (sign != 0) {
    return 64'0;
  } else {
    return 64'hffffffffffffffff;
  }
}
if (exp != 0) {
  sig = sig | 32'h00800000;
}
sig64 = sig `<< 40;
extra = 0;
if (shiftDist != 0) {
  TwoU64s sig64Extra = softfloat_shiftRightJam64Extra(sig64, 0, $signed(shiftDist));
  sig64 = sig64Extra.u1;
  extra = sig64Extra.u2;
}
return softfloat_roundToUI64(sign, sig64, extra, mode);

for (U32 i = 0; i < N; i++) {
  if (value[N - 1 - i] == 1) {
    return i;
  }
}
return N;

for (U32 i = 0; i < N; i++) {
  if (value[N - 1 - i] == 1) {
    return i;
  }
}
return N;

Bits<1> sign = a[63];
Bits<64> absA;
if (sign == 1) {
  absA = -a;
} else {
  absA = a;
}
Bits<8> shiftDist = count_leading_zeros(64, absA) - 40;
Bits<32> sig;
if ($signed(shiftDist) >= 0s) {
  if (a != 0) {
    return packToF32UI(sign, 16'h95 - shiftDist, absA << shiftDist);
  } else {
    return 0;
  }
} else {
  shiftDist = shiftDist + 7;
  if ($signed(shiftDist) < 0s) {
    sig = softfloat_shortShiftRightJam64(absA, -shiftDist);
  } else {
    sig = absA << shiftDist;
  }
  return softfloat_roundPackToF32(sign, 8'h9C - shiftDist, sig, mode);
}

Bits<1> sign = a[63];
Bits<64> absA;
if (sign == 1) {
  absA = -a;
} else {
  absA = a;
}
Bits<8> shiftDist = count_leading_zeros(64, absA) - 40;
Bits<32> sig;
if ($signed(shiftDist) >= 0s) {
  if (a != 0) {
    return packToF32UI(sign, 16'h95 - shiftDist, absA << shiftDist);
  } else {
    return 0;
  }
} else {
  shiftDist = shiftDist + 7;
  if ($signed(shiftDist) < 0s) {
    sig = softfloat_shortShiftRightJam64(absA, -shiftDist);
  } else {
    sig = absA << shiftDist;
  }
  return softfloat_roundPackToF32(sign, 8'h9C - shiftDist, sig, mode);
}

return a >> dist | (a & ((64'h1 << dist) - 1 != 0) ? 1 : 0);

return a >> dist | (a & ((64'h1 << dist) - 1 != 0) ? 1 : 0);

return (dist < 31) ? a >> dist | ((a[dist - 1:0] != 0) ? 1 : 0) : ((a != 0) ? 1 : 0);

return (dist < 31) ? a >> dist | ((a[dist - 1:0] != 0) ? 1 : 0) : ((a != 0) ? 1 : 0);

Bits<8> shiftDist = count_leading_zeros(64, a) - 40;
Bits<32> sig;
if (0s <= $signed(shiftDist)) {
  if (a != 0) {
    return packToF32UI(0, 8'h95 - shiftDist, a << shiftDist);
  } else {
    return 0;
  }
} else {
  shiftDist = shiftDist + 7;
  if ($signed(shiftDist) < 0s) {
    sig = softfloat_shortShiftRightJam64(a, -shiftDist);
  } else {
    sig = a << shiftDist;
  }
  return softfloat_roundPackToF32(0, 8'h9C - shiftDist, sig, mode);
}

Bits<8> shiftDist = count_leading_zeros(64, a) - 40;
Bits<32> sig;
if (0s <= $signed(shiftDist)) {
  if (a != 0) {
    return packToF32UI(0, 8'h95 - shiftDist, a << shiftDist);
  } else {
    return 0;
  }
} else {
  shiftDist = shiftDist + 7;
  if ($signed(shiftDist) < 0s) {
    sig = softfloat_shortShiftRightJam64(a, -shiftDist);
  } else {
    sig = a << shiftDist;
  }
  return softfloat_roundPackToF32(0, 8'h9C - shiftDist, sig, mode);
}

Bits<8> shiftDist = count_leading_zeros(32, sig) - 1;
exp = exp - shiftDist;
if ((7 <= shiftDist) && (exp < 0xFD)) {
  return packToF32UI(sign, (sig != 0) ? exp : 0, sig << (shiftDist - 7));
} else {
  return softfloat_roundPackToF32(sign, exp, sig << shiftDist, mode);
}

Bits<8> shiftDist = count_leading_zeros(32, sig) - 1;
exp = exp - shiftDist;
if ((7 <= shiftDist) && (exp < 0xFD)) {
  return packToF32UI(sign, (sig != 0) ? exp : 0, sig << (shiftDist - 7));
} else {
  return softfloat_roundPackToF32(sign, exp, sig << shiftDist, mode);
}

Bits<1> sign = a[31];
if ((a & 0x7FFFFFFF) == 0) {
  return (sign == 1) ? packToF32UI(1, 0x9E, 0) : packToF32UI(0, 0, 0);
}
U32 absA = (sign == 1) ? -a : a;
return softfloat_normRoundPackToF32(sign, 0x9C, absA, mode);

Bits<1> sign = a[31];
if ((a & 0x7FFFFFFF) == 0) {
  return (sign == 1) ? 32'hcf000000 : 32'0;
}
U32 absA = (sign == 1) ? -a : a;
return softfloat_normRoundPackToF32(sign, 0x9C, absA, mode);

if (a == 0) {
  return a;
}
if (a[31] == 1) {
  return softfloat_roundPackToF32(0, 0x9D, a >> 1 | (a & 1), mode);
} else {
  return softfloat_normRoundPackToF32(0, 0x9C, a, mode);
}

if (a == 0) {
  return a;
}
if (a[31] == 1) {
  return softfloat_roundPackToF32(0, 0x9D, a >> 1 | (a & 1), mode);
} else {
  return softfloat_normRoundPackToF32(0, 0x9C, a, mode);
}

Bits<16> roundIncrement = 0x800;
if ((roundingMode != RoundingMode::RMM) && (roundingMode != RoundingMode::RNE)) {
  roundIncrement = 0;
  if (sign == 1 ? (roundingMode == RoundingMode::RDN) : (roundingMode == RoundingMode::RUP)) {
    roundIncrement = 0xFFF;
  }
}
Bits<16> roundBits = sig & 0xFFF;
sig = sig + roundIncrement;
if ((sig & 0xFFFFF00000000000) != 0) {
  set_fp_flag(FpFlag::NV);
  return sign == 1 ? WORD_NEG_OVERFLOW : WORD_POS_OVERFLOW;
}
Bits<32> sig32 = sig >> 12;
if ((roundBits == 0x800 && (roundingMode == RoundingMode::RNE))) {
  sig32 = sig32 & ~32'b1;
}
Bits<32> z = (sign == 1) ? -sig32 : sig32;
if ((z != 0) && $signed(z) < 's0) != (sign == 1) {
  set_fp_flag(FpFlag::NV);
  return sign == 1 ? WORD_NEG_OVERFLOW : WORD_POS_OVERFLOW;
}
if (roundBits != 0) {
  set_fp_flag(FpFlag::NX);
}
return z;

Bits<16> roundIncrement = 0x800;
if ((roundingMode != RoundingMode::RMM) && (roundingMode != RoundingMode::RNE)) {
  roundIncrement = 0;
  if (sign == 1 ? (roundingMode == RoundingMode::RDN) : (roundingMode == RoundingMode::RUP)) {
    roundIncrement = 0xFFF;
  }
}
Bits<16> roundBits = sig & 0xFFF;
sig = sig + roundIncrement;
if ((sig & 0xFFFFF00000000000) != 0) {
  set_fp_flag(FpFlag::NV);
  return sign == 1 ? 32'h80000000 : 32'h7fffffff;
}
Bits<32> sig32 = sig >> 12;
if ((roundBits == 0x800 && (roundingMode == RoundingMode::RNE))) {
  sig32 = sig32 & 32'hfffffffe;
}
Bits<32> z = (sign == 1) ? -sig32 : sig32;
if ((z != 0) && $signed(z) < 's0) != (sign == 1) {
  set_fp_flag(FpFlag::NV);
  return sign == 1 ? 32'h80000000 : 32'h7fffffff;
}
if (roundBits != 0) {
  set_fp_flag(FpFlag::NX);
}
return z;

Bits<1> sign = signF32UI(a);
Bits<16> exp = expF32UI(a);
Bits<32> sig = fracF32UI(a);
Bits<16> shiftDist;
U64 sig64;
if ((exp == 8'hFF) && (sig != 0)) {
  sign = 0;
  set_fp_flag(FpFlag::NV);
  return I32_NAN;
}
if (exp != 0) {
  sig = sig | 32'h00800000;
}
sig64 = sig `<< 32;
shiftDist = 8'hAA - exp;
if ($signed(shiftDist) > 0s) {
  sig64 = softfloat_shiftRightJam64(sig64, shiftDist);
}
return softfloat_roundToI32(sign, sig64, mode);

Bits<1> sign = signF32UI(a);
Bits<16> exp = expF32UI(a);
Bits<32> sig = fracF32UI(a);
Bits<16> shiftDist;
U64 sig64;
if ((exp == 8'hFF) && (sig != 0)) {
  sign = 0;
  set_fp_flag(FpFlag::NV);
  return 32'h7fffffff;
}
if (exp != 0) {
  sig = sig | 32'h00800000;
}
sig64 = sig `<< 32;
shiftDist = 8'hAA - exp;
if ($signed(shiftDist) > 0s) {
  sig64 = softfloat_shiftRightJam64(sig64, shiftDist);
}
return softfloat_roundToI32(sign, sig64, mode);

Bits<16> roundIncrement = 0x800;
if ((roundingMode != RoundingMode::RMM) && (roundingMode != RoundingMode::RNE)) {
  roundIncrement = 0;
  if (sign == 1) {
    if (sig == 0) {
      return 0;
    }
    if (roundingMode == RoundingMode::RDN) {
      set_fp_flag(FpFlag::NV);
    }
  } else {
    if (roundingMode == RoundingMode::RUP) {
      roundIncrement = 0xFFF;
    }
  }
}
Bits<16> roundBits = sig & 0xFFF;
sig = sig + roundIncrement;
if ((sig & 0xFFFFF00000000000) != 0) {
  set_fp_flag(FpFlag::NV);
  return sign == 1 ? UI32_NEG_OVERFLOW : UI32_POS_OVERFLOW;
}
Bits<32> z = sig >> 12;
if ((roundBits == 0x800 && (roundingMode == RoundingMode::RNE))) {
  z = z & ~32'b1;
}
if ((z != 0) && (sign == 1)) {
  set_fp_flag(FpFlag::NV);
  return sign == 1 ? UI32_NEG_OVERFLOW : UI32_POS_OVERFLOW;
}
if (roundBits != 0) {
  set_fp_flag(FpFlag::NX);
}
return z;

Bits<16> roundIncrement = 0x800;
if ((roundingMode != RoundingMode::RMM) && (roundingMode != RoundingMode::RNE)) {
  roundIncrement = 0;
  if (sign == 1) {
    if (sig == 0) {
      return 0;
    }
    if (roundingMode == RoundingMode::RDN) {
      set_fp_flag(FpFlag::NV);
    }
  } else {
    if (roundingMode == RoundingMode::RUP) {
      roundIncrement = 0xFFF;
    }
  }
}
Bits<16> roundBits = sig & 0xFFF;
sig = sig + roundIncrement;
if ((sig & 0xFFFFF00000000000) != 0) {
  set_fp_flag(FpFlag::NV);
  return sign == 1 ? 32'0 : 32'hffffffff;
}
Bits<32> z = sig >> 12;
if ((roundBits == 0x800 && (roundingMode == RoundingMode::RNE))) {
  z = z & 32'hfffffffe;
}
if ((z != 0) && (sign == 1)) {
  set_fp_flag(FpFlag::NV);
  return sign == 1 ? 32'0 : 32'hffffffff;
}
if (roundBits != 0) {
  set_fp_flag(FpFlag::NX);
}
return z;

Bits<1> sign = signF32UI(a);
Bits<16> exp = expF32UI(a);
Bits<32> sig = fracF32UI(a);
Bits<16> shiftDist;
U64 sig64;
if ((exp == 8'hFF) && (sig != 0)) {
  sign = 0;
  set_fp_flag(FpFlag::NV);
  return UI32_NAN;
}
if (exp != 0) {
  sig = sig | 32'h00800000;
}
sig64 = sig `<< 32;
shiftDist = 8'hAA - exp;
if ($signed(shiftDist) > 0s) {
  sig64 = softfloat_shiftRightJam64(sig64, shiftDist);
}
return softfloat_roundToUI32(sign, sig64, mode);

Bits<1> sign = signF32UI(a);
Bits<16> exp = expF32UI(a);
Bits<32> sig = fracF32UI(a);
Bits<16> shiftDist;
U64 sig64;
if ((exp == 8'hFF) && (sig != 0)) {
  sign = 0;
  set_fp_flag(FpFlag::NV);
  return 32'hffffffff;
}
if (exp != 0) {
  sig = sig | 32'h00800000;
}
sig64 = sig `<< 32;
shiftDist = 8'hAA - exp;
if ($signed(shiftDist) > 0s) {
  sig64 = softfloat_shiftRightJam64(sig64, shiftDist);
}
return softfloat_roundToUI32(sign, sig64, mode);

Bits<16> shiftDist = count_leading_zeros(32, sig) - 8;
ExpAndSig ret;
ret.exp = 1 - shiftDist;
ret.sig = sig << shiftDist;
return ret;

Bits<16> shiftDist = count_leading_zeros(32, sig) - 8;
ExpAndSig ret;
ret.exp = 1 - shiftDist;
ret.sig = sig << shiftDist;
return ret;

Bits<64> a64 = {32'h0, a};
Bits<64> a_top = a64 << 31;
Bits<64> rem = 64'h7FFFFFFFFFFFFFFF;
Bits<32> q = 0;
for (U32 i = 0; i < 32; i++) {
  Bits<64> d = a_top >> i;
  if (rem >= d) {
    q = q | (32'h1 << (31 - i));
    rem = rem - d;
  }
}
return q;

Bits<64> a64 = {32'h0, a};
Bits<64> a_top = a64 << 31;
Bits<64> rem = 64'h7FFFFFFFFFFFFFFF;
Bits<32> q = 0;
for (U32 i = 0; i < 32; i++) {
  Bits<64> d = a_top >> i;
  if (rem >= d) {
    q = q | (32'h1 << (31 - i));
    rem = rem - d;
  }
}
return q;

if (is_sp_signaling_nan?(a) || is_sp_signaling_nan?(b)) {
  set_fp_flag(FpFlag::NV);
}
Bits<1> signA = signF32UI(a);
Bits<16> expA = expF32UI(a);
Bits<32> sigA = fracF32UI(a);
Bits<1> signB = signF32UI(b);
Bits<16> expB = expF32UI(b);
Bits<32> sigB = fracF32UI(b);
Bits<1> signZ = signA ^ signB;
Bits<16> expZ;
if (expA == 8'hFF) {
  if (sigA != 0) {
    return SP_CANONICAL_NAN;
  }
  if (expB == 8'hFF) {
    if (sigB != 0) {
      return SP_CANONICAL_NAN;
    }
    set_fp_flag(FpFlag::NV);
    return SP_CANONICAL_NAN;
  }
  return packToF32UI(signZ, 8'hFF, 0);
}
if (expB == 8'hFF) {
  if (sigB != 0) {
    return SP_CANONICAL_NAN;
  }
  return packToF32UI(signZ, 0, 0);
}
if (expB == 0) {
  if (sigB == 0) {
    if ((expA == 0) && (sigA == 0)) {
      set_fp_flag(FpFlag::NV);
      return SP_CANONICAL_NAN;
    }
    set_fp_flag(FpFlag::DZ);
    return packToF32UI(signZ, 8'hFF, 0);
  }
  ExpAndSig norm = softfloat_normSubnormalF32Sig(sigB);
  expB = norm.exp;
  sigB = norm.sig;
}
if (expA == 0) {
  if (sigA == 0) {
    return packToF32UI(signZ, 0, 0);
  }
  ExpAndSig norm = softfloat_normSubnormalF32Sig(sigA);
  expA = norm.exp;
  sigA = norm.sig;
}
expZ = expA - expB + 16'h007E;
sigA = sigA | 32'h00800000;
sigB = sigB | 32'h00800000;
if (sigA < sigB) {
  expZ = expZ - 1;
  sigA = sigA << 8;
} else {
  sigA = sigA << 7;
}
sigB = sigB << 8;
Bits<32> recip32 = softfloat_approxRecip32_1(sigB);
Bits<32> sigZ = (sigA `* recip32) >> 32;
sigZ = sigZ + 2;
if ((sigZ & 7) <= 2) {
  sigZ = sigZ & ~32'h3;
  Bits<64> rem = (sigA `<< 31) - (sigZ `* sigB);
  if ((rem & 64'h8000000000000000) != 0) {
    sigZ = sigZ - 4;
  } else {
    if (rem != 0) {
      sigZ = sigZ | 1;
    }
  }
}
return softfloat_roundPackToF32(signZ, expZ, sigZ, mode);

if (is_sp_signaling_nan?(a) || is_sp_signaling_nan?(b)) {
  set_fp_flag(FpFlag::NV);
}
Bits<1> signA = signF32UI(a);
Bits<16> expA = expF32UI(a);
Bits<32> sigA = fracF32UI(a);
Bits<1> signB = signF32UI(b);
Bits<16> expB = expF32UI(b);
Bits<32> sigB = fracF32UI(b);
Bits<1> signZ = signA ^ signB;
Bits<16> expZ;
if (expA == 8'hFF) {
  if (sigA != 0) {
    return 32'h7fc00000;
  }
  if (expB == 8'hFF) {
    if (sigB != 0) {
      return 32'h7fc00000;
    }
    set_fp_flag(FpFlag::NV);
    return 32'h7fc00000;
  }
  return packToF32UI(signZ, 8'hFF, 0);
}
if (expB == 8'hFF) {
  if (sigB != 0) {
    return 32'h7fc00000;
  }
  return packToF32UI(signZ, 0, 0);
}
if (expB == 0) {
  if (sigB == 0) {
    if ((expA == 0) && (sigA == 0)) {
      set_fp_flag(FpFlag::NV);
      return 32'h7fc00000;
    }
    set_fp_flag(FpFlag::DZ);
    return packToF32UI(signZ, 8'hFF, 0);
  }
  ExpAndSig norm = softfloat_normSubnormalF32Sig(sigB);
  expB = norm.exp;
  sigB = norm.sig;
}
if (expA == 0) {
  if (sigA == 0) {
    return packToF32UI(signZ, 0, 0);
  }
  ExpAndSig norm = softfloat_normSubnormalF32Sig(sigA);
  expA = norm.exp;
  sigA = norm.sig;
}
expZ = expA - expB + 16'h007E;
sigA = sigA | 32'h00800000;
sigB = sigB | 32'h00800000;
if (sigA < sigB) {
  expZ = expZ - 1;
  sigA = sigA << 8;
} else {
  sigA = sigA << 7;
}
sigB = sigB << 8;
Bits<32> recip32 = softfloat_approxRecip32_1(sigB);
Bits<32> sigZ = (sigA `* recip32) >> 32;
sigZ = sigZ + 2;
if ((sigZ & 7) <= 2) {
  sigZ = sigZ & 32'hfffffffc;
  Bits<64> rem = (sigA `<< 31) - (sigZ `* sigB);
  if ((rem & 64'h8000000000000000) != 0) {
    sigZ = sigZ - 4;
  } else {
    if (rem != 0) {
      sigZ = sigZ | 1;
    }
  }
}
return softfloat_roundPackToF32(signZ, expZ, sigZ, mode);

return (sp_value[30:23] == 0b11111111) && (sp_value[22:0] != 0);

return (sp_value[30:23] == 0b11111111) && (sp_value[22:0] != 0);

assert(FROM_SIZE < TO_SIZE, "Bad arguments; FROM_SIZE must be less than TO_SIZE");
return {{TO_SIZE - FROM_SIZE{1'b1}}, from_value};

assert(FROM_SIZE < TO_SIZE, "Bad arguments; FROM_SIZE must be less than TO_SIZE");
return {{TO_SIZE - FROM_SIZE{1'b1}}, from_value};

return (dist < 63) ? a >> dist | ((a[dist - 1:0] != 0) ? 1 : 0) : ((a != 0) ? 1 : 0);

return (dist < 63) ? a >> dist | ((a[dist - 1:0] != 0) ? 1 : 0) : ((a != 0) ? 1 : 0);

for (U32 i = 0; i < N; i++) {
  if (value[N - 1 - i] == 1) {
    return i;
  }
}
return N;

for (U32 i = 0; i < N; i++) {
  if (value[N - 1 - i] == 1) {
    return i;
  }
}
return N;

if (is_sp_signaling_nan?(a) || is_sp_signaling_nan?(b) || is_sp_signaling_nan?(c)) {
  set_fp_flag(FpFlag::NV);
}
Bits<1> signA = signF32UI(a);
Bits<16> expA = expF32UI(a);
Bits<32> sigA = fracF32UI(a);
Bits<1> signB = signF32UI(b);
Bits<16> expB = expF32UI(b);
Bits<32> sigB = fracF32UI(b);
Bits<1> signC = signF32UI(c) ^ op == F32MulAddOp::Softfloat_mulAdd_subC) ? 1 : 0); Bits<16> expC = expF32UI(c); Bits<32> sigC = fracF32UI(c); Bits<1> signProd = (signA ^ signB) ^ ((op == F32MulAddOp::Softfloat_mulAdd_subProd) ? 1 : 0); Bits<32> magBits; Bits<64> sig64Z; if (expA == 0xFF) {   if ((sigA != 0) || ((expB == 0xFF) && (sigB != 0) {
    return SP_CANONICAL_NAN;
  }
  magBits = expB | sigB;
  if (magBits != 0) {
    U32 zA = packToF32UI(signProd, 0xFF, 0);
    if (expC != 0xFF) {
      return zA;
    }
    if (sigC != 0) {
      return SP_CANONICAL_NAN;
    }
    if (signProd == signC) {
      return zA;
    }
  }
  set_fp_flag(FpFlag::NV);
  return SP_CANONICAL_NAN;
}
if (expB == 0xFF) {
  if (sigB != 0) {
    return SP_CANONICAL_NAN;
  }
  magBits = expA | sigA;
  if (magBits != 0) {
    U32 zB = packToF32UI(signProd, 0xFF, 0);
    if (expC != 0xFF) {
      return zB;
    }
    if (sigC != 0) {
      return SP_CANONICAL_NAN;
    }
    if (signProd == signC) {
      return zB;
    }
  }
  set_fp_flag(FpFlag::NV);
  return SP_CANONICAL_NAN;
}
if (expC == 0xFF) {
  if (sigC != 0) {
    return SP_CANONICAL_NAN;
  }
  return c;
}
if (expA == 0) {
  if (sigA == 0) {
    if (expC | sigC) == 0) && (signProd != signC {
      return packToF32UI((mode == RoundingMode::RDN) ? 1 : 0, 0, 0);
    }
    return c;
  }
  ExpAndSig norm = softfloat_normSubnormalF32Sig(sigA);
  expA = norm.exp;
  sigA = norm.sig;
}
if (expB == 0) {
  if (sigB == 0) {
    if (expC | sigC) == 0) && (signProd != signC {
      return packToF32UI((mode == RoundingMode::RDN) ? 1 : 0, 0, 0);
    }
    return c;
  }
  ExpAndSig norm = softfloat_normSubnormalF32Sig(sigB);
  expB = norm.exp;
  sigB = norm.sig;
}
Bits<16> expProd = expA + expB - 16'h007E;
sigA = (sigA | 32'h00800000) << 7;
sigB = (sigB | 32'h00800000) << 7;
U64 sigProd = sigA `* sigB;
if (sigProd < 64'h2000000000000000) {
  expProd = expProd - 1;
  sigProd = sigProd << 1;
}
Bits<1> signZ = signProd;
Bits<16> expZ;
Bits<32> sigZ;
if (expC == 0) {
  if (sigC == 0) {
    expZ = expProd - 1;
    sigZ = softfloat_shiftRightJam64(sigProd, 31);
    return softfloat_roundPackToF32(signZ, expZ, sigZ, mode);
  }
  ExpAndSig norm = softfloat_normSubnormalF32Sig(sigC);
  expC = norm.exp;
  sigC = norm.sig;
}
sigC = (sigC | 0x00800000) << 6;
Bits<16> expDiff = expProd - expC;
if (signProd == signC) {
  if ($signed(expDiff) <= 0s) {
    expZ = expC;
    sigZ = sigC + softfloat_shiftRightJam64(sigProd, 32 - expDiff);
  } else {
    expZ = expProd;
    sig64Z = sigProd + softfloat_shiftRightJam64(sigC `<< 32, expDiff);
    sigZ = softfloat_shiftRightJam64(sig64Z, 32);
  }
  if (sigZ < 0x40000000) {
    expZ = expZ - 1;
    sigZ = sigZ << 1;
  }
  return softfloat_roundPackToF32(signZ, expZ, sigZ, mode);
} else {
  U64 sig64C = sigC `<< 32;
  if ($signed(expDiff) < 0s) {
    signZ = signC;
    expZ = expC;
    sig64Z = sig64C - softfloat_shiftRightJam64(sigProd, -expDiff);
  } else if (expDiff == 0) {
    expZ = expProd;
    sig64Z = sigProd - sig64C;
    if (sig64Z == 0) {
      return packToF32UI((mode == RoundingMode::RDN) ? 1 : 0, 0, 0);
    }
    if ((sig64Z & 64'h8000000000000000) != 0) {
      signZ = signZ ^ 1;
      sig64Z = -sig64Z;
    }
  } else {
    expZ = expProd;
    sig64Z = sigProd - softfloat_shiftRightJam64(sig64C, expDiff);
  }
  Bits<8> shiftDist = count_leading_zeros_64(64, sig64Z) - 1;
  expZ = expZ - shiftDist;
  shiftDist = shiftDist - 8'h20;
  if ($signed(shiftDist) < 0s) {
    sigZ = softfloat_shiftRightJam64(sig64Z, -shiftDist);
  } else {
    sigZ = sig64Z << shiftDist;
  }
  return softfloat_roundPackToF32(signZ, expZ, sigZ, mode);
}

if (is_sp_signaling_nan?(a) || is_sp_signaling_nan?(b) || is_sp_signaling_nan?(c)) {
  set_fp_flag(FpFlag::NV);
}
Bits<1> signA = signF32UI(a);
Bits<16> expA = expF32UI(a);
Bits<32> sigA = fracF32UI(a);
Bits<1> signB = signF32UI(b);
Bits<16> expB = expF32UI(b);
Bits<32> sigB = fracF32UI(b);
Bits<1> signC = signF32UI(c) ^ op == F32MulAddOp::Softfloat_mulAdd_subC) ? 1 : 0); Bits<16> expC = expF32UI(c); Bits<32> sigC = fracF32UI(c); Bits<1> signProd = (signA ^ signB) ^ ((op == F32MulAddOp::Softfloat_mulAdd_subProd) ? 1 : 0); Bits<32> magBits; Bits<64> sig64Z; if (expA == 0xFF) {   if ((sigA != 0) || ((expB == 0xFF) && (sigB != 0) {
    return 32'h7fc00000;
  }
  magBits = expB | sigB;
  if (magBits != 0) {
    U32 zA = packToF32UI(signProd, 0xFF, 0);
    if (expC != 0xFF) {
      return zA;
    }
    if (sigC != 0) {
      return 32'h7fc00000;
    }
    if (signProd == signC) {
      return zA;
    }
  }
  set_fp_flag(FpFlag::NV);
  return 32'h7fc00000;
}
if (expB == 0xFF) {
  if (sigB != 0) {
    return 32'h7fc00000;
  }
  magBits = expA | sigA;
  if (magBits != 0) {
    U32 zB = packToF32UI(signProd, 0xFF, 0);
    if (expC != 0xFF) {
      return zB;
    }
    if (sigC != 0) {
      return 32'h7fc00000;
    }
    if (signProd == signC) {
      return zB;
    }
  }
  set_fp_flag(FpFlag::NV);
  return 32'h7fc00000;
}
if (expC == 0xFF) {
  if (sigC != 0) {
    return 32'h7fc00000;
  }
  return c;
}
if (expA == 0) {
  if (sigA == 0) {
    if (expC | sigC) == 0) && (signProd != signC {
      return packToF32UI((mode == RoundingMode::RDN) ? 1 : 0, 0, 0);
    }
    return c;
  }
  ExpAndSig norm = softfloat_normSubnormalF32Sig(sigA);
  expA = norm.exp;
  sigA = norm.sig;
}
if (expB == 0) {
  if (sigB == 0) {
    if (expC | sigC) == 0) && (signProd != signC {
      return packToF32UI((mode == RoundingMode::RDN) ? 1 : 0, 0, 0);
    }
    return c;
  }
  ExpAndSig norm = softfloat_normSubnormalF32Sig(sigB);
  expB = norm.exp;
  sigB = norm.sig;
}
Bits<16> expProd = expA + expB - 16'h007E;
sigA = (sigA | 32'h00800000) << 7;
sigB = (sigB | 32'h00800000) << 7;
U64 sigProd = sigA `* sigB;
if (sigProd < 64'h2000000000000000) {
  expProd = expProd - 1;
  sigProd = sigProd << 1;
}
Bits<1> signZ = signProd;
Bits<16> expZ;
Bits<32> sigZ;
if (expC == 0) {
  if (sigC == 0) {
    expZ = expProd - 1;
    sigZ = softfloat_shiftRightJam64(sigProd, 31);
    return softfloat_roundPackToF32(signZ, expZ, sigZ, mode);
  }
  ExpAndSig norm = softfloat_normSubnormalF32Sig(sigC);
  expC = norm.exp;
  sigC = norm.sig;
}
sigC = (sigC | 0x00800000) << 6;
Bits<16> expDiff = expProd - expC;
if (signProd == signC) {
  if ($signed(expDiff) <= 0s) {
    expZ = expC;
    sigZ = sigC + softfloat_shiftRightJam64(sigProd, 32 - expDiff);
  } else {
    expZ = expProd;
    sig64Z = sigProd + softfloat_shiftRightJam64(sigC `<< 32, expDiff);
    sigZ = softfloat_shiftRightJam64(sig64Z, 32);
  }
  if (sigZ < 0x40000000) {
    expZ = expZ - 1;
    sigZ = sigZ << 1;
  }
  return softfloat_roundPackToF32(signZ, expZ, sigZ, mode);
} else {
  U64 sig64C = sigC `<< 32;
  if ($signed(expDiff) < 0s) {
    signZ = signC;
    expZ = expC;
    sig64Z = sig64C - softfloat_shiftRightJam64(sigProd, -expDiff);
  } else if (expDiff == 0) {
    expZ = expProd;
    sig64Z = sigProd - sig64C;
    if (sig64Z == 0) {
      return packToF32UI((mode == RoundingMode::RDN) ? 1 : 0, 0, 0);
    }
    if ((sig64Z & 64'h8000000000000000) != 0) {
      signZ = signZ ^ 1;
      sig64Z = -sig64Z;
    }
  } else {
    expZ = expProd;
    sig64Z = sigProd - softfloat_shiftRightJam64(sig64C, expDiff);
  }
  Bits<8> shiftDist = count_leading_zeros_64(64, sig64Z) - 1;
  expZ = expZ - shiftDist;
  shiftDist = shiftDist - 8'h20;
  if ($signed(shiftDist) < 0s) {
    sigZ = softfloat_shiftRightJam64(sig64Z, -shiftDist);
  } else {
    sigZ = sig64Z << shiftDist;
  }
  return softfloat_roundPackToF32(signZ, expZ, sigZ, mode);
}

if (is_sp_signaling_nan?(a) || is_sp_signaling_nan?(b)) {
  set_fp_flag(FpFlag::NV);
}
Bits<1> signA = signF32UI(a);
Bits<16> expA = expF32UI(a);
Bits<23> fracA = fracF32UI(a);
Bits<1> signB = signF32UI(b);
Bits<16> expB = expF32UI(b);
Bits<23> fracB = fracF32UI(b);
Bits<1> signZ = signA ^ signB;
Bits<32> sigA = fracA;
Bits<32> sigB = fracB;
Bits<16> expZ;
Bits<32> sigZ;
if (expA == 8'hFF) {
  if ((fracA != 0) || expB == 8'hFF) && (fracB != 0) {
    return SP_CANONICAL_NAN;
  }
  if ((expB == 0) && (fracB == 0)) {
    set_fp_flag(FpFlag::NV);
    return SP_CANONICAL_NAN;
  }
  return packToF32UI(signZ, 8'hFF, 0);
}
if (expB == 8'hFF) {
  if (fracB != 0) {
    return SP_CANONICAL_NAN;
  }
  if ((expA == 0) && (fracA == 0)) {
    set_fp_flag(FpFlag::NV);
    return SP_CANONICAL_NAN;
  }
  return packToF32UI(signZ, 8'hFF, 0);
}
if (expA == 0) {
  if (fracA == 0) {
    return packToF32UI(signZ, 0, 0);
  }
  ExpAndSig norm = softfloat_normSubnormalF32Sig(fracA);
  expA = norm.exp;
  sigA = norm.sig;
}
if (expB == 0) {
  if (fracB == 0) {
    return packToF32UI(signZ, 0, 0);
  }
  ExpAndSig norm = softfloat_normSubnormalF32Sig(fracB);
  expB = norm.exp;
  sigB = norm.sig;
}
expZ = expA + expB - 16'h007F;
sigA = (sigA | 32'h00800000) << 7;
sigB = (sigB | 32'h00800000) << 8;
sigZ = softfloat_shiftRightJam64(sigA `* sigB, 32);
if (sigZ < 0x40000000) {
  expZ = expZ - 1;
  sigZ = sigZ << 1;
}
return softfloat_roundPackToF32(signZ, expZ, sigZ, mode);

if (is_sp_signaling_nan?(a) || is_sp_signaling_nan?(b)) {
  set_fp_flag(FpFlag::NV);
}
Bits<1> signA = signF32UI(a);
Bits<16> expA = expF32UI(a);
Bits<23> fracA = fracF32UI(a);
Bits<1> signB = signF32UI(b);
Bits<16> expB = expF32UI(b);
Bits<23> fracB = fracF32UI(b);
Bits<1> signZ = signA ^ signB;
Bits<32> sigA = fracA;
Bits<32> sigB = fracB;
Bits<16> expZ;
Bits<32> sigZ;
if (expA == 8'hFF) {
  if ((fracA != 0) || expB == 8'hFF) && (fracB != 0) {
    return 32'h7fc00000;
  }
  if ((expB == 0) && (fracB == 0)) {
    set_fp_flag(FpFlag::NV);
    return 32'h7fc00000;
  }
  return packToF32UI(signZ, 8'hFF, 0);
}
if (expB == 8'hFF) {
  if (fracB != 0) {
    return 32'h7fc00000;
  }
  if ((expA == 0) && (fracA == 0)) {
    set_fp_flag(FpFlag::NV);
    return 32'h7fc00000;
  }
  return packToF32UI(signZ, 8'hFF, 0);
}
if (expA == 0) {
  if (fracA == 0) {
    return packToF32UI(signZ, 0, 0);
  }
  ExpAndSig norm = softfloat_normSubnormalF32Sig(fracA);
  expA = norm.exp;
  sigA = norm.sig;
}
if (expB == 0) {
  if (fracB == 0) {
    return packToF32UI(signZ, 0, 0);
  }
  ExpAndSig norm = softfloat_normSubnormalF32Sig(fracB);
  expB = norm.exp;
  sigB = norm.sig;
}
expZ = expA + expB - 16'h007F;
sigA = (sigA | 32'h00800000) << 7;
sigB = (sigB | 32'h00800000) << 8;
sigZ = softfloat_shiftRightJam64(sigA `* sigB, 32);
if (sigZ < 0x40000000) {
  expZ = expZ - 1;
  sigZ = sigZ << 1;
}
return softfloat_roundPackToF32(signZ, expZ, sigZ, mode);

Bits<8> index = a;
r = r + ((adj `* sqrSigma0) >> 48);
if ((r & 32'h80000000) == 0) {
  r = 32'h80000000;
}
return r;

Bits<8> index = a;
r = r + ((adj `* sqrSigma0) >> 48);
if ((r & 32'h80000000) == 0) {
  r = 32'h80000000;
}
return r;

if (is_sp_signaling_nan?(a)) {
  set_fp_flag(FpFlag::NV);
}
Bits<1> signA = signF32UI(a);
Bits<16> expA = expF32UI(a);
Bits<32> fracA = fracF32UI(a);
if (expA == 8'hFF) {
  if (fracA != 0) {
    return SP_CANONICAL_NAN;
  }
  if (signA == 0) {
    return a;
  }
  set_fp_flag(FpFlag::NV);
  return SP_CANONICAL_NAN;
}
if (signA == 1) {
  if ((expA == 0) && (fracA == 0)) {
    return a;
  }
  set_fp_flag(FpFlag::NV);
  return SP_CANONICAL_NAN;
}
if (expA == 0) {
  if (fracA == 0) {
    return a;
  }
  ExpAndSig norm = softfloat_normSubnormalF32Sig(fracA);
  expA = norm.exp;
  fracA = norm.sig;
}
Bits<16> adjExp = expA - 16'h007F;
Bits<16> expZ = adjExp + 16'h007E;
Bits<1> oddExpA = expA[0];
Bits<32> sigA32 = (fracA | 32'h00800000) << 8;
Bits<32> sigZ = (sigA32 `* softfloat_approxRecipSqrt32_1(oddExpA, sigA32)) >> 32;
if (oddExpA == 1) {
  sigZ = sigZ >> 1;
}
sigZ = sigZ + 2;
if ((sigZ & 0x3F) < 2) {
  Bits<32> shiftedSigZ = sigZ >> 2;
  Bits<32> negRem = shiftedSigZ * shiftedSigZ;
  sigZ = sigZ & ~32'h3;
  if ((negRem & 0x80000000) != 0) {
    sigZ = sigZ | 1;
  } else {
    if (negRem != 0) {
      sigZ = sigZ - 1;
    }
  }
}
return softfloat_roundPackToF32(0, expZ, sigZ, mode);

if (is_sp_signaling_nan?(a)) {
  set_fp_flag(FpFlag::NV);
}
Bits<1> signA = signF32UI(a);
Bits<16> expA = expF32UI(a);
Bits<32> fracA = fracF32UI(a);
if (expA == 8'hFF) {
  if (fracA != 0) {
    return 32'h7fc00000;
  }
  if (signA == 0) {
    return a;
  }
  set_fp_flag(FpFlag::NV);
  return 32'h7fc00000;
}
if (signA == 1) {
  if ((expA == 0) && (fracA == 0)) {
    return a;
  }
  set_fp_flag(FpFlag::NV);
  return 32'h7fc00000;
}
if (expA == 0) {
  if (fracA == 0) {
    return a;
  }
  ExpAndSig norm = softfloat_normSubnormalF32Sig(fracA);
  expA = norm.exp;
  fracA = norm.sig;
}
Bits<16> adjExp = expA - 16'h007F;
Bits<16> expZ = adjExp + 16'h007E;
Bits<1> oddExpA = expA[0];
Bits<32> sigA32 = (fracA | 32'h00800000) << 8;
Bits<32> sigZ = (sigA32 `* softfloat_approxRecipSqrt32_1(oddExpA, sigA32)) >> 32;
if (oddExpA == 1) {
  sigZ = sigZ >> 1;
}
sigZ = sigZ + 2;
if ((sigZ & 0x3F) < 2) {
  Bits<32> shiftedSigZ = sigZ >> 2;
  Bits<32> negRem = shiftedSigZ * shiftedSigZ;
  sigZ = sigZ & 32'hfffffffc;
  if ((negRem & 0x80000000) != 0) {
    sigZ = sigZ | 1;
  } else {
    if (negRem != 0) {
      sigZ = sigZ - 1;
    }
  }
}
return softfloat_roundPackToF32(0, expZ, sigZ, mode);

if (is_sp_signaling_nan?(a) || is_sp_signaling_nan?(b)) {
  set_fp_flag(FpFlag::NV);
}
Bits<16> expA = expF32UI(a);
Bits<32> sigA = fracF32UI(a);
Bits<16> expB = expF32UI(b);
Bits<32> sigB = fracF32UI(b);
U32 sigZ;
U32 z;
Bits<1> signZ;
Bits<8> expZ;
U32 sigDiff;
U32 sigX;
U32 sigY;
Bits<8> shiftDist;
Bits<16> expDiff = expA - expB;
if (expDiff == 16'd0) {
  if (expA == 8'hFF) {
    set_fp_flag(FpFlag::NV);
    return SP_CANONICAL_NAN;
  }
  sigDiff = sigA - sigB;
  if (sigDiff == 0) {
    return packToF32UI(((mode == RoundingMode::RDN) ? 1 : 0), 0, 0);
  }
  if (expA != 0) {
    expA = expA - 1;
  }
  signZ = signF32UI(a);
  if (sigDiff < 0) {
    signZ = ~signZ;
    sigDiff = -32'sh1 * sigDiff;
  }
  shiftDist = count_leading_zeros(32, sigDiff) - 8;
  expZ = expA - shiftDist;
  if (expZ < 0) {
    shiftDist = expA;
    expZ = 0;
  }
  return packToF32UI(signZ, expZ, sigDiff << shiftDist);
} else {
  signZ = signF32UI(a);
  sigA = sigA << 7;
  sigB = sigB << 7;
  if ($signed(expDiff) < 0s) {
    signZ = ~signZ;
    if (expB == 0xFF) {
      if (sigB != 0) {
        return SP_CANONICAL_NAN;
      }
      return packToF32UI(signZ, expB, 0);
    }
    expZ = expB - 1;
    sigX = sigB | 0x40000000;
    sigY = sigA + ((expA != 0) ? 0x40000000 : sigA);
    expDiff = -expDiff;
  } else {
    if (expA == 0xFF) {
      if (sigA != 0) {
        return SP_CANONICAL_NAN;
      }
      return a;
    }
    expZ = expA - 1;
    sigX = sigA | 0x40000000;
    sigY = sigB + ((expB != 0) ? 0x40000000 : sigB);
  }
  return softfloat_normRoundPackToF32(signZ, expZ, sigX - softfloat_shiftRightJam32(sigY, expDiff), mode);
}

if (is_sp_signaling_nan?(a) || is_sp_signaling_nan?(b)) {
  set_fp_flag(FpFlag::NV);
}
Bits<16> expA = expF32UI(a);
Bits<32> sigA = fracF32UI(a);
Bits<16> expB = expF32UI(b);
Bits<32> sigB = fracF32UI(b);
U32 sigZ;
U32 z;
Bits<1> signZ;
Bits<8> expZ;
U32 sigDiff;
U32 sigX;
U32 sigY;
Bits<8> shiftDist;
Bits<16> expDiff = expA - expB;
if (expDiff == 16'd0) {
  if (expA == 8'hFF) {
    set_fp_flag(FpFlag::NV);
    return 32'h7fc00000;
  }
  sigDiff = sigA - sigB;
  if (sigDiff == 0) {
    return packToF32UI(((mode == RoundingMode::RDN) ? 1 : 0), 0, 0);
  }
  if (expA != 0) {
    expA = expA - 1;
  }
  signZ = signF32UI(a);
  if (sigDiff < 0) {
    signZ = ~signZ;
    sigDiff = 32'-1 * sigDiff;
  }
  shiftDist = count_leading_zeros(32, sigDiff) - 8;
  expZ = expA - shiftDist;
  if (expZ < 0) {
    shiftDist = expA;
    expZ = 0;
  }
  return packToF32UI(signZ, expZ, sigDiff << shiftDist);
} else {
  signZ = signF32UI(a);
  sigA = sigA << 7;
  sigB = sigB << 7;
  if ($signed(expDiff) < 0s) {
    signZ = ~signZ;
    if (expB == 0xFF) {
      if (sigB != 0) {
        return 32'h7fc00000;
      }
      return packToF32UI(signZ, expB, 0);
    }
    expZ = expB - 1;
    sigX = sigB | 0x40000000;
    sigY = sigA + ((expA != 0) ? 0x40000000 : sigA);
    expDiff = -expDiff;
  } else {
    if (expA == 0xFF) {
      if (sigA != 0) {
        return 32'h7fc00000;
      }
      return a;
    }
    expZ = expA - 1;
    sigX = sigA | 0x40000000;
    sigY = sigB + ((expB != 0) ? 0x40000000 : sigB);
  }
  return softfloat_normRoundPackToF32(signZ, expZ, sigX - softfloat_shiftRightJam32(sigY, expDiff), mode);
}

U32 a_xor_b = a ^ b;
if (signF32UI(a_xor_b) == 1) {
  return softfloat_addMagsF32(a, b, mode);
} else {
  return softfloat_subMagsF32(a, b, mode);
}

U32 a_xor_b = a ^ b;
if (signF32UI(a_xor_b) == 1) {
  return softfloat_addMagsF32(a, b, mode);
} else {
  return softfloat_subMagsF32(a, b, mode);
}

assert((target_hw_addr & 0x1) == 0x0, "Expected halfword-aligned address in jump_halfword");
if (ialign() != 16) {
  if ((target_hw_addr & 0x3) != 0) {
    raise(ExceptionCode::InstructionAddressMisaligned, mode(), target_hw_addr);
  }
}
$pc = target_hw_addr;

assert((target_hw_addr & 0x1) == 0x0, "Expected halfword-aligned address in jump_halfword");

$pc = target_hw_addr;

return (mode() == PrivilegeMode::VS) || (mode() == PrivilegeMode::VU);

return (mode() == PrivilegeMode::VS) || (mode() == PrivilegeMode::VU);

return eaddr;

return eaddr;

if (CSR[misa].S == 1'b0) {
  return true;
}
SatpMode satp_mode;
if (virtual_mode?()) {
  satp_mode = $enum(SatpMode, CSR[vsatp].MODE);
} else {
  satp_mode = $enum(SatpMode, CSR[satp].MODE);
}
XReg eaddr = mask_eaddr(vaddr);
if (SATP_MODE_BARE && (satp_mode == SatpMode::Bare)) {
  return true;
} else if ((MXLEN == 32) && satp_mode == SatpMode::Sv32) {
  return true;
} else if ((MXLEN == 64) && satp_mode == SatpMode::Sv39) {
  return eaddr[63:39] == {25{eaddr[38]}};
} else if ((MXLEN == 64) && satp_mode == SatpMode::Sv48) {
  return eaddr[63:48] == {16{eaddr[47]}};
} else if ((MXLEN == 64) && satp_mode == SatpMode::Sv57) {
  return eaddr[63:57] == {6{eaddr[56]}};
}
return false;

SatpMode satp_mode;
if (virtual_mode?()) {
  satp_mode = $enum(SatpMode, CSR[vsatp].MODE);
} else {
  satp_mode = $enum(SatpMode, CSR[satp].MODE);
}
XReg eaddr = mask_eaddr(vaddr);
if ((satp_mode == SatpMode::Bare)) {
  return true;
} else if (satp_mode == SatpMode::Sv39) {
  return eaddr[63:39] == {25{eaddr[38]}};
} else if (satp_mode == SatpMode::Sv48) {
  return eaddr[63:48] == {16{eaddr[47]}};
} else if (satp_mode == SatpMode::Sv57) {
  return eaddr[63:57] == {6{eaddr[56]}};
}
return false;

SatpMode satp_mode = $enum(SatpMode, CSR[satp].MODE);
if (satp_mode == SatpMode::Bare) {
  return true;
} else if (satp_mode == SatpMode::Sv32) {
  return true;
} else if ((MXLEN > 32) && (satp_mode == SatpMode::Sv39)) {
  return gpaddr[63:39] == {25{gpaddr[38]}};
} else if ((MXLEN > 32) && (satp_mode == SatpMode::Sv48)) {
  return gpaddr[63:48] == {16{gpaddr[47]}};
} else if ((MXLEN > 32) && (satp_mode == SatpMode::Sv57)) {
  return gpaddr[63:57] == {6{gpaddr[56]}};
}
return false;

SatpMode satp_mode = $enum(SatpMode, CSR[satp].MODE);
if (satp_mode == SatpMode::Bare) {
  return true;
} else if (satp_mode == SatpMode::Sv32) {
  return true;
} else if ((satp_mode == SatpMode::Sv39)) {
  return gpaddr[63:39] == {25{gpaddr[38]}};
} else if ((satp_mode == SatpMode::Sv48)) {
  return gpaddr[63:48] == {16{gpaddr[47]}};
} else if ((satp_mode == SatpMode::Sv57)) {
  return gpaddr[63:57] == {6{gpaddr[56]}};
}
return false;

VectorState state;
state.log2_sew = 3 + CSR[vtype].VSEW;
state.sew = 7'b1 << state.log2_sew;
Bits<3> vlmul = CSR[vtype].VLMUL;
state.lmul_type = CSR[vtype].VLMUL[2] == 1'b1 ? VectorLmulType::Divide : VectorLmulType::Multiply;
state.log2_lmul = CSR[vtype].VLMUL[1:0];
if (vlmul == 3'b101) {
  state.log2_lmul = 3;
} else if (vlmul == 3'b110) {
  state.log2_lmul = 2;
} else if (vlmul == 3'b111) {
  state.log2_lmul = 1;
} else if (vlmul == 3'b100) {
  unpredictable("VLMUL value 0b100 is reserved");
}
return state;

VectorState state;
state.log2_sew = 3 + CSR[vtype].VSEW;
state.sew = 7'b1 << state.log2_sew;
Bits<3> vlmul = CSR[vtype].VLMUL;
state.lmul_type = CSR[vtype].VLMUL[2] == 1'b1 ? VectorLmulType::Divide : VectorLmulType::Multiply;
state.log2_lmul = CSR[vtype].VLMUL[1:0];
if (vlmul == 3'b101) {
  state.log2_lmul = 3;
} else if (vlmul == 3'b110) {
  state.log2_lmul = 2;
} else if (vlmul == 3'b111) {
  state.log2_lmul = 1;
} else if (vlmul == 3'b100) {
  unpredictable("VLMUL value 0b100 is reserved");
}
return state;

XReg Mask = (N / 8) - 1;
return (address & ~Mask) == ((address + length - 1) & ~Mask);

XReg Mask = (N / 8) - 1;
return (address & ~Mask) == ((address + length - 1) & ~Mask);

return false if (MISALIGNED_MAX_ATOMICITY_GRANULE_SIZE == 0);
if (pma_applies?(PmaAttribute::MAG16, physical_address, N) && in_naturally_aligned_region?(128, physical_address, N)) {
  return true;
} else if (pma_applies?(PmaAttribute::MAG8, physical_address, N) && in_naturally_aligned_region?(64, physical_address, N)) {
  return true;
} else if (pma_applies?(PmaAttribute::MAG4, physical_address, N) && in_naturally_aligned_region?(32, physical_address, N)) {
  return true;
} else if (pma_applies?(PmaAttribute::MAG2, physical_address, N) && in_naturally_aligned_region?(16, physical_address, N)) {
  return true;
} else {
  return false;
}

return false

Boolean aligned = is_naturally_aligned(N, virtual_address);
if (!aligned && MISALIGNED_LDST_EXCEPTION_PRIORITY == "high") {
  raise(ExceptionCode::StoreAmoAddressMisaligned, mode(), virtual_address);
}
Bits<PHYS_ADDR_WIDTH> physical_address = (CSR[misa].S == 1) ? translate(virtual_address, MemoryOperation::ReadModifyWrite, effective_ldst_mode(), encoding).paddr : virtual_address;
if (pma_applies?(PmaAttribute::AmoNone, physical_address, N)) {
  raise(ExceptionCode::StoreAmoAccessFault, mode(), virtual_address);
} else if (op == AmoOperation::Add || op == AmoOperation::Max || op == AmoOperation::Maxu || op == AmoOperation::Min || op == AmoOperation::Minu) {
  if (!pma_applies?(PmaAttribute::AmoArithmetic, physical_address, N)) {
    raise(ExceptionCode::StoreAmoAccessFault, mode(), virtual_address);
  }
} else if (op == AmoOperation::And || op == AmoOperation::Or || op == AmoOperation::Xor) {
  if (!pma_applies?(PmaAttribute::AmoLogical, physical_address, N)) {
    raise(ExceptionCode::StoreAmoAccessFault, mode(), virtual_address);
  }
} else {
  assert(pma_applies?(PmaAttribute::AmoSwap, physical_address, N) && op == AmoOperation::Swap, "Bad AMO operation");
}
if (!aligned && !misaligned_is_atomic?(N, physical_address)) {
  raise(ExceptionCode::StoreAmoAddressMisaligned, mode(), virtual_address);
}
if (N == 32) {
  return atomic_read_modify_write_32(physical_address, value, op);
} else {
  return atomic_read_modify_write_64(physical_address, value, op);
}

Boolean aligned = is_naturally_aligned(N, virtual_address);
if (!aligned) {
  raise(ExceptionCode::StoreAmoAddressMisaligned, mode(), virtual_address);
}
Bits<PHYS_ADDR_WIDTH> physical_address = translate(virtual_address, MemoryOperation::ReadModifyWrite, effective_ldst_mode(), encoding).paddr;
if (pma_applies?(PmaAttribute::AmoNone, physical_address, N)) {
  raise(ExceptionCode::StoreAmoAccessFault, mode(), virtual_address);
} else if ((op == AmoOperation::Add || op == AmoOperation::Max || op == AmoOperation::Maxu || op == AmoOperation::Min || op == AmoOperation::Minu)) {
  if (!pma_applies?(PmaAttribute::AmoArithmetic, physical_address, N)) {
    raise(ExceptionCode::StoreAmoAccessFault, mode(), virtual_address);
  }
} else if ((op == AmoOperation::And || op == AmoOperation::Or || op == AmoOperation::Xor)) {
  if (!pma_applies?(PmaAttribute::AmoLogical, physical_address, N)) {
    raise(ExceptionCode::StoreAmoAccessFault, mode(), virtual_address);
  }
} else {
  assert(pma_applies?(PmaAttribute::AmoSwap, physical_address, N) && op == AmoOperation::Swap, "Bad AMO operation");
}
if (!aligned) {
  raise(ExceptionCode::StoreAmoAddressMisaligned, mode(), virtual_address);
}
if (N == 32) {
  return atomic_read_modify_write_32(physical_address, value, op);
} else {
  return atomic_read_modify_write_64(physical_address, value, op);
}

reservation_set_valid = true;
reservation_set_address = physical_address;
if (LRSC_RESERVATION_STRATEGY == "reserve naturally-aligned 64-byte region") {
  reservation_set_address = physical_address & ~MXLEN'h3f;
  reservation_set_size = 64;
} else if (LRSC_RESERVATION_STRATEGY == "reserve naturally-aligned 128-byte region") {
  reservation_set_address = physical_address & ~MXLEN'h7f;
  reservation_set_size = 128;
} else if (LRSC_RESERVATION_STRATEGY == "reserve exactly enough to cover the access") {
  reservation_set_address = physical_address;
  reservation_set_size = length;
} else if (LRSC_RESERVATION_STRATEGY == "custom") {
  unpredictable("Implementations may set reservation sets of any size, as long as they cover the reserved accessed");
} else {
  assert(false, "Unexpected LRSC_RESERVATION_STRATEGY");
  unreachable();
}

reservation_set_valid = true;
reservation_set_address = physical_address;
reservation_set_address = physical_address & 64'hffffffffffffffc0;
reservation_set_size = 64;

Bits<PHYS_ADDR_WIDTH> physical_address = (CSR[misa].S == 1) ? translate(virtual_address, MemoryOperation::Read, effective_ldst_mode(), encoding).paddr : virtual_address;
if (pma_applies?(PmaAttribute::RsrvNone, physical_address, N)) {
  raise(ExceptionCode::LoadAccessFault, mode(), virtual_address);
}
if (aq == 1) {
  memory_model_acquire();
}
if (rl == 1) {
  memory_model_release();
}
register_reservation_set(physical_address, N);
if (CSR[misa].S == 1 && LRSC_FAIL_ON_VA_SYNONYM) {
  reservation_virtual_address = virtual_address;
}
return read_memory_aligned(N, physical_address, encoding, 1'b0, 1'b0);

Bits<PHYS_ADDR_WIDTH> physical_address = translate(virtual_address, MemoryOperation::Read, effective_ldst_mode(), encoding).paddr;
if (pma_applies?(PmaAttribute::RsrvNone, physical_address, N)) {
  raise(ExceptionCode::LoadAccessFault, mode(), virtual_address);
}
if (aq == 1) {
  memory_model_acquire();
}
if (rl == 1) {
  memory_model_release();
}
register_reservation_set(physical_address, N);

return read_memory_aligned(N, physical_address, encoding, 1'b0, 1'b0);

return target_start >= region_start && (target_start + target_size) <= (region_start + region_size);

return target_start >= region_start && (target_start + target_size) <= (region_start + region_size);

reservation_set_valid = false;

reservation_set_valid = false;

Bits<PHYS_ADDR_WIDTH> physical_address = (CSR[misa].S == 1) ? translate(virtual_address, MemoryOperation::Write, effective_ldst_mode(), encoding).paddr : virtual_address;
if (pma_applies?(PmaAttribute::RsrvNone, physical_address, N)) {
  raise(ExceptionCode::StoreAmoAccessFault, mode(), virtual_address);
}
access_check(physical_address, N, virtual_address, MemoryOperation::Write, ExceptionCode::StoreAmoAccessFault, effective_ldst_mode());
if (aq == 1) {
  memory_model_acquire();
}
if (rl == 1) {
  memory_model_release();
}
if (reservation_set_valid == false) {
  return false;
}
if (!contains?(reservation_set_address, reservation_set_size, physical_address, N)) {
  invalidate_reservation_set();
  return false;
}
if (LRSC_FAIL_ON_NON_EXACT_LRSC) {
  if (reservation_physical_address != physical_address || reservation_size != N) {
    invalidate_reservation_set();
    return false;
  }
}
if (LRSC_FAIL_ON_VA_SYNONYM) {
  if (reservation_virtual_address != virtual_address || reservation_size != N) {
    invalidate_reservation_set();
    return false;
  }
}
write_physical_memory(N, physical_address, value);
return true;

Bits<PHYS_ADDR_WIDTH> physical_address = translate(virtual_address, MemoryOperation::Write, effective_ldst_mode(), encoding).paddr;
if (pma_applies?(PmaAttribute::RsrvNone, physical_address, N)) {
  raise(ExceptionCode::StoreAmoAccessFault, mode(), virtual_address);
}
access_check(physical_address, N, virtual_address, MemoryOperation::Write, ExceptionCode::StoreAmoAccessFault, effective_ldst_mode());
if (aq == 1) {
  memory_model_acquire();
}
if (rl == 1) {
  memory_model_release();
}
if (reservation_set_valid == false) {
  return false;
}
if (!contains?(reservation_set_address, 64'64, physical_address, N)) {
  invalidate_reservation_set();
  return false;
}


write_physical_memory(N, physical_address, value);
return true;

for (Bits<8> i = xlen(); i > 0; i--) {
  if (value[i - 1] == 1) {
    return i - 1;
  }
}
return -'sd1;

for (Bits<8> i = xlen(); i > 0; i--) {
  if (value[i - 1] == 1) {
    return i - 1;
  }
}
return 64'-1;

for (Bits<8> i = 0; i < xlen(); i++) {
  if (value[i] == 1) {
    return i;
  }
}
return xlen();

for (Bits<8> i = 0; i < xlen(); i++) {
  if (value[i] == 1) {
    return i;
  }
}
return xlen();

Bits<16> roundIncrement = 0x800;
if ((roundingMode != RoundingMode::RMM) && (roundingMode != RoundingMode::RNE)) {
  roundIncrement = 0;
  if (sign == 1 ? (roundingMode == RoundingMode::RDN) : (roundingMode == RoundingMode::RUP)) {
    roundIncrement = 0xFFF;
  }
}
Bits<16> roundBits = sig & 0xFFF;
sig = sig + roundIncrement;
if ((sig & 0xFFFFF00000000000) != 0) {
  return sign == 1 ? WORD_NEG_OVERFLOW : WORD_POS_OVERFLOW;
}
Bits<32> sig32 = sig >> 12;
if ((roundBits == 0x800 && (roundingMode == RoundingMode::RNE))) {
  sig32 = sig32 & ~32'b1;
}
Bits<32> z = (sign == 1) ? -sig32 : sig32;
if ((z != 0) && $signed(z) < 's0) != (sign == 1) {
  return sign == 1 ? WORD_NEG_OVERFLOW : WORD_POS_OVERFLOW;
}
return z;

Bits<16> roundIncrement = 0x800;
if ((roundingMode != RoundingMode::RMM) && (roundingMode != RoundingMode::RNE)) {
  roundIncrement = 0;
  if (sign == 1 ? (roundingMode == RoundingMode::RDN) : (roundingMode == RoundingMode::RUP)) {
    roundIncrement = 0xFFF;
  }
}
Bits<16> roundBits = sig & 0xFFF;
sig = sig + roundIncrement;
if ((sig & 0xFFFFF00000000000) != 0) {
  return sign == 1 ? 32'h80000000 : 32'h7fffffff;
}
Bits<32> sig32 = sig >> 12;
if ((roundBits == 0x800 && (roundingMode == RoundingMode::RNE))) {
  sig32 = sig32 & 32'hfffffffe;
}
Bits<32> z = (sign == 1) ? -sig32 : sig32;
if ((z != 0) && $signed(z) < 's0) != (sign == 1) {
  return sign == 1 ? 32'h80000000 : 32'h7fffffff;
}
return z;

Bits<1> sign = signF32UI(a);
Bits<8> exp = expF32UI(a);
Bits<23> sig = fracF32UI(a);
Bits<8> shiftDist;
U64 sig64;
if ((exp == 8'hFF) && (sig != 0)) {
  sign = 0;
  return I32_NAN;
}
if (exp != 0) {
  sig = sig | 32'h00800000;
}
sig64 = sig `<< 32;
shiftDist = 8'hAA - exp;
if (shiftDist > 0) {
  sig64 = softfloat_shiftRightJam64(sig64, shiftDist);
}
return softfloat_roundToI32_no_flag(sign, sig64, mode);

Bits<1> sign = signF32UI(a);
Bits<8> exp = expF32UI(a);
Bits<23> sig = fracF32UI(a);
Bits<8> shiftDist;
U64 sig64;
if ((exp == 8'hFF) && (sig != 0)) {
  sign = 0;
  return 32'h7fffffff;
}
if (exp != 0) {
  sig = sig | 32'h00800000;
}
sig64 = sig `<< 32;
shiftDist = 8'hAA - exp;
if (shiftDist > 0) {
  sig64 = softfloat_shiftRightJam64(sig64, shiftDist);
}
return softfloat_roundToI32_no_flag(sign, sig64, mode);

U32 a_copy = a;
a_copy[31] = 1'b0;
return a_copy;

U32 a_copy = a;
a_copy[31] = 1'b0;
return a_copy;

Bits<8> shiftDist = count_leading_zeros(32, sig) - 1;
exp = exp - shiftDist;
if ((7 <= shiftDist) && (exp < 0xFD)) {
  return packToF32UI(sign, (sig != 0) ? exp : 0, sig << (shiftDist - 7));
} else {
  return softfloat_roundPackToF32_no_flag(sign, exp, sig << shiftDist, mode);
}

Bits<8> shiftDist = count_leading_zeros(32, sig) - 1;
exp = exp - shiftDist;
if ((7 <= shiftDist) && (exp < 0xFD)) {
  return packToF32UI(sign, (sig != 0) ? exp : 0, sig << (shiftDist - 7));
} else {
  return softfloat_roundPackToF32_no_flag(sign, exp, sig << shiftDist, mode);
}

Bits<1> sign = a[31];
if ((a & 0x7FFFFFFF) == 0) {
  return (sign == 1) ? packToF32UI(1, 0x9E, 0) : packToF32UI(0, 0, 0);
}
U32 magnitude_of_A = returnMag(a);
return softfloat_normRoundPackToF32_no_flag(sign, 0x9C, magnitude_of_A, mode);

Bits<1> sign = a[31];
if ((a & 0x7FFFFFFF) == 0) {
  return (sign == 1) ? 32'hcf000000 : 32'0;
}
U32 magnitude_of_A = returnMag(a);
return softfloat_normRoundPackToF32_no_flag(sign, 0x9C, magnitude_of_A, mode);

if ((is_sp_neg_inf?(a)) || (is_sp_pos_inf?(a)) || (is_sp_pos_zero?(a)) || (is_sp_neg_zero?(a))) {
  return a;
} else if (is_sp_signaling_nan?(a)) {
  set_fp_flag(FpFlag::NV);
  return a;
}
U32 intermediate;
intermediate = f32_to_i32_no_flag(a, mode);
return i32_to_f32_no_flag(intermediate, mode);

if ((is_sp_neg_inf?(a)) || (is_sp_pos_inf?(a)) || (is_sp_pos_zero?(a)) || (is_sp_neg_zero?(a))) {
  return a;
} else if (is_sp_signaling_nan?(a)) {
  set_fp_flag(FpFlag::NV);
  return a;
}
U32 intermediate;
intermediate = f32_to_i32_no_flag(a, mode);
return i32_to_f32_no_flag(intermediate, mode);

Bits<8> shift_dist = count_leading_zeros(16, hp_value);
return 1 - shift_dist, hp_value << shift_dist;

Bits<8> shift_dist = count_leading_zeros(16, hp_value);
return 1 - shift_dist, hp_value << shift_dist;

return {sign, exp, sig};

return {sign, exp, sig};

if (TRAP_ON_UNIMPLEMENTED_CSR) {
  raise(ExceptionCode::IllegalInstruction, mode(), encoding);
} else {
  unpredictable("Accessing an unimplmented CSR");
}

raise(ExceptionCode::IllegalInstruction, mode(), encoding);

if (target_mode == PrivilegeMode::M) {
  return actual_mode == PrivilegeMode::M;
} else if (target_mode == PrivilegeMode::S) {
  return (actual_mode == PrivilegeMode::M) || (actual_mode == PrivilegeMode::S);
} else if (target_mode == PrivilegeMode::U) {
  return (actual_mode == PrivilegeMode::M) || (actual_mode == PrivilegeMode::S) || (actual_mode == PrivilegeMode::U);
} else if (target_mode == PrivilegeMode::VS) {
  return (actual_mode == PrivilegeMode::M) || (actual_mode == PrivilegeMode::S) || (actual_mode == PrivilegeMode::VS);
} else if (target_mode == PrivilegeMode::VU) {
  return (actual_mode == PrivilegeMode::M) || (actual_mode == PrivilegeMode::S) || (actual_mode == PrivilegeMode::VS) || (actual_mode == PrivilegeMode::VU);
}
return false;

if (target_mode == PrivilegeMode::M) {
  return actual_mode == PrivilegeMode::M;
} else if (target_mode == PrivilegeMode::S) {
  return (actual_mode == PrivilegeMode::M) || (actual_mode == PrivilegeMode::S);
} else if (target_mode == PrivilegeMode::U) {
  return (actual_mode == PrivilegeMode::M) || (actual_mode == PrivilegeMode::S) || (actual_mode == PrivilegeMode::U);
} else if (target_mode == PrivilegeMode::VS) {
  return (actual_mode == PrivilegeMode::M) || (actual_mode == PrivilegeMode::S) || (actual_mode == PrivilegeMode::VS);
} else if (target_mode == PrivilegeMode::VU) {
  return (actual_mode == PrivilegeMode::M) || (actual_mode == PrivilegeMode::S) || (actual_mode == PrivilegeMode::VS) || (actual_mode == PrivilegeMode::VU);
}
return false;

if (code > 1 `<< $enum_element_size(InterruptCode - 1)) {
  return false;
}
if ($array_includes?($enum_to_a(InterruptCode), code)) {
  return true;
} else {
  return false;
}

if (code > 5'15) {
  return false;
}
if ($array_includes?($enum_to_a(InterruptCode), code)) {
  return true;
} else {
  return false;
}

if (code > 1 `<< $enum_element_size(ExceptionCode - 1)) {
  return false;
}
if ($array_includes?($enum_to_a(ExceptionCode), code)) {
  return true;
} else {
  return false;
}

if (code > 6'31) {
  return false;
}
if ($array_includes?($enum_to_a(ExceptionCode), code)) {
  return true;
} else {
  return false;
}

Boolean fs_has_single_value = !implemented?(ExtensionName::F || ($array_size(MSTATUS_FS_LEGAL_VALUES) == 1));
Boolean vs_has_single_value = !implemented?(ExtensionName::V || ($array_size(MSTATUS_VS_LEGAL_VALUES) == 1));
return fs_has_single_value && vs_has_single_value;

Boolean fs_has_single_value = ($array_size([2'0, 2'1, 2'2, 2'3]) == 1);
Boolean vs_has_single_value = ($array_size([2'0, 2'1, 2'2, 2'3]) == 1);
return false;

assert(mstatus_sd_has_known_reset(), "mstatus_sd_reset_value is only defined when mstatus_sd_has_known_reset() == true");
Bits<2> fs_value, vs_value;
if ((!implemented?(ExtensionName::F)) || ($array_size(MSTATUS_FS_LEGAL_VALUES) == 1)) {
  fs_value = (!implemented?(ExtensionName::F)) ? 0 : MSTATUS_FS_LEGAL_VALUES[0];
}
if ((!implemented?(ExtensionName::V)) || ($array_size(MSTATUS_VS_LEGAL_VALUES) == 1)) {
  vs_value = (!implemented?(ExtensionName::V)) ? 0 : MSTATUS_VS_LEGAL_VALUES[0];
}
return fs_value == 3) || (vs_value == 3 ? 1 : 0;

assert(mstatus_sd_has_known_reset(), "mstatus_sd_reset_value is only defined when mstatus_sd_has_known_reset() == true");
Bits<2> fs_value, vs_value;
if (($array_size([2'0, 2'1, 2'2, 2'3]) == 1)) {
  fs_value = 2'0;
}
if (($array_size([2'0, 2'1, 2'2, 2'3]) == 1)) {
  vs_value = 2'0;
}
return fs_value == 3) || (vs_value == 3 ? 1 : 0;

if (int_mask[$bits(InterruptCode::MachineExternal)] == 1'b1) {
  return InterruptCode::MachineExternal;
} else if (int_mask[$bits(InterruptCode::MachineSoftware)] == 1'b1) {
  return InterruptCode::MachineSoftware;
} else if (int_mask[$bits(InterruptCode::MachineTimer)] == 1'b1) {
  return InterruptCode::MachineTimer;
} else if (CSR[misa].S == 1'b1) {
  if (int_mask[$bits(InterruptCode::SupervisorExternal)] == 1'b1) {
    return InterruptCode::SupervisorExternal;
  } else if (int_mask[$bits(InterruptCode::SupervisorSoftware)] == 1'b1) {
    return InterruptCode::SupervisorSoftware;
  } else if (int_mask[$bits(InterruptCode::SupervisorTimer)] == 1'b1) {
    return InterruptCode::SupervisorTimer;
  }
} else if (implemented?(ExtensionName::Sscofpmf)) {
  if (int_mask[$bits(InterruptCode::LocalCounterOverflow)] == 1'b1) {
    return InterruptCode::LocalCounterOverflow;
  }
}
assert(false, "There is no valid interrupt");
unreachable();

if (int_mask[$bits(InterruptCode::MachineExternal)] == 1'b1) {
  return InterruptCode::MachineExternal;
} else if (int_mask[$bits(InterruptCode::MachineSoftware)] == 1'b1) {
  return InterruptCode::MachineSoftware;
} else if (int_mask[$bits(InterruptCode::MachineTimer)] == 1'b1) {
  return InterruptCode::MachineTimer;
} else {
  if (int_mask[$bits(InterruptCode::SupervisorExternal)] == 1'b1) {
    return InterruptCode::SupervisorExternal;
  } else if (int_mask[$bits(InterruptCode::SupervisorSoftware)] == 1'b1) {
    return InterruptCode::SupervisorSoftware;
  } else if (int_mask[$bits(InterruptCode::SupervisorTimer)] == 1'b1) {
    return InterruptCode::SupervisorTimer;
  }
}
assert(false, "There is no valid interrupt");
unreachable();

InterruptCode chosen;
Boolean HAS_MIDELEG = implemented_version?(ExtensionName::S, "<= 1.9.1") || (implemented_version?(ExtensionName::S, "> 1.9.1") && implemented_version?(ExtensionName::Sm, "> 1.9.1"));
Bits<MXLEN> mmode_pending_and_enabled = pending_and_enabled_interrupts & ~(HAS_MIDELEG ? $bits(CSR[CSR[mideleg]]) : MXLEN'0);
if (mmode_pending_and_enabled != 0) {
  assert((mode() != PrivilegeMode::M) || (CSR[mstatus].MIE == 1'b1), "M-mode interrupts are not enabled");
  chosen = highest_priority_interrupt(mmode_pending_and_enabled);
} else if (CSR[misa].S == 1'b1) {
  Bits<MXLEN> smode_pending_and_enabled = (pending_and_enabled_interrupts & $bits(CSR[CSR[mideleg]]));
  if (smode_pending_and_enabled != 0) {
    assert((mode() == PrivilegeMode::U) || (mode() == PrivilegeMode::VU) || (mode() == PrivilegeMode::VS) || (mode() == PrivilegeMode::S) && (CSR[mstatus].SIE == 1'b1), "S-mode interrupt can't be triggered");
    chosen = highest_priority_interrupt(smode_pending_and_enabled);
  }
}
assert($bits(chosen) != 0, "Didn't pick interrupt?");
PrivilegeMode to_mode;
Bits<MXLEN> chosen_mask = (MXLEN'1 << $bits(chosen));
if (((HAS_MIDELEG ? $bits(CSR[CSR[mideleg]]) : MXLEN'0) & chosen_mask) == 0) {
  to_mode = PrivilegeMode::M;
} else {
  if (CSR[misa].S == 1'b1) {
    to_mode = PrivilegeMode::S;
  } else {
    to_mode = PrivilegeMode::U;
  }
}
return chosen, to_mode;

InterruptCode chosen;
Boolean HAS_MIDELEG = true;
Bits<MXLEN> mmode_pending_and_enabled = pending_and_enabled_interrupts & ~($bits(CSR[CSR[mideleg]]));
if (mmode_pending_and_enabled != 0) {
  assert((mode() != PrivilegeMode::M) || (CSR[mstatus].MIE == 1'b1), "M-mode interrupts are not enabled");
  chosen = highest_priority_interrupt(mmode_pending_and_enabled);
} else {
  Bits<MXLEN> smode_pending_and_enabled = (pending_and_enabled_interrupts & $bits(CSR[CSR[mideleg]]));
  if (smode_pending_and_enabled != 0) {
    assert((mode() == PrivilegeMode::U) || (mode() == PrivilegeMode::VU) || (mode() == PrivilegeMode::VS) || (mode() == PrivilegeMode::S) && (CSR[mstatus].SIE == 1'b1), "S-mode interrupt can't be triggered");
    chosen = highest_priority_interrupt(smode_pending_and_enabled);
  }
}
assert($bits(chosen) != 0, "Didn't pick interrupt?");
PrivilegeMode to_mode;
Bits<MXLEN> chosen_mask = (MXLEN'1 << $bits(chosen));
if ($bits(CSR[CSR[mideleg]] & chosen_mask) == 0) {
  to_mode = PrivilegeMode::M;
} else {
  to_mode = PrivilegeMode::S;
}
return chosen, to_mode;

if (new_mode != current_mode) {
  notify_mode_change(new_mode, current_mode);
  current_mode = new_mode;
}

if (new_mode != current_mode) {
  notify_mode_change(new_mode, current_mode);
  current_mode = new_mode;
}

PrivilegeMode to_mode;
InterruptCode code;
(code, to_mode = choose_interrupt());
if (to_mode == PrivilegeMode::M) {
  CSR[mepc].PC = $pc;
  CSR[mstatus].MPP = $bits(mode())[1:0];
  if (CSR[misa].H == 1'b1) {
    if (MXLEN == 64) {
      CSR[mstatus].MPV = $bits(mode())[2];
    } else {
      CSR[mstatush].MPV = $bits(mode())[2];
    }
    CSR[mtval2].VALUE = 0;
    CSR[mtinst].VALUE = 0;
  }
  CSR[mcause].CODE = $bits(code);
  CSR[mcause].INT = 1'b1;
  CSR[mtval].VALUE = 0;
  if (CSR[mtvec].MODE == 0) {
    $pc = {CSR[mtvec].BASE, 2'b00};
  } else if (CSR[mtvec].MODE == 1'b1) {
    $pc = {CSR[mtvec].BASE, 2'b00} + ($bits(code) * 4);
  }
} else if ((CSR[misa].S == 1'b1) && (to_mode == PrivilegeMode::S)) {
  CSR[sepc].PC = $pc;
  CSR[mstatus].SPP = $bits(mode())[0];
  if (CSR[misa].H == 1'b1) {
    CSR[hstatus].SPV = $bits(mode())[2];
  }
  CSR[scause].CODE = $bits(code);
  CSR[scause].INT = 1'b1;
  CSR[stval].VALUE = 0;
  if (CSR[stvec].MODE == 0) {
    $pc = {CSR[stvec].BASE, 2'b00};
  } else if (CSR[stvec].MODE == 1'b1) {
    $pc = {CSR[stvec].BASE, 2'b00} + ($bits(code) * 4);
  }
} else if ((CSR[misa].H == 1'b1) && (to_mode == PrivilegeMode::VS)) {
  CSR[vsepc].PC = $pc;
  CSR[vsstatus].SPP = $bits(mode())[0];
  CSR[vscause].CODE = $bits(code);
  CSR[vscause].INT = 1'b1;
  CSR[vstval].VALUE = 0;
  if (CSR[vstvec].MODE == 0) {
    $pc = {CSR[vstvec].BASE, 2'b00};
  } else if (CSR[vstvec].MODE == 1'b1) {
    $pc = {CSR[vstvec].BASE, 2'b00} + ($bits(code) * 4);
  }
}
set_mode_no_refresh(to_mode);

PrivilegeMode to_mode;
InterruptCode code;
(code, to_mode = choose_interrupt());
if (to_mode == PrivilegeMode::M) {
  CSR[mepc].PC = $pc;
  CSR[mstatus].MPP = $bits(mode())[1:0];
  CSR[mstatus].MPV = $bits(mode())[2];
  CSR[mtval2].VALUE = 0;
  CSR[mtinst].VALUE = 0;
  CSR[mcause].CODE = $bits(code);
  CSR[mcause].INT = 1'b1;
  CSR[mtval].VALUE = 0;
  if (CSR[mtvec].MODE == 0) {
    $pc = {CSR[mtvec].BASE, 2'b00};
  } else if (CSR[mtvec].MODE == 1'b1) {
    $pc = {CSR[mtvec].BASE, 2'b00} + ($bits(code) * 4);
  }
} else if ((to_mode == PrivilegeMode::S)) {
  CSR[sepc].PC = $pc;
  CSR[mstatus].SPP = $bits(mode())[0];
  CSR[hstatus].SPV = $bits(mode())[2];
  CSR[scause].CODE = $bits(code);
  CSR[scause].INT = 1'b1;
  CSR[stval].VALUE = 0;
  if (CSR[stvec].MODE == 0) {
    $pc = {CSR[stvec].BASE, 2'b00};
  } else if (CSR[stvec].MODE == 1'b1) {
    $pc = {CSR[stvec].BASE, 2'b00} + ($bits(code) * 4);
  }
} else if ((to_mode == PrivilegeMode::VS)) {
  CSR[vsepc].PC = $pc;
  CSR[vsstatus].SPP = $bits(mode())[0];
  CSR[vscause].CODE = $bits(code);
  CSR[vscause].INT = 1'b1;
  CSR[vstval].VALUE = 0;
  if (CSR[vstvec].MODE == 0) {
    $pc = {CSR[vstvec].BASE, 2'b00};
  } else if (CSR[vstvec].MODE == 1'b1) {
    $pc = {CSR[vstvec].BASE, 2'b00} + ($bits(code) * 4);
  }
}
set_mode_no_refresh(to_mode);