diff --git a/src/arch/generic/memhelpers.hh b/src/arch/generic/memhelpers.hh
index d5684a6af9..9cdd2a56eb 100644
--- a/src/arch/generic/memhelpers.hh
+++ b/src/arch/generic/memhelpers.hh
@@ -124,6 +124,24 @@ readMemAtomic(XC *xc, trace::InstRecord *traceData, Addr addr, MemT &mem,
     return fault;
 }
 
+/// Read from memory in atomic mode.
+template <ByteOrder Order, class XC, class MemT>
+Fault
+readMemAtomic(XC *xc, trace::InstRecord *traceData, Addr addr, MemT &mem,
+              size_t size, Request::Flags flags)
+{
+    memset(&mem, 0, size);
+    static const std::vector<bool> byte_enable(size, true);
+    Fault fault = readMemAtomic(xc, addr, (uint8_t*)&mem,
+                                size, flags, byte_enable);
+    if (fault == NoFault) {
+        mem = gtoh(mem, Order);
+        if (traceData)
+            traceData->setData(mem);
+    }
+    return fault;
+}
+
 template <class XC, class MemT>
 Fault
 readMemAtomicLE(XC *xc, trace::InstRecord *traceData, Addr addr, MemT &mem,
@@ -133,6 +151,16 @@ readMemAtomicLE(XC *xc, trace::InstRecord *traceData, Addr addr, MemT &mem,
             xc, traceData, addr, mem, flags);
 }
 
+template <class XC, class MemT>
+Fault
+readMemAtomicLE(XC *xc, trace::InstRecord *traceData, Addr addr, MemT &mem,
+                size_t size, Request::Flags flags)
+{
+    return readMemAtomic<ByteOrder::little>(
+            xc, traceData, addr, mem, size, flags);
+}
+
+
 template <class XC, class MemT>
 Fault
 readMemAtomicBE(XC *xc, trace::InstRecord *traceData, Addr addr, MemT &mem,
@@ -165,6 +193,20 @@ writeMemTiming(XC *xc, trace::InstRecord *traceData, MemT mem, Addr addr,
                           sizeof(MemT), flags, res, byte_enable);
 }
 
+template <ByteOrder Order, class XC, class MemT>
+Fault
+writeMemTiming(XC *xc, trace::InstRecord *traceData, MemT mem, Addr addr,
+               size_t size, Request::Flags flags, uint64_t *res)
+{
+    if (traceData) {
+        traceData->setData(mem);
+    }
+    mem = htog(mem, Order);
+    static const std::vector<bool> byte_enable(size, true);
+    return writeMemTiming(xc, (uint8_t*)&mem, addr,
+                          size, flags, res, byte_enable);
+}
+
 template <class XC, class MemT>
 Fault
 writeMemTimingLE(XC *xc, trace::InstRecord *traceData, MemT mem, Addr addr,
@@ -174,6 +216,15 @@ writeMemTimingLE(XC *xc, trace::InstRecord *traceData, MemT mem, Addr addr,
             xc, traceData, mem, addr, flags, res);
 }
 
+template <class XC, class MemT>
+Fault
+writeMemTimingLE(XC *xc, trace::InstRecord *traceData, MemT mem, Addr addr,
+               size_t size, Request::Flags flags, uint64_t *res)
+{
+    return writeMemTiming<ByteOrder::little>(
+            xc, traceData, mem, addr, size, flags, res);
+}
+
 template <class XC, class MemT>
 Fault
 writeMemTimingBE(XC *xc, trace::InstRecord *traceData, MemT mem, Addr addr,
@@ -214,6 +265,27 @@ writeMemAtomic(XC *xc, trace::InstRecord *traceData, const MemT &mem,
     return fault;
 }
 
+template <ByteOrder Order, class XC, class MemT>
+Fault
+writeMemAtomic(XC *xc, trace::InstRecord *traceData, const MemT &mem,
+               Addr addr, size_t size, Request::Flags flags, uint64_t *res)
+{
+    if (traceData) {
+        traceData->setData(mem);
+    }
+    MemT host_mem = htog(mem, Order);
+    static const std::vector<bool> byte_enable(size, true);
+    Fault fault = writeMemAtomic(xc, (uint8_t*)&host_mem,
+                                 addr, size, flags, res, byte_enable);
+    if (fault == NoFault && res != NULL) {
+        if (flags & Request::MEM_SWAP || flags & Request::MEM_SWAP_COND)
+            *(MemT *)res = gtoh(*(MemT *)res, Order);
+        else
+            *res = gtoh(*res, Order);
+    }
+    return fault;
+}
+
 template <class XC, class MemT>
 Fault
 writeMemAtomicLE(XC *xc, trace::InstRecord *traceData, const MemT &mem,
@@ -223,6 +295,15 @@ writeMemAtomicLE(XC *xc, trace::InstRecord *traceData, const MemT &mem,
             xc, traceData, mem, addr, flags, res);
 }
 
+template <class XC, class MemT>
+Fault
+writeMemAtomicLE(XC *xc, trace::InstRecord *traceData, const MemT &mem,
+                 size_t size, Addr addr, Request::Flags flags, uint64_t *res)
+{
+    return writeMemAtomic<ByteOrder::little>(
+            xc, traceData, mem, addr, size, flags, res);
+}
+
 template <class XC, class MemT>
 Fault
 writeMemAtomicBE(XC *xc, trace::InstRecord *traceData, const MemT &mem,
diff --git a/src/arch/riscv/isa/templates/vector_mem.isa b/src/arch/riscv/isa/templates/vector_mem.isa
index fc1b93548c..8cbab044ec 100644
--- a/src/arch/riscv/isa/templates/vector_mem.isa
+++ b/src/arch/riscv/isa/templates/vector_mem.isa
@@ -562,7 +562,7 @@ Fault
     }
 
     Fault fault = writeMemAtomicLE(xc, traceData, *(vreg_t::Container*)(&Mem),
-                                   EA, memAccessFlags, nullptr);
+                                   vlenb, EA, memAccessFlags, nullptr);
     return fault;
 }
 
@@ -592,7 +592,7 @@ Fault
     }
 
     Fault fault = writeMemTimingLE(xc, traceData, *(vreg_t::Container*)(&Mem),
-                                   EA, memAccessFlags, nullptr);
+                                   EA, vlenb, memAccessFlags, nullptr);
     return fault;
 }
 
@@ -689,7 +689,8 @@ Fault
     %(ea_code)s;
 
     Fault fault = readMemAtomicLE(xc, traceData, EA,
-                                  *(vreg_t::Container*)(&Mem), memAccessFlags);
+                            *(vreg_t::Container*)(&Mem), vlenb,
+                            memAccessFlags);
     if (fault != NoFault)
         return fault;
 
@@ -722,7 +723,8 @@ Fault
     %(set_vlenb)s;
     %(ea_code)s;
 
-    Fault fault = initiateMemRead(xc, traceData, EA, Mem, memAccessFlags);
+    const std::vector<bool> byte_enable(vlenb, true);
+    Fault fault = initiateMemRead(xc, EA, vlenb, memAccessFlags, byte_enable);
     return fault;
 }