diff --git a/CMakeLists.txt b/CMakeLists.txt
index a9d5943..454de86 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -27,7 +27,7 @@ if(NOT TARGET dbt-rise-core)
     FetchContent_Declare(
         dbt_rise_core_git
         GIT_REPOSITORY "https://github.com/Minres/DBT-RISE-Core.git"
-        GIT_TAG 5d1ab03db17819fc113d3c4182cf0cee666085f2
+        GIT_TAG e17e1b58
         GIT_SHALLOW OFF
         UPDATE_DISCONNECTED NOT ${UPDATE_EXTERNAL_PROJECT} # When enabled, this option causes the update step to be skipped.
     )
@@ -176,7 +176,7 @@ install(TARGETS ${PROJECT_NAME} COMPONENT ${PROJECT_NAME}
     PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME} # headers for mac (note the different component -> different package)
     INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} # headers
 )
-install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/incl/iss COMPONENT ${PROJECT_NAME}
+install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/src/iss COMPONENT ${PROJECT_NAME}
     DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} # target directory
     FILES_MATCHING # install only matched files
     PATTERN "*.h" # select header files
diff --git a/gen_input/templates/asmjit/CORENAME.cpp.gtl b/gen_input/templates/asmjit/CORENAME.cpp.gtl
index 76b4845..4d1c614 100644
--- a/gen_input/templates/asmjit/CORENAME.cpp.gtl
+++ b/gen_input/templates/asmjit/CORENAME.cpp.gtl
@@ -346,7 +346,8 @@ private:
     }
 };
 
-template <typename ARCH> vm_impl<ARCH>::vm_impl() { this(new ARCH()); }
+template <typename ARCH> vm_impl<ARCH>::vm_impl()
+: vm_base<ARCH>(std::make_unique<ARCH>()) {}
 
 template <typename ARCH>
 vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
diff --git a/gen_input/templates/llvm/CORENAME.cpp.gtl b/gen_input/templates/llvm/CORENAME.cpp.gtl
index 36d5bb9..6f4e8ce 100644
--- a/gen_input/templates/llvm/CORENAME.cpp.gtl
+++ b/gen_input/templates/llvm/CORENAME.cpp.gtl
@@ -250,7 +250,8 @@ template <typename CODE_WORD> void debug_fn(CODE_WORD instr) {
     instr = 2 * x;
 }
 
-template <typename ARCH> vm_impl<ARCH>::vm_impl() { this(new ARCH()); }
+template <typename ARCH> vm_impl<ARCH>::vm_impl()
+: vm_base<ARCH>(std::make_unique<ARCH>()) {}
 
 template <typename ARCH>
 vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
diff --git a/softvector b/softvector
index 4441a9b..2278733 160000
--- a/softvector
+++ b/softvector
@@ -1 +1 @@
-Subproject commit 4441a9be0d19d2a2698791698bd720f914eee07e
+Subproject commit 22787332251bf0688c732b0ffd43817ed6a04c0b
diff --git a/src/iss/debugger/riscv_target_adapter.h b/src/iss/debugger/riscv_target_adapter.h
index 64988d4..7e1fc7d 100644
--- a/src/iss/debugger/riscv_target_adapter.h
+++ b/src/iss/debugger/riscv_target_adapter.h
@@ -52,9 +52,6 @@ char const* const get_csr_name(unsigned);
 constexpr auto vec_offset = 128U;
 constexpr auto csr_offset = 256U;
 
-using namespace iss::arch;
-using namespace iss::debugger;
-
 template <typename ARCH> class riscv_target_adapter : public target_adapter_base {
 public:
     riscv_target_adapter(server_if* srv, iss::arch_if* core)
@@ -117,7 +114,7 @@ template <typename ARCH> class riscv_target_adapter : public target_adapter_base
 
     status crc_query(uint64_t addr, size_t len, uint32_t& val) override;
 
-    status raw_query(std::string in_buf, std::string& out_buf) override;
+    status raw_query(const std::string& in_buf, std::string& out_buf) override;
 
     status threadinfo_query(int first, std::string& out_buf) override;
 
@@ -198,7 +195,7 @@ template <typename ARCH> status riscv_target_adapter<ARCH>::read_registers(std::
     for(size_t i = 0; i < 33; ++i) {
         if(i < arch::traits<ARCH>::RFS || i == arch::traits<ARCH>::PC) {
             auto reg_no = i < 32 ? start_reg + i : arch::traits<ARCH>::PC;
-            unsigned offset = traits<ARCH>::reg_byte_offsets[reg_no];
+            unsigned offset = iss::arch::traits<ARCH>::reg_byte_offsets[reg_no];
             for(size_t j = 0; j < arch::traits<ARCH>::XLEN / 8; ++j) {
                 data.push_back(*(reg_base + offset + j));
                 avail.push_back(0xff);
@@ -220,11 +217,13 @@ template <typename ARCH> status riscv_target_adapter<ARCH>::write_registers(cons
     auto iter_end = data.data() + data.size();
     for(size_t i = 0; i < 33 && iter < iter_end; ++i) {
         auto reg_width = arch::traits<ARCH>::XLEN / 8;
+        if(iter_end - iter < static_cast<decltype(iter_end - iter)>(reg_width))
+            return Err;
         if(i < arch::traits<ARCH>::RFS) {
-            auto offset = traits<ARCH>::reg_byte_offsets[start_reg + i];
+            auto offset = iss::arch::traits<ARCH>::reg_byte_offsets[start_reg + i];
             std::copy(iter, iter + reg_width, reg_base + offset);
         } else if(i == 32) {
-            auto offset = traits<ARCH>::reg_byte_offsets[arch::traits<ARCH>::PC];
+            auto offset = iss::arch::traits<ARCH>::reg_byte_offsets[arch::traits<ARCH>::PC];
             std::copy(iter, iter + reg_width, reg_base + offset);
         }
         iter += reg_width;
@@ -234,24 +233,32 @@ template <typename ARCH> status riscv_target_adapter<ARCH>::write_registers(cons
 
 template <typename ARCH>
 status riscv_target_adapter<ARCH>::read_single_register(unsigned int reg_no, std::vector<uint8_t>& data, std::vector<uint8_t>& avail) {
+    data.clear();
+    avail.clear();
     if(reg_no < vec_offset) {
-        // auto reg_size = arch::traits<ARCH>::reg_bit_width(static_cast<typename
-        // arch::traits<ARCH>::reg_e>(reg_no))/8;
+        if(reg_no >= iss::arch::traits<ARCH>::reg_bit_widths.size() || reg_no >= iss::arch::traits<ARCH>::reg_byte_offsets.size())
+            return Err;
         auto* reg_base = core->get_regs_base_ptr();
         auto reg_width = arch::traits<ARCH>::reg_bit_widths[reg_no] / 8;
+        if(reg_width == 0)
+            return Err;
         data.resize(reg_width);
         avail.resize(reg_width);
-        auto offset = traits<ARCH>::reg_byte_offsets[reg_no];
+        auto offset = iss::arch::traits<ARCH>::reg_byte_offsets[reg_no];
         std::copy(reg_base + offset, reg_base + offset + reg_width, data.begin());
         std::fill(avail.begin(), avail.end(), 0xff);
     } else if(reg_no < csr_offset) {
         // TODO: implement vector register reading
+        return Err;
     } else {
-        typed_addr_t<iss::address_type::PHYSICAL> a(iss::access_type::DEBUG_READ, traits<ARCH>::CSR, reg_no - csr_offset);
-        data.resize(sizeof(typename traits<ARCH>::reg_t));
-        avail.resize(sizeof(typename traits<ARCH>::reg_t));
-        std::fill(avail.begin(), avail.end(), 0xff);
-        core->read(a, data.size(), data.data());
+        typed_addr_t<iss::address_type::PHYSICAL> a(iss::access_type::DEBUG_READ, iss::arch::traits<ARCH>::CSR, reg_no - csr_offset);
+        data.resize(sizeof(typename iss::arch::traits<ARCH>::reg_t));
+        avail.resize(sizeof(typename iss::arch::traits<ARCH>::reg_t));
+        auto res = core->read(a, data.size(), data.data());
+        if(res != Ok) {
+            std::fill(avail.begin(), avail.end(), 0);
+            return res;
+        }
         std::fill(avail.begin(), avail.end(), 0xff);
     }
     return data.size() > 0 ? Ok : Err;
@@ -259,29 +266,40 @@ status riscv_target_adapter<ARCH>::read_single_register(unsigned int reg_no, std
 
 template <typename ARCH> status riscv_target_adapter<ARCH>::write_single_register(unsigned int reg_no, const std::vector<uint8_t>& data) {
     if(reg_no < vec_offset) {
+        if(reg_no >= iss::arch::traits<ARCH>::reg_bit_widths.size() || reg_no >= iss::arch::traits<ARCH>::reg_byte_offsets.size())
+            return Err;
         auto* reg_base = core->get_regs_base_ptr();
         auto reg_width = arch::traits<ARCH>::reg_bit_widths[static_cast<typename arch::traits<ARCH>::reg_e>(reg_no)] / 8;
-        auto offset = traits<ARCH>::reg_byte_offsets[reg_no];
+        if(data.size() < reg_width)
+            return Err;
+        auto offset = iss::arch::traits<ARCH>::reg_byte_offsets[reg_no];
         std::copy(data.begin(), data.begin() + reg_width, reg_base + offset);
     } else if(reg_no < csr_offset) {
         // TODO: implement vector register writing
+        return Err;
     } else {
-        typed_addr_t<iss::address_type::PHYSICAL> a(iss::access_type::DEBUG_WRITE, traits<ARCH>::CSR, reg_no - csr_offset);
-        core->write(a, data.size(), data.data());
+        typed_addr_t<iss::address_type::PHYSICAL> a(iss::access_type::DEBUG_WRITE, iss::arch::traits<ARCH>::CSR, reg_no - csr_offset);
+        auto res = core->write(a, data.size(), data.data());
+        if(res != Ok)
+            return res;
     }
     return Ok;
 }
 
 template <typename ARCH> status riscv_target_adapter<ARCH>::read_mem(uint64_t addr, std::vector<uint8_t>& data) {
+    if(!srv)
+        return Err;
     auto a = map_addr({iss::address_type::VIRTUAL, iss::access_type::DEBUG_READ, 0, addr});
     auto f = [&]() -> status { return core->read(a, data.size(), data.data()); };
-    return srv->execute_syncronized(f);
+    return srv->execute_synchronized(f);
 }
 
 template <typename ARCH> status riscv_target_adapter<ARCH>::write_mem(uint64_t addr, const std::vector<uint8_t>& data) {
+    if(!srv)
+        return Err;
     auto a = map_addr({iss::address_type::VIRTUAL, iss::access_type::DEBUG_WRITE, 0, addr});
     auto f = [&]() -> status { return core->write(a, data.size(), data.data()); };
-    return srv->execute_syncronized(f);
+    return srv->execute_synchronized(f);
 }
 
 template <typename ARCH>
@@ -298,7 +316,9 @@ template <typename ARCH> status riscv_target_adapter<ARCH>::offsets_query(uint64
 
 template <typename ARCH> status riscv_target_adapter<ARCH>::crc_query(uint64_t addr, size_t len, uint32_t& val) { return NotSupported; }
 
-template <typename ARCH> status riscv_target_adapter<ARCH>::raw_query(std::string in_buf, std::string& out_buf) { return NotSupported; }
+template <typename ARCH> status riscv_target_adapter<ARCH>::raw_query(const std::string& in_buf, std::string& out_buf) {
+    return NotSupported;
+}
 
 template <typename ARCH> status riscv_target_adapter<ARCH>::threadinfo_query(int first, std::string& out_buf) {
     if(first) {
@@ -365,9 +385,9 @@ status riscv_target_adapter<ARCH>::resume_from_addr(bool step, int sig, uint64_t
                                                     std::function<void(unsigned)> stop_callback) {
     auto* reg_base = core->get_regs_base_ptr();
     auto reg_width = arch::traits<ARCH>::reg_bit_widths[arch::traits<ARCH>::PC] / 8;
-    auto offset = traits<ARCH>::reg_byte_offsets[arch::traits<ARCH>::PC];
+    auto offset = iss::arch::traits<ARCH>::reg_byte_offsets[arch::traits<ARCH>::PC];
     const uint8_t* iter = reinterpret_cast<const uint8_t*>(&addr);
-    std::copy(iter, iter + reg_width, reg_base);
+    std::copy(iter, iter + reg_width, reg_base + offset);
     return resume_from_current(step, sig, thread, stop_callback);
 }
 
@@ -415,8 +435,8 @@ template <typename ARCH> status riscv_target_adapter<ARCH>::target_xml_query(std
             oss << "  </feature>\n";
         }
         std::vector<uint8_t> data;
-        data.resize(sizeof(typename traits<ARCH>::reg_t));
-        typed_addr_t<iss::address_type::PHYSICAL> vlen_addr(iss::access_type::DEBUG_READ, traits<ARCH>::CSR, 0xC22);
+        data.resize(sizeof(typename iss::arch::traits<ARCH>::reg_t));
+        typed_addr_t<iss::address_type::PHYSICAL> vlen_addr(iss::access_type::DEBUG_READ, iss::arch::traits<ARCH>::CSR, 0xC22);
         auto res = core->read(vlen_addr, data.size(), data.data());
         if(res == iss::Ok) {
             auto bitsize = data[0] * 8L;
@@ -438,9 +458,9 @@ template <typename ARCH> status riscv_target_adapter<ARCH>::target_xml_query(std
         }
         oss << "  <feature name=\"org.gnu.gdb.riscv.csr\">\n";
         std::vector<uint8_t> avail;
-        avail.resize(sizeof(typename traits<ARCH>::reg_t));
+        avail.resize(sizeof(typename iss::arch::traits<ARCH>::reg_t));
         for(auto i = 0U; i < 4096; ++i) {
-            typed_addr_t<iss::address_type::PHYSICAL> a(iss::access_type::DEBUG_READ, traits<ARCH>::CSR, i);
+            typed_addr_t<iss::address_type::PHYSICAL> a(iss::access_type::DEBUG_READ, iss::arch::traits<ARCH>::CSR, i);
             std::fill(avail.begin(), avail.end(), 0xff);
             auto res = core->read(a, data.size(), data.data());
             if(res == iss::Ok) {
diff --git a/src/iss/semihosting/semihosting.cpp b/src/iss/semihosting/semihosting.cpp
index 0e4d63b..368eec2 100644
--- a/src/iss/semihosting/semihosting.cpp
+++ b/src/iss/semihosting/semihosting.cpp
@@ -33,6 +33,9 @@
  ******************************************************************************/
 
 #include "semihosting.h"
+#include <algorithm>
+#include <array>
+#include <cerrno>
 #include <chrono>
 #include <cstdint>
 #include <iss/vm_types.h>
@@ -42,16 +45,16 @@
 
 const char* SYS_OPEN_MODES_STRS[] = {"r", "rb", "r+", "r+b", "w", "wb", "w+", "w+b", "a", "ab", "a+", "a+b"};
 
-template <typename T> T sh_read_field(iss::arch_if* arch_if_ptr, T addr, int len = 4) {
-    uint8_t bytes[4];
-    auto res = arch_if_ptr->read({iss::address_type::LOGICAL, iss::access_type::DEBUG_READ, 0, addr}, 4, &bytes[0]);
-    // auto res = arch_if_ptr->read(iss::address_type::PHYSICAL, iss::access_type::DEBUG_READ, 0, *parameter, 1, &character);
-
-    if(res != iss::Ok) {
+template <typename T> T sh_read_field(iss::arch_if* arch_if_ptr, T addr, size_t len = sizeof(T)) {
+    std::array<uint8_t, sizeof(T)> bytes{};
+    len = std::min(len, sizeof(T));
+    auto res = arch_if_ptr->read({iss::address_type::LOGICAL, iss::access_type::DEBUG_READ, 0, addr}, len, bytes.data());
+    if(res != iss::Ok)
         return 0; // TODO THROW ERROR
-    } else
-        return static_cast<T>(bytes[0]) | (static_cast<T>(bytes[1]) << 8) | (static_cast<T>(bytes[2]) << 16) |
-               (static_cast<T>(bytes[3]) << 24);
+    T value{0};
+    for(size_t i = 0; i < len; ++i)
+        value |= static_cast<T>(bytes[i]) << (8 * i);
+    return value;
 }
 
 template <typename T> std::string sh_read_string(iss::arch_if* arch_if_ptr, T addr, T str_len) {
@@ -67,6 +70,16 @@ template <typename T> void semihosting_callback<T>::operator()(iss::arch_if* arc
     static std::map<T, FILE*> openFiles;
     static T file_count = 3;
     static T semihostingErrno;
+    auto get_open_file = [call_number, this](T file_handle, FILE*& file) -> bool {
+        auto it = openFiles.find(file_handle);
+        if(it == openFiles.end() || it->second == nullptr) {
+            semihostingErrno = EBADF;
+            *call_number = static_cast<T>(-1);
+            return false;
+        }
+        file = it->second;
+        return true;
+    };
 
     switch(static_cast<semihosting_syscalls>(*call_number)) {
     case semihosting_syscalls::SYS_CLOCK: {
@@ -78,11 +91,13 @@ template <typename T> void semihosting_callback<T>::operator()(iss::arch_if* arc
     }
     case semihosting_syscalls::SYS_CLOSE: {
         T file_handle = *parameter;
-        if(openFiles.size() <= file_handle && file_handle < 0) {
+        auto it = openFiles.find(file_handle);
+        if(it == openFiles.end() || it->second == nullptr) {
             semihostingErrno = EBADF;
+            *call_number = static_cast<T>(-1);
             return;
         }
-        auto file = openFiles[file_handle];
+        auto file = it->second;
         openFiles.erase(file_handle);
         if(!(file == stdin || file == stdout || file == stderr)) {
             int i = fclose(file);
@@ -112,7 +127,9 @@ template <typename T> void semihosting_callback<T>::operator()(iss::arch_if* arc
     }
     case semihosting_syscalls::SYS_FLEN: {
         T file_handle = *parameter;
-        auto file = openFiles[file_handle];
+        FILE* file = nullptr;
+        if(!get_open_file(file_handle, file))
+            return;
 
         size_t currentPos = ftell(file);
         if(currentPos < 0)
@@ -151,7 +168,7 @@ template <typename T> void semihosting_callback<T>::operator()(iss::arch_if* arc
         // TODO LOG INFO
 
         if(mode >= 12) {
-            // TODO throw ERROR
+            *call_number = static_cast<T>(-1);
             return;
         }
 
@@ -166,7 +183,7 @@ template <typename T> void semihosting_callback<T>::operator()(iss::arch_if* arc
         } else {
             file = fopen(path_str.c_str(), SYS_OPEN_MODES_STRS[mode]);
             if(file == nullptr) {
-                // TODO throw error
+                *call_number = static_cast<T>(-1);
                 return;
             }
         }
@@ -179,8 +196,9 @@ template <typename T> void semihosting_callback<T>::operator()(iss::arch_if* arc
         T file_handle = sh_read_field<T>(arch_if_ptr, (*parameter) + 4);
         T addr = sh_read_field<T>(arch_if_ptr, *parameter);
         T count = sh_read_field<T>(arch_if_ptr, (*parameter) + 8);
-
-        auto file = openFiles[file_handle];
+        FILE* file = nullptr;
+        if(!get_open_file(file_handle, file))
+            return;
 
         std::vector<uint8_t> buffer(count);
         size_t num_read = 0;
@@ -199,7 +217,7 @@ template <typename T> void semihosting_callback<T>::operator()(iss::arch_if* arc
         }
         buffer.resize(num_read);
         for(int i = 0; i < num_read; i++) {
-            auto res = arch_if_ptr->write({iss::address_type::LOGICAL, iss::access_type::DEBUG_READ, 0, addr + i}, 1, &buffer[i]);
+            auto res = arch_if_ptr->write({iss::address_type::LOGICAL, iss::access_type::DEBUG_WRITE, 0, addr + i}, 1, &buffer[i]);
             if(res != iss::Ok)
                 return;
         }
@@ -238,7 +256,9 @@ template <typename T> void semihosting_callback<T>::operator()(iss::arch_if* arc
     case semihosting_syscalls::SYS_SEEK: {
         T file_handle = sh_read_field<T>(arch_if_ptr, *parameter);
         T pos = sh_read_field<T>(arch_if_ptr, (*parameter) + 1);
-        auto file = openFiles[file_handle];
+        FILE* file = nullptr;
+        if(!get_open_file(file_handle, file))
+            return;
 
         int retval = fseek(file, pos, SEEK_SET);
         if(retval < 0)
@@ -275,9 +295,9 @@ template <typename T> void semihosting_callback<T>::operator()(iss::arch_if* arc
         ss << "tmp/file-" << std::setfill('0') << std::setw(3) << identifier;
         std::string filename = ss.str();
 
-        for(int i = 0; i < buffer_len; i++) {
+        for(int i = 0; i < buffer_len && i < static_cast<int>(filename.size()); i++) {
             uint8_t character = filename[i];
-            auto res = arch_if_ptr->write({iss::address_type::LOGICAL, iss::access_type::DEBUG_READ, 0, (*parameter) + i}, 1, &character);
+            auto res = arch_if_ptr->write({iss::address_type::LOGICAL, iss::access_type::DEBUG_WRITE, 0, (*parameter) + i}, 1, &character);
             if(res != iss::Ok)
                 return;
         }
@@ -287,8 +307,9 @@ template <typename T> void semihosting_callback<T>::operator()(iss::arch_if* arc
         T file_handle = sh_read_field<T>(arch_if_ptr, (*parameter) + 4);
         T addr = sh_read_field<T>(arch_if_ptr, *parameter);
         T count = sh_read_field<T>(arch_if_ptr, (*parameter) + 8);
-
-        auto file = openFiles[file_handle];
+        FILE* file = nullptr;
+        if(!get_open_file(file_handle, file))
+            return;
         std::string str = sh_read_string<T>(arch_if_ptr, addr, count);
         fwrite(&str[0], 1, count, file);
         break;
diff --git a/src/sysc/register_cores.cpp b/src/sysc/register_cores.cpp
index cecba28..01e7a88 100644
--- a/src/sysc/register_cores.cpp
+++ b/src/sysc/register_cores.cpp
@@ -134,12 +134,12 @@ using namespace sysc;
 volatile std::array<bool, 4> riscv_init = {
     iss_factory::instance().register_creator("rv32imac_m:llvm",
                                              [](unsigned gdb_port, sysc::riscv::core_complex_if* cc) -> iss_factory::base_t {
-                                                 auto* cpu = new core2sc_adapter<arch::riscv_hart_m_p<arch::rv32imc>>(cc);
+                                                 auto* cpu = new core2sc_adapter<arch::riscv_hart_m_p<arch::rv32imac>>(cc);
                                                  return {sysc::core_ptr{cpu}, vm_ptr{create(static_cast<arch::rv32imac*>(cpu), gdb_port)}};
                                              }),
     iss_factory::instance().register_creator("rv32imac_mu:llvm",
                                              [](unsigned gdb_port, sysc::riscv::core_complex_if* cc) -> iss_factory::base_t {
-                                                 auto* cpu = new core2sc_adapter<arch::riscv_hart_mu_p<arch::rv32imc>>(cc);
+                                                 auto* cpu = new core2sc_adapter<arch::riscv_hart_mu_p<arch::rv32imac>>(cc);
                                                  return {sysc::core_ptr{cpu}, vm_ptr{create(static_cast<arch::rv32imac*>(cpu), gdb_port)}};
                                              }),
     iss_factory::instance().register_creator("tgc5c_m:llvm",
diff --git a/src/sysc/register_rv32gcv.cpp b/src/sysc/register_rv32gcv.cpp
index 0dcb46d..819e5ae 100644
--- a/src/sysc/register_rv32gcv.cpp
+++ b/src/sysc/register_rv32gcv.cpp
@@ -58,21 +58,22 @@ volatile std::array<bool, 2 + 1> rv32gcv_init = {
         })
 };
 }
-#if defined(WITH_LLVM)
-namespace llvm {
-using namespace sysc;
-volatile std::array<bool, 2> rv32gcv_init = {
-        iss_factory::instance().register_creator("rv32gcv_m:llvm", [](unsigned gdb_port, sysc::riscv::core_complex_if* cc) -> iss_factory::base_t {
-            auto* cpu = new core2sc_adapter<arch::riscv_hart_m_p<arch::rv32gcv>>(cc);
-            return {sysc::core_ptr{cpu}, vm_ptr{create(static_cast<arch::rv32gcv*>(cpu), gdb_port)}};
-        }),
-        iss_factory::instance().register_creator("rv32gcv_mu:llvm", [](unsigned gdb_port, sysc::riscv::core_complex_if* cc) -> iss_factory::base_t {
-            auto* cpu = new core2sc_adapter<arch::riscv_hart_mu_p<arch::rv32gcv>>(cc);
-            return {sysc::core_ptr{cpu}, vm_ptr{create(static_cast<arch::rv32gcv*>(cpu), gdb_port)}};
-        })
-};
-}
-#endif
+// TODO: generate for and test with LLVM
+// #if defined(WITH_LLVM)
+// namespace llvm {
+// using namespace sysc;
+// volatile std::array<bool, 2> rv32gcv_init = {
+//         iss_factory::instance().register_creator("rv32gcv_m:llvm", [](unsigned gdb_port, sysc::riscv::core_complex_if* cc) -> iss_factory::base_t {
+//             auto* cpu = new core2sc_adapter<arch::riscv_hart_m_p<arch::rv32gcv>>(cc);
+//             return {sysc::core_ptr{cpu}, vm_ptr{create(static_cast<arch::rv32gcv*>(cpu), gdb_port)}};
+//         }),
+//         iss_factory::instance().register_creator("rv32gcv_mu:llvm", [](unsigned gdb_port, sysc::riscv::core_complex_if* cc) -> iss_factory::base_t {
+//             auto* cpu = new core2sc_adapter<arch::riscv_hart_mu_p<arch::rv32gcv>>(cc);
+//             return {sysc::core_ptr{cpu}, vm_ptr{create(static_cast<arch::rv32gcv*>(cpu), gdb_port)}};
+//         })
+// };
+// }
+// #endif
 #if defined(WITH_ASMJIT)
 namespace asmjit {
 using namespace sysc;
diff --git a/src/sysc/register_rv64gcv.cpp b/src/sysc/register_rv64gcv.cpp
index be8ac2d..0da658d 100644
--- a/src/sysc/register_rv64gcv.cpp
+++ b/src/sysc/register_rv64gcv.cpp
@@ -58,21 +58,22 @@ volatile std::array<bool, 2 + 1> rv64gcv_init = {
         })
 };
 }
-#if defined(WITH_LLVM)
-namespace llvm {
-using namespace sysc;
-volatile std::array<bool, 2> rv64gcv_init = {
-        iss_factory::instance().register_creator("rv64gcv_m:llvm", [](unsigned gdb_port, sysc::riscv::core_complex_if* cc) -> iss_factory::base_t {
-            auto* cpu = new core2sc_adapter<arch::riscv_hart_m_p<arch::rv64gcv>>(cc);
-            return {sysc::core_ptr{cpu}, vm_ptr{create(static_cast<arch::rv64gcv*>(cpu), gdb_port)}};
-        }),
-        iss_factory::instance().register_creator("rv64gcv_mu:llvm", [](unsigned gdb_port, sysc::riscv::core_complex_if* cc) -> iss_factory::base_t {
-            auto* cpu = new core2sc_adapter<arch::riscv_hart_mu_p<arch::rv64gcv>>(cc);
-            return {sysc::core_ptr{cpu}, vm_ptr{create(static_cast<arch::rv64gcv*>(cpu), gdb_port)}};
-        })
-};
-}
-#endif
+// TODO: generate for and test with LLVM
+// #if defined(WITH_LLVM)
+// namespace llvm {
+// using namespace sysc;
+// volatile std::array<bool, 2> rv64gcv_init = {
+//         iss_factory::instance().register_creator("rv64gcv_m:llvm", [](unsigned gdb_port, sysc::riscv::core_complex_if* cc) -> iss_factory::base_t {
+//             auto* cpu = new core2sc_adapter<arch::riscv_hart_m_p<arch::rv64gcv>>(cc);
+//             return {sysc::core_ptr{cpu}, vm_ptr{create(static_cast<arch::rv64gcv*>(cpu), gdb_port)}};
+//         }),
+//         iss_factory::instance().register_creator("rv64gcv_mu:llvm", [](unsigned gdb_port, sysc::riscv::core_complex_if* cc) -> iss_factory::base_t {
+//             auto* cpu = new core2sc_adapter<arch::riscv_hart_mu_p<arch::rv64gcv>>(cc);
+//             return {sysc::core_ptr{cpu}, vm_ptr{create(static_cast<arch::rv64gcv*>(cpu), gdb_port)}};
+//         })
+// };
+// }
+// #endif
 #if defined(WITH_ASMJIT)
 namespace asmjit {
 using namespace sysc;
diff --git a/src/vm/asmjit/vm_rv32gc.cpp b/src/vm/asmjit/vm_rv32gc.cpp
index b4d12f2..198ba4a 100644
--- a/src/vm/asmjit/vm_rv32gc.cpp
+++ b/src/vm/asmjit/vm_rv32gc.cpp
@@ -9967,7 +9967,8 @@ template <typename ARCH> class vm_impl : public iss::asmjit::vm_base<ARCH> {
     }
 };
 
-template <typename ARCH> vm_impl<ARCH>::vm_impl() { this(new ARCH()); }
+template <typename ARCH> vm_impl<ARCH>::vm_impl()
+: vm_base<ARCH>(std::make_unique<ARCH>()) {}
 
 template <typename ARCH>
 vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
diff --git a/src/vm/asmjit/vm_rv32gcv.cpp b/src/vm/asmjit/vm_rv32gcv.cpp
index e97e5e9..9662cf0 100644
--- a/src/vm/asmjit/vm_rv32gcv.cpp
+++ b/src/vm/asmjit/vm_rv32gcv.cpp
@@ -85374,7 +85374,8 @@ template <typename ARCH> class vm_impl : public iss::asmjit::vm_base<ARCH> {
     }
 };
 
-template <typename ARCH> vm_impl<ARCH>::vm_impl() { this(new ARCH()); }
+template <typename ARCH> vm_impl<ARCH>::vm_impl()
+: vm_base<ARCH>(std::make_unique<ARCH>()) {}
 
 template <typename ARCH>
 vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
diff --git a/src/vm/asmjit/vm_rv32i.cpp b/src/vm/asmjit/vm_rv32i.cpp
index 1565685..4231527 100644
--- a/src/vm/asmjit/vm_rv32i.cpp
+++ b/src/vm/asmjit/vm_rv32i.cpp
@@ -2810,7 +2810,8 @@ template <typename ARCH> class vm_impl : public iss::asmjit::vm_base<ARCH> {
     }
 };
 
-template <typename ARCH> vm_impl<ARCH>::vm_impl() { this(new ARCH()); }
+template <typename ARCH> vm_impl<ARCH>::vm_impl()
+: vm_base<ARCH>(std::make_unique<ARCH>()) {}
 
 template <typename ARCH>
 vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
diff --git a/src/vm/asmjit/vm_rv32imac.cpp b/src/vm/asmjit/vm_rv32imac.cpp
index f56c43f..fd4bf87 100644
--- a/src/vm/asmjit/vm_rv32imac.cpp
+++ b/src/vm/asmjit/vm_rv32imac.cpp
@@ -5410,7 +5410,8 @@ template <typename ARCH> class vm_impl : public iss::asmjit::vm_base<ARCH> {
     }
 };
 
-template <typename ARCH> vm_impl<ARCH>::vm_impl() { this(new ARCH()); }
+template <typename ARCH> vm_impl<ARCH>::vm_impl()
+: vm_base<ARCH>(std::make_unique<ARCH>()) {}
 
 template <typename ARCH>
 vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
diff --git a/src/vm/asmjit/vm_rv64gc.cpp b/src/vm/asmjit/vm_rv64gc.cpp
index c1faf78..66800ec 100644
--- a/src/vm/asmjit/vm_rv64gc.cpp
+++ b/src/vm/asmjit/vm_rv64gc.cpp
@@ -12548,7 +12548,8 @@ template <typename ARCH> class vm_impl : public iss::asmjit::vm_base<ARCH> {
     }
 };
 
-template <typename ARCH> vm_impl<ARCH>::vm_impl() { this(new ARCH()); }
+template <typename ARCH> vm_impl<ARCH>::vm_impl()
+: vm_base<ARCH>(std::make_unique<ARCH>()) {}
 
 template <typename ARCH>
 vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
diff --git a/src/vm/asmjit/vm_rv64gcv.cpp b/src/vm/asmjit/vm_rv64gcv.cpp
index bedf7be..7426209 100644
--- a/src/vm/asmjit/vm_rv64gcv.cpp
+++ b/src/vm/asmjit/vm_rv64gcv.cpp
@@ -87955,7 +87955,8 @@ template <typename ARCH> class vm_impl : public iss::asmjit::vm_base<ARCH> {
     }
 };
 
-template <typename ARCH> vm_impl<ARCH>::vm_impl() { this(new ARCH()); }
+template <typename ARCH> vm_impl<ARCH>::vm_impl()
+: vm_base<ARCH>(std::make_unique<ARCH>()) {}
 
 template <typename ARCH>
 vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
diff --git a/src/vm/asmjit/vm_rv64i.cpp b/src/vm/asmjit/vm_rv64i.cpp
index 3dd28e4..f1cc199 100644
--- a/src/vm/asmjit/vm_rv64i.cpp
+++ b/src/vm/asmjit/vm_rv64i.cpp
@@ -3465,7 +3465,8 @@ template <typename ARCH> class vm_impl : public iss::asmjit::vm_base<ARCH> {
     }
 };
 
-template <typename ARCH> vm_impl<ARCH>::vm_impl() { this(new ARCH()); }
+template <typename ARCH> vm_impl<ARCH>::vm_impl()
+: vm_base<ARCH>(std::make_unique<ARCH>()) {}
 
 template <typename ARCH>
 vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
diff --git a/src/vm/asmjit/vm_tgc5c.cpp b/src/vm/asmjit/vm_tgc5c.cpp
index f9b56d7..6a82710 100644
--- a/src/vm/asmjit/vm_tgc5c.cpp
+++ b/src/vm/asmjit/vm_tgc5c.cpp
@@ -4704,7 +4704,8 @@ template <typename ARCH> class vm_impl : public iss::asmjit::vm_base<ARCH> {
     }
 };
 
-template <typename ARCH> vm_impl<ARCH>::vm_impl() { this(new ARCH()); }
+template <typename ARCH> vm_impl<ARCH>::vm_impl()
+: vm_base<ARCH>(std::make_unique<ARCH>()) {}
 
 template <typename ARCH>
 vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
diff --git a/src/vm/llvm/vm_rv32gc.cpp b/src/vm/llvm/vm_rv32gc.cpp
index 0f20537..b92ed21 100644
--- a/src/vm/llvm/vm_rv32gc.cpp
+++ b/src/vm/llvm/vm_rv32gc.cpp
@@ -9641,7 +9641,8 @@ template <typename CODE_WORD> void debug_fn(CODE_WORD instr) {
     instr = 2 * x;
 }
 
-template <typename ARCH> vm_impl<ARCH>::vm_impl() { this(new ARCH()); }
+template <typename ARCH> vm_impl<ARCH>::vm_impl()
+: vm_base<ARCH>(std::make_unique<ARCH>()) {}
 
 template <typename ARCH>
 vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
diff --git a/src/vm/llvm/vm_rv32i.cpp b/src/vm/llvm/vm_rv32i.cpp
index b1598bd..e271a8a 100644
--- a/src/vm/llvm/vm_rv32i.cpp
+++ b/src/vm/llvm/vm_rv32i.cpp
@@ -2901,7 +2901,8 @@ template <typename CODE_WORD> void debug_fn(CODE_WORD instr) {
     instr = 2 * x;
 }
 
-template <typename ARCH> vm_impl<ARCH>::vm_impl() { this(new ARCH()); }
+template <typename ARCH> vm_impl<ARCH>::vm_impl()
+: vm_base<ARCH>(std::make_unique<ARCH>()) {}
 
 template <typename ARCH>
 vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
diff --git a/src/vm/llvm/vm_rv32imac.cpp b/src/vm/llvm/vm_rv32imac.cpp
index 0357511..6db2415 100644
--- a/src/vm/llvm/vm_rv32imac.cpp
+++ b/src/vm/llvm/vm_rv32imac.cpp
@@ -5667,7 +5667,8 @@ template <typename CODE_WORD> void debug_fn(CODE_WORD instr) {
     instr = 2 * x;
 }
 
-template <typename ARCH> vm_impl<ARCH>::vm_impl() { this(new ARCH()); }
+template <typename ARCH> vm_impl<ARCH>::vm_impl()
+: vm_base<ARCH>(std::make_unique<ARCH>()) {}
 
 template <typename ARCH>
 vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
diff --git a/src/vm/llvm/vm_rv64gc.cpp b/src/vm/llvm/vm_rv64gc.cpp
index bc2285b..0757fc1 100644
--- a/src/vm/llvm/vm_rv64gc.cpp
+++ b/src/vm/llvm/vm_rv64gc.cpp
@@ -12319,7 +12319,8 @@ template <typename CODE_WORD> void debug_fn(CODE_WORD instr) {
     instr = 2 * x;
 }
 
-template <typename ARCH> vm_impl<ARCH>::vm_impl() { this(new ARCH()); }
+template <typename ARCH> vm_impl<ARCH>::vm_impl()
+: vm_base<ARCH>(std::make_unique<ARCH>()) {}
 
 template <typename ARCH>
 vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
diff --git a/src/vm/llvm/vm_rv64i.cpp b/src/vm/llvm/vm_rv64i.cpp
index bf491d1..39d383a 100644
--- a/src/vm/llvm/vm_rv64i.cpp
+++ b/src/vm/llvm/vm_rv64i.cpp
@@ -3610,7 +3610,8 @@ template <typename CODE_WORD> void debug_fn(CODE_WORD instr) {
     instr = 2 * x;
 }
 
-template <typename ARCH> vm_impl<ARCH>::vm_impl() { this(new ARCH()); }
+template <typename ARCH> vm_impl<ARCH>::vm_impl()
+: vm_base<ARCH>(std::make_unique<ARCH>()) {}
 
 template <typename ARCH>
 vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
diff --git a/src/vm/llvm/vm_tgc5c.cpp b/src/vm/llvm/vm_tgc5c.cpp
index b607f0a..13ea642 100644
--- a/src/vm/llvm/vm_tgc5c.cpp
+++ b/src/vm/llvm/vm_tgc5c.cpp
@@ -4922,7 +4922,8 @@ template <typename CODE_WORD> void debug_fn(CODE_WORD instr) {
     instr = 2 * x;
 }
 
-template <typename ARCH> vm_impl<ARCH>::vm_impl() { this(new ARCH()); }
+template <typename ARCH> vm_impl<ARCH>::vm_impl()
+: vm_base<ARCH>(std::make_unique<ARCH>()) {}
 
 template <typename ARCH>
 vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
diff --git a/src/vm/tcc/vm_tgc5c.cpp b/src/vm/tcc/vm_tgc5c.cpp
index 8846647..a46642e 100644
--- a/src/vm/tcc/vm_tgc5c.cpp
+++ b/src/vm/tcc/vm_tgc5c.cpp
@@ -3721,7 +3721,8 @@ template <typename CODE_WORD> void debug_fn(CODE_WORD instr) {
     instr = 2 * x;
 }
 
-template <typename ARCH> vm_impl<ARCH>::vm_impl() { this(new ARCH()); }
+template <typename ARCH> vm_impl<ARCH>::vm_impl()
+: vm_base<ARCH>(std::make_unique<ARCH>()) {}
 
 template <typename ARCH>
 vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
diff --git a/src/vm/vector_functions.h b/src/vm/vector_functions.h
index 83b1552..6577a86 100644
--- a/src/vm/vector_functions.h
+++ b/src/vm/vector_functions.h
@@ -97,7 +97,7 @@ uint64_t vlseg(void* core, uint8_t* V, uint64_t vl, uint64_t vstart, softvector:
     case 0b111:
         return softvector::vector_load_store<VLEN, uint64_t>(core, softvec_read, V, vl, vstart, vtype, vm, vd, rs1_val, segment_size);
     default:
-        throw new std::runtime_error("Unsupported width bit value");
+        throw std::runtime_error("Unsupported width bit value");
     }
 }
 template <size_t VLEN>
@@ -113,7 +113,7 @@ uint64_t vsseg(void* core, uint8_t* V, uint64_t vl, uint64_t vstart, softvector:
     case 0b111:
         return softvector::vector_load_store<VLEN, uint64_t>(core, softvec_write, V, vl, vstart, vtype, vm, vd, rs1_val, segment_size);
     default:
-        throw new std::runtime_error("Unsupported width bit value");
+        throw std::runtime_error("Unsupported width bit value");
     }
 }
 template <size_t VLEN>
@@ -133,7 +133,7 @@ uint64_t vlsseg(void* core, uint8_t* V, uint64_t vl, uint64_t vstart, softvector
         return softvector::vector_load_store<VLEN, uint64_t>(core, softvec_read, V, vl, vstart, vtype, vm, vd, rs1_val, segment_size,
                                                              stride, true);
     default:
-        throw new std::runtime_error("Unsupported width bit value");
+        throw std::runtime_error("Unsupported width bit value");
     }
 }
 template <size_t VLEN>
@@ -153,7 +153,7 @@ uint64_t vssseg(void* core, uint8_t* V, uint64_t vl, uint64_t vstart, softvector
         return softvector::vector_load_store<VLEN, uint64_t>(core, softvec_write, V, vl, vstart, vtype, vm, vd, rs1_val, segment_size,
                                                              stride, true);
     default:
-        throw new std::runtime_error("Unsupported width bit value");
+        throw std::runtime_error("Unsupported width bit value");
     }
 }
 template <size_t VLEN, size_t XLEN>
@@ -181,7 +181,7 @@ void vector_vector_op(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, u
     case 0b011:
         return softvector::vector_vector_op<VLEN, uint64_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -197,7 +197,7 @@ void vector_imm_op(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, uint
     case 0b011:
         return softvector::vector_imm_op<VLEN, uint64_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm);
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -212,7 +212,7 @@ void vector_vector_wv(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, u
         return softvector::vector_vector_op<VLEN, uint64_t, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
     case 0b011: // would widen to 128 bits
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -227,7 +227,7 @@ void vector_imm_wv(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, uint
         return softvector::vector_imm_op<VLEN, uint64_t, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm);
     case 0b011: // would widen to 128 bits
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -242,7 +242,7 @@ void vector_vector_ww(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, u
         return softvector::vector_vector_op<VLEN, uint64_t, uint64_t, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
     case 0b011: // would widen to 128 bits
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -257,7 +257,7 @@ void vector_imm_ww(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, uint
         return softvector::vector_imm_op<VLEN, uint64_t, uint64_t, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm);
     case 0b011: // would widen to 128 bits
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -266,7 +266,7 @@ void vector_extend(uint8_t* V, uint8_t unary_op, uint64_t vl, uint64_t vstart, s
     switch(target_sew_pow) {
     case 4: // uint16_t target
         if(frac_pow != 1)
-            throw new std::runtime_error("Unsupported frac_pow");
+            throw std::runtime_error("Unsupported frac_pow");
         return softvector::vector_unary_op<VLEN, uint16_t, uint8_t>(V, unary_op, vl, vstart, vtype, vm, vd, vs2);
     case 5: // uint32_t target
         switch(frac_pow) {
@@ -275,7 +275,7 @@ void vector_extend(uint8_t* V, uint8_t unary_op, uint64_t vl, uint64_t vstart, s
         case 2:
             return softvector::vector_unary_op<VLEN, uint32_t, uint8_t>(V, unary_op, vl, vstart, vtype, vm, vd, vs2);
         default:
-            throw new std::runtime_error("Unsupported frac_pow");
+            throw std::runtime_error("Unsupported frac_pow");
         }
     case 6: // uint64_t target
         switch(frac_pow) {
@@ -286,10 +286,10 @@ void vector_extend(uint8_t* V, uint8_t unary_op, uint64_t vl, uint64_t vstart, s
         case 3:
             return softvector::vector_unary_op<VLEN, uint64_t, uint8_t>(V, unary_op, vl, vstart, vtype, vm, vd, vs2);
         default:
-            throw new std::runtime_error("Unsupported frac_pow");
+            throw std::runtime_error("Unsupported frac_pow");
         }
     default:
-        throw new std::runtime_error("Unsupported target_sew_pow");
+        throw std::runtime_error("Unsupported target_sew_pow");
     }
 }
 template <size_t VLEN>
@@ -305,7 +305,7 @@ void vector_vector_carry(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl
     case 0b011:
         return softvector::vector_vector_carry<VLEN, uint64_t>(V, funct6, funct3, vl, vstart, vtype, vd, vs2, vs1, carry);
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -321,7 +321,7 @@ void vector_imm_carry(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, u
     case 0b011:
         return softvector::vector_imm_carry<VLEN, uint64_t>(V, funct6, funct3, vl, vstart, vtype, vd, vs2, imm, carry);
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -337,7 +337,7 @@ void carry_vector_vector_op(uint8_t* V, unsigned funct6, uint64_t vl, uint64_t v
     case 0b011:
         return softvector::carry_vector_vector_op<VLEN, uint64_t>(V, funct6, vl, vstart, vtype, vm, vd, vs2, vs1);
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -353,7 +353,7 @@ void carry_vector_imm_op(uint8_t* V, unsigned funct6, uint64_t vl, uint64_t vsta
     case 0b011:
         return softvector::carry_vector_imm_op<VLEN, uint64_t>(V, funct6, vl, vstart, vtype, vm, vd, vs2, imm);
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -369,7 +369,7 @@ void mask_vector_vector_op(uint8_t* V, unsigned funct6, uint8_t funct3, uint64_t
     case 0b011:
         return softvector::mask_vector_vector_op<VLEN, uint64_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -385,7 +385,7 @@ void mask_vector_imm_op(uint8_t* V, unsigned funct6, uint8_t funct3, uint64_t vl
     case 0b011:
         return softvector::mask_vector_imm_op<VLEN, uint64_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm);
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -400,7 +400,7 @@ void vector_vector_vw(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, u
         return softvector::vector_vector_op<VLEN, uint32_t, uint64_t, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
     case 0b011: // would require 128 bits vs2 value
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -415,7 +415,7 @@ void vector_imm_vw(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, uint
         return softvector::vector_imm_op<VLEN, uint32_t, uint64_t, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm);
     case 0b011: // would require 128 bits vs2 value
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -431,7 +431,7 @@ void vector_vector_merge(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::v
     case 0b011:
         return softvector::vector_vector_merge<VLEN, uint64_t>(V, vl, vstart, vtype, vm, vd, vs2, vs1);
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -447,7 +447,7 @@ void vector_imm_merge(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::vtyp
     case 0b011:
         return softvector::vector_imm_merge<VLEN, uint64_t>(V, vl, vstart, vtype, vm, vd, vs2, imm);
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -463,7 +463,7 @@ bool sat_vector_vector_op(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t v
     case 0b011:
         return softvector::sat_vector_vector_op<VLEN, uint64_t>(V, funct6, funct3, vl, vstart, vtype, vxrm, vm, vd, vs2, vs1);
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -479,7 +479,7 @@ bool sat_vector_imm_op(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl,
     case 0b011:
         return softvector::sat_vector_imm_op<VLEN, uint64_t>(V, funct6, funct3, vl, vstart, vtype, vxrm, vm, vd, vs2, imm);
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -494,7 +494,7 @@ bool sat_vector_vector_vw(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t v
         return softvector::sat_vector_vector_op<VLEN, uint32_t, uint64_t>(V, funct6, funct3, vl, vstart, vtype, vxrm, vm, vd, vs2, vs1);
     case 0b011: // would require 128 bits vs2 value
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -509,7 +509,7 @@ bool sat_vector_imm_vw(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl,
         return softvector::sat_vector_imm_op<VLEN, uint32_t, uint64_t>(V, funct6, funct3, vl, vstart, vtype, vxrm, vm, vd, vs2, imm);
     case 0b011: // would require 128 bits vs2 value
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -525,7 +525,7 @@ void vector_red_op(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, uint
     case 0b011:
         return softvector::vector_red_op<VLEN, uint64_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -540,7 +540,7 @@ void vector_red_wv(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, uint
         return softvector::vector_red_op<VLEN, uint64_t, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
     case 0b011: // would require 128 bits vs2 value
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -568,7 +568,7 @@ void viota(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype,
     case 0b011:
         return softvector::viota<VLEN, uint64_t>(V, vl, vstart, vtype, vm, vd, vs2);
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN> void vid(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t sew_val) {
@@ -582,7 +582,7 @@ template <size_t VLEN> void vid(uint8_t* V, uint64_t vl, uint64_t vstart, softve
     case 0b011:
         return softvector::vid<VLEN, uint64_t>(V, vl, vstart, vtype, vm, vd);
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN> void scalar_to_vector(uint8_t* V, softvector::vtype_t vtype, unsigned vd, uint64_t val, uint8_t sew_val) {
@@ -600,7 +600,7 @@ template <size_t VLEN> void scalar_to_vector(uint8_t* V, softvector::vtype_t vty
         softvector::scalar_move<VLEN, uint64_t>(V, vtype, vd, val, true);
         break;
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN> uint64_t scalar_from_vector(uint8_t* V, softvector::vtype_t vtype, unsigned vd, uint8_t sew_val) {
@@ -614,7 +614,7 @@ template <size_t VLEN> uint64_t scalar_from_vector(uint8_t* V, softvector::vtype
     case 0b011:
         return softvector::scalar_move<VLEN, uint64_t>(V, vtype, vd, 0, false);
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -630,7 +630,7 @@ void vector_slideup(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::vtype_
     case 0b011:
         return softvector::vector_slideup<VLEN, uint64_t>(V, vl, vstart, vtype, vm, vd, vs2, imm);
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -646,7 +646,7 @@ void vector_slidedown(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::vtyp
     case 0b011:
         return softvector::vector_slidedown<VLEN, uint64_t>(V, vl, vstart, vtype, vm, vd, vs2, imm);
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -662,7 +662,7 @@ void vector_slide1up(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::vtype
     case 0b011:
         return softvector::vector_slide1up<VLEN, uint64_t>(V, vl, vstart, vtype, vm, vd, vs2, imm);
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -678,7 +678,7 @@ void vector_slide1down(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::vty
     case 0b011:
         return softvector::vector_slide1down<VLEN, uint64_t>(V, vl, vstart, vtype, vm, vd, vs2, imm);
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -694,7 +694,7 @@ void vector_vector_gather(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::
     case 0b011:
         return softvector::vector_vector_gather<VLEN, uint64_t>(V, vl, vstart, vtype, vm, vd, vs2, vs1);
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -710,7 +710,7 @@ void vector_vector_gatherei16(uint8_t* V, uint64_t vl, uint64_t vstart, softvect
     case 0b011:
         return softvector::vector_vector_gather<VLEN, uint64_t, uint16_t>(V, vl, vstart, vtype, vm, vd, vs2, vs1);
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -726,7 +726,7 @@ void vector_imm_gather(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::vty
     case 0b011:
         return softvector::vector_imm_gather<VLEN, uint64_t>(V, vl, vstart, vtype, vm, vd, vs2, imm);
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -742,7 +742,7 @@ void vector_compress(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::vtype
     case 0b011:
         return softvector::vector_compress<VLEN, uint64_t>(V, vl, vstart, vtype, vd, vs2, vs1);
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN> void vector_whole_move(uint8_t* V, uint8_t vd, uint8_t vs2, uint8_t count) {
@@ -766,7 +766,7 @@ void fp_vector_red_op(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, u
                       uint8_t vd, uint8_t vs2, uint8_t vs1, uint8_t rm, uint8_t sew_val) {
     switch(sew_val) {
     case 0b000:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     case 0b001:
         return softvector::fp_vector_red_op<VLEN, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1, rm);
     case 0b010:
@@ -774,7 +774,7 @@ void fp_vector_red_op(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, u
     case 0b011:
         return softvector::fp_vector_red_op<VLEN, uint64_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1, rm);
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -789,7 +789,7 @@ void fp_vector_red_wv(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, u
         return softvector::fp_vector_red_op<VLEN, uint64_t, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1, rm);
     case 0b011: // would require 128 bits vs2 value
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -797,7 +797,7 @@ void fp_vector_vector_op(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl
                          uint8_t vd, uint8_t vs2, uint8_t vs1, uint8_t rm, uint8_t sew_val) {
     switch(sew_val) {
     case 0b000:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     case 0b001:
         return softvector::fp_vector_vector_op<VLEN, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1, rm);
     case 0b010:
@@ -805,7 +805,7 @@ void fp_vector_vector_op(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl
     case 0b011:
         return softvector::fp_vector_vector_op<VLEN, uint64_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1, rm);
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -813,7 +813,7 @@ void fp_vector_imm_op(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, u
                       uint8_t vd, uint8_t vs2, uint64_t imm, uint8_t rm, uint8_t sew_val) {
     switch(sew_val) {
     case 0b000:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     case 0b001:
         return softvector::fp_vector_imm_op<VLEN, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm, rm);
     case 0b010:
@@ -821,7 +821,7 @@ void fp_vector_imm_op(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, u
     case 0b011:
         return softvector::fp_vector_imm_op<VLEN, uint64_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm, rm);
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -829,14 +829,14 @@ void fp_vector_vector_wv(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl
                          uint8_t vd, uint8_t vs2, uint8_t vs1, uint8_t rm, uint8_t sew_val) {
     switch(sew_val) {
     case 0b000:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     case 0b001:
         return softvector::fp_vector_vector_op<VLEN, uint32_t, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1, rm);
     case 0b010:
         return softvector::fp_vector_vector_op<VLEN, uint64_t, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1, rm);
     case 0b011: // would widen to 128 bits
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -844,14 +844,14 @@ void fp_vector_imm_wv(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, u
                       uint8_t vd, uint8_t vs2, uint64_t imm, uint8_t rm, uint8_t sew_val) {
     switch(sew_val) {
     case 0b000:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     case 0b001:
         return softvector::fp_vector_imm_op<VLEN, uint32_t, uint16_t, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm, rm);
     case 0b010:
         return softvector::fp_vector_imm_op<VLEN, uint64_t, uint32_t, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm, rm);
     case 0b011: // would widen to 128 bits
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -859,7 +859,7 @@ void fp_vector_vector_ww(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl
                          uint8_t vd, uint8_t vs2, uint8_t vs1, uint8_t rm, uint8_t sew_val) {
     switch(sew_val) {
     case 0b000:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     case 0b001:
         return softvector::fp_vector_vector_op<VLEN, uint32_t, uint32_t, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1,
                                                                                    rm);
@@ -868,7 +868,7 @@ void fp_vector_vector_ww(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl
                                                                                    rm);
     case 0b011: // would widen to 128 bits
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -876,14 +876,14 @@ void fp_vector_imm_ww(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, u
                       uint8_t vd, uint8_t vs2, uint64_t imm, uint8_t rm, uint8_t sew_val) {
     switch(sew_val) {
     case 0b000:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     case 0b001:
         return softvector::fp_vector_imm_op<VLEN, uint32_t, uint32_t, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm, rm);
     case 0b010:
         return softvector::fp_vector_imm_op<VLEN, uint64_t, uint64_t, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm, rm);
     case 0b011: // would widen to 128 bits
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -891,7 +891,7 @@ void fp_vector_unary_op(uint8_t* V, uint8_t encoding_space, uint8_t unary_op, ui
                         bool vm, uint8_t vd, uint8_t vs2, uint8_t rm, uint8_t sew_val) {
     switch(sew_val) {
     case 0b000:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     case 0b001:
         return softvector::fp_vector_unary_op<VLEN, uint16_t>(V, encoding_space, unary_op, vl, vstart, vtype, vm, vd, vs2, rm);
     case 0b010:
@@ -899,7 +899,7 @@ void fp_vector_unary_op(uint8_t* V, uint8_t encoding_space, uint8_t unary_op, ui
     case 0b011:
         return softvector::fp_vector_unary_op<VLEN, uint64_t>(V, encoding_space, unary_op, vl, vstart, vtype, vm, vd, vs2, rm);
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -907,7 +907,7 @@ void mask_fp_vector_vector_op(uint8_t* V, uint8_t funct6, uint64_t vl, uint64_t
                               uint8_t vs2, uint8_t vs1, uint8_t rm, uint8_t sew_val) {
     switch(sew_val) {
     case 0b000:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     case 0b001:
         return softvector::mask_fp_vector_vector_op<VLEN, uint16_t>(V, funct6, vl, vstart, vtype, vm, vd, vs2, vs1, rm);
     case 0b010:
@@ -915,7 +915,7 @@ void mask_fp_vector_vector_op(uint8_t* V, uint8_t funct6, uint64_t vl, uint64_t
     case 0b011:
         return softvector::mask_fp_vector_vector_op<VLEN, uint64_t>(V, funct6, vl, vstart, vtype, vm, vd, vs2, vs1, rm);
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -923,7 +923,7 @@ void mask_fp_vector_imm_op(uint8_t* V, uint8_t funct6, uint64_t vl, uint64_t vst
                            uint8_t vs2, uint64_t imm, uint8_t rm, uint8_t sew_val) {
     switch(sew_val) {
     case 0b000:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     case 0b001:
         return softvector::mask_fp_vector_imm_op<VLEN, uint16_t>(V, funct6, vl, vstart, vtype, vm, vd, vs2, imm, rm);
     case 0b010:
@@ -931,7 +931,7 @@ void mask_fp_vector_imm_op(uint8_t* V, uint8_t funct6, uint64_t vl, uint64_t vst
     case 0b011:
         return softvector::mask_fp_vector_imm_op<VLEN, uint64_t>(V, funct6, vl, vstart, vtype, vm, vd, vs2, imm, rm);
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -951,7 +951,7 @@ void fp_vector_unary_w(uint8_t* V, uint8_t unary_op, uint64_t vl, uint64_t vstar
         return softvector::fp_vector_unary_w<VLEN, uint64_t, uint32_t>(V, unary_op, vl, vstart, vtype, vm, vd, vs2, rm);
     case 0b011: // would widen to 128 bits
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -966,7 +966,7 @@ void fp_vector_unary_n(uint8_t* V, uint8_t unary_op, uint64_t vl, uint64_t vstar
         return softvector::fp_vector_unary_n<VLEN, uint32_t, uint64_t>(V, unary_op, vl, vstart, vtype, vm, vd, vs2, rm);
     case 0b011: // would require 128 bit value to narrow
     default:
-        throw new std::runtime_error("Unsupported sew bit value");
+        throw std::runtime_error("Unsupported sew bit value");
     }
 }
 template <size_t VLEN>
@@ -982,7 +982,7 @@ void vector_unary_op(uint8_t* V, uint8_t unary_op, uint64_t vl, uint64_t vstart,
     case 0b011:
         return softvector::vector_unary_op<VLEN, uint64_t>(V, unary_op, vl, vstart, vtype, vm, vd, vs2);
     default:
-        throw new std::runtime_error("Unsupported sew_val");
+        throw std::runtime_error("Unsupported sew_val");
     }
 }
 template <size_t VLEN>
@@ -994,7 +994,7 @@ void vector_vector_crypto(uint8_t* V, uint8_t funct6, uint64_t eg_len, uint64_t
     case 8:
         return softvector::vector_vector_crypto<VLEN, 8>(V, funct6, eg_len, eg_start, vtype, vd, vs2, vs1);
     default:
-        throw new std::runtime_error("Unsupported egs");
+        throw std::runtime_error("Unsupported egs");
     }
 }
 template <size_t VLEN>
@@ -1006,7 +1006,7 @@ void vector_scalar_crypto(uint8_t* V, uint8_t funct6, uint64_t eg_len, uint64_t
     case 8:
         return softvector::vector_scalar_crypto<VLEN, 8>(V, funct6, eg_len, eg_start, vtype, vd, vs2, vs1);
     default:
-        throw new std::runtime_error("Unsupported egs");
+        throw std::runtime_error("Unsupported egs");
     }
 }
 template <size_t VLEN>
@@ -1018,7 +1018,7 @@ void vector_imm_crypto(uint8_t* V, uint8_t funct6, uint64_t eg_len, uint64_t eg_
     case 8:
         return softvector::vector_imm_crypto<VLEN, 8>(V, funct6, eg_len, eg_start, vtype, vd, vs2, imm);
     default:
-        throw new std::runtime_error("Unsupported egs");
+        throw std::runtime_error("Unsupported egs");
     }
 }
 template <size_t VLEN>
@@ -1032,7 +1032,7 @@ void vector_crypto(uint8_t* V, uint8_t funct6, uint64_t eg_len, uint64_t eg_star
         case 64:
             return softvector::vector_crypto<VLEN, 4, uint64_t>(V, funct6, eg_len, eg_start, vtype, vd, vs2, vs1);
         default:
-            throw new std::runtime_error("Unsupported sew");
+            throw std::runtime_error("Unsupported sew");
         }
     case 8:
         switch(sew) {
@@ -1041,10 +1041,10 @@ void vector_crypto(uint8_t* V, uint8_t funct6, uint64_t eg_len, uint64_t eg_star
         case 64:
             return softvector::vector_crypto<VLEN, 8, uint64_t>(V, funct6, eg_len, eg_start, vtype, vd, vs2, vs1);
         default:
-            throw new std::runtime_error("Unsupported sew");
+            throw std::runtime_error("Unsupported sew");
         }
     default:
-        throw new std::runtime_error("Unsupported egs");
+        throw std::runtime_error("Unsupported egs");
     }
 }