Tag target endian values to help guide conversion code

5 files changed, 53 insertions, 52 deletions

diff --git a/fesvr/htif.cc b/fesvr/htif.cc
index 996e321..4f34cec 100644
--- a/fesvr/htif.cc
+++ b/fesvr/htif.cc
@@ -217,7 +217,7 @@ int htif_t::run()
   while (!signal_exit && exitcode == 0)
   {
     if (auto tohost = from_target(mem.read_uint64(tohost_addr))) {
-      mem.write_uint64(tohost_addr, 0);
+      mem.write_uint64(tohost_addr, target_endian<uint64_t>::zero);
       command_t cmd(mem, tohost, fromhost_callback);
       device_list.handle_command(cmd);
     } else {
@@ -226,7 +226,7 @@ int htif_t::run()
 
     device_list.tick();
 
-    if (!fromhost_queue.empty() && mem.read_uint64(fromhost_addr) == 0) {
+    if (!fromhost_queue.empty() && !mem.read_uint64(fromhost_addr)) {
       mem.write_uint64(fromhost_addr, to_target(fromhost_queue.front()));
       fromhost_queue.pop();
     }
diff --git a/fesvr/htif.h b/fesvr/htif.h
index 66a626d..3cee25f 100644
--- a/fesvr/htif.h
+++ b/fesvr/htif.h
@@ -29,27 +29,27 @@ class htif_t : public chunked_memif_t
 
   virtual memif_t& memif() { return mem; }
 
-  template<typename T> inline T from_target(T n) const
+  template<typename T> inline T from_target(target_endian<T> n) const
   {
 #ifdef RISCV_ENABLE_DUAL_ENDIAN
     memif_endianness_t endianness = get_target_endianness();
     assert(endianness == memif_endianness_little || endianness == memif_endianness_big);
 
-    return endianness == memif_endianness_big? from_be(n) : from_le(n);
+    return endianness == memif_endianness_big? n.from_be() : n.from_le();
 #else
-    return from_le(n);
+    return n.from_le();
 #endif
   }
 
-  template<typename T> inline T to_target(T n) const
+  template<typename T> inline target_endian<T> to_target(T n) const
   {
 #ifdef RISCV_ENABLE_DUAL_ENDIAN
     memif_endianness_t endianness = get_target_endianness();
     assert(endianness == memif_endianness_little || endianness == memif_endianness_big);
 
-    return endianness == memif_endianness_big? to_be(n) : to_le(n);
+    return endianness == memif_endianness_big? target_endian<T>::to_be(n) : target_endian<T>::to_le(n);
 #else
-    return to_le(n);
+    return target_endian<T>::to_le(n);
 #endif
   }
 
diff --git a/fesvr/memif.cc b/fesvr/memif.cc
index fd96291..e56bd94 100644
--- a/fesvr/memif.cc
+++ b/fesvr/memif.cc
@@ -94,90 +94,90 @@ void memif_t::write(addr_t addr, size_t len, const void* bytes)
     throw std::runtime_error("misaligned address"); \
   this->write(addr, sizeof(val), &val)
 
-uint8_t memif_t::read_uint8(addr_t addr)
+target_endian<uint8_t> memif_t::read_uint8(addr_t addr)
 {
-  uint8_t val;
+  target_endian<uint8_t> val;
   MEMIF_READ_FUNC;
 }
 
-int8_t memif_t::read_int8(addr_t addr)
+target_endian<int8_t> memif_t::read_int8(addr_t addr)
 {
-  int8_t val;
+  target_endian<int8_t> val;
   MEMIF_READ_FUNC;
 }
 
-void memif_t::write_uint8(addr_t addr, uint8_t val)
+void memif_t::write_uint8(addr_t addr, target_endian<uint8_t> val)
 {
   MEMIF_WRITE_FUNC;
 }
 
-void memif_t::write_int8(addr_t addr, int8_t val)
+void memif_t::write_int8(addr_t addr, target_endian<int8_t> val)
 {
   MEMIF_WRITE_FUNC;
 }
 
-uint16_t memif_t::read_uint16(addr_t addr)
+target_endian<uint16_t> memif_t::read_uint16(addr_t addr)
 {
-  uint16_t val;
+  target_endian<uint16_t> val;
   MEMIF_READ_FUNC;
 }
 
-int16_t memif_t::read_int16(addr_t addr)
+target_endian<int16_t> memif_t::read_int16(addr_t addr)
 {
-  int16_t val;
+  target_endian<int16_t> val;
   MEMIF_READ_FUNC;
 }
 
-void memif_t::write_uint16(addr_t addr, uint16_t val)
+void memif_t::write_uint16(addr_t addr, target_endian<uint16_t> val)
 {
   MEMIF_WRITE_FUNC;
 }
 
-void memif_t::write_int16(addr_t addr, int16_t val)
+void memif_t::write_int16(addr_t addr, target_endian<int16_t> val)
 {
   MEMIF_WRITE_FUNC;
 }
 
-uint32_t memif_t::read_uint32(addr_t addr)
+target_endian<uint32_t> memif_t::read_uint32(addr_t addr)
 {
-  uint32_t val;
+  target_endian<uint32_t> val;
   MEMIF_READ_FUNC;
 }
 
-int32_t memif_t::read_int32(addr_t addr)
+target_endian<int32_t> memif_t::read_int32(addr_t addr)
 {
-  int32_t val;
+  target_endian<int32_t> val;
   MEMIF_READ_FUNC;
 }
 
-void memif_t::write_uint32(addr_t addr, uint32_t val)
+void memif_t::write_uint32(addr_t addr, target_endian<uint32_t> val)
 {
   MEMIF_WRITE_FUNC;
 }
 
-void memif_t::write_int32(addr_t addr, int32_t val)
+void memif_t::write_int32(addr_t addr, target_endian<int32_t> val)
 {
   MEMIF_WRITE_FUNC;
 }
 
-uint64_t memif_t::read_uint64(addr_t addr)
+target_endian<uint64_t> memif_t::read_uint64(addr_t addr)
 {
-  uint64_t val;
+  target_endian<uint64_t> val;
   MEMIF_READ_FUNC;
 }
 
-int64_t memif_t::read_int64(addr_t addr)
+target_endian<int64_t> memif_t::read_int64(addr_t addr)
 {
-  int64_t val;
+  target_endian<int64_t> val;
   MEMIF_READ_FUNC;
 }
 
-void memif_t::write_uint64(addr_t addr, uint64_t val)
+void memif_t::write_uint64(addr_t addr, target_endian<uint64_t> val)
 {
   MEMIF_WRITE_FUNC;
 }
 
-void memif_t::write_int64(addr_t addr, int64_t val)
+void memif_t::write_int64(addr_t addr, target_endian<int64_t> val)
 {
   MEMIF_WRITE_FUNC;
 }
diff --git a/fesvr/memif.h b/fesvr/memif.h
index aaa9f05..001c425 100644
--- a/fesvr/memif.h
+++ b/fesvr/memif.h
@@ -5,6 +5,7 @@
 
 #include <stdint.h>
 #include <stddef.h>
+#include "byteorder.h"
 
 typedef uint64_t reg_t;
 typedef int64_t sreg_t;
@@ -43,28 +44,28 @@ public:
   virtual void write(addr_t addr, size_t len, const void* bytes);
 
   // read and write 8-bit words
-  virtual uint8_t read_uint8(addr_t addr);
-  virtual int8_t read_int8(addr_t addr);
-  virtual void write_uint8(addr_t addr, uint8_t val);
-  virtual void write_int8(addr_t addr, int8_t val);
+  virtual target_endian<uint8_t> read_uint8(addr_t addr);
+  virtual target_endian<int8_t> read_int8(addr_t addr);
+  virtual void write_uint8(addr_t addr, target_endian<uint8_t> val);
+  virtual void write_int8(addr_t addr, target_endian<int8_t> val);
 
   // read and write 16-bit words
-  virtual uint16_t read_uint16(addr_t addr);
-  virtual int16_t read_int16(addr_t addr);
-  virtual void write_uint16(addr_t addr, uint16_t val);
-  virtual void write_int16(addr_t addr, int16_t val);
+  virtual target_endian<uint16_t> read_uint16(addr_t addr);
+  virtual target_endian<int16_t> read_int16(addr_t addr);
+  virtual void write_uint16(addr_t addr, target_endian<uint16_t> val);
+  virtual void write_int16(addr_t addr, target_endian<int16_t> val);
 
   // read and write 32-bit words
-  virtual uint32_t read_uint32(addr_t addr);
-  virtual int32_t read_int32(addr_t addr);
-  virtual void write_uint32(addr_t addr, uint32_t val);
-  virtual void write_int32(addr_t addr, int32_t val);
+  virtual target_endian<uint32_t> read_uint32(addr_t addr);
+  virtual target_endian<int32_t> read_int32(addr_t addr);
+  virtual void write_uint32(addr_t addr, target_endian<uint32_t> val);
+  virtual void write_int32(addr_t addr, target_endian<int32_t> val);
 
   // read and write 64-bit words
-  virtual uint64_t read_uint64(addr_t addr);
-  virtual int64_t read_int64(addr_t addr);
-  virtual void write_uint64(addr_t addr, uint64_t val);
-  virtual void write_int64(addr_t addr, int64_t val);
+  virtual target_endian<uint64_t> read_uint64(addr_t addr);
+  virtual target_endian<int64_t> read_int64(addr_t addr);
+  virtual void write_uint64(addr_t addr, target_endian<uint64_t> val);
+  virtual void write_int64(addr_t addr, target_endian<int64_t> val);
 
   // endianness
   virtual void set_target_endianness(memif_endianness_t endianness) {
diff --git a/fesvr/syscall.cc b/fesvr/syscall.cc
index 6feb13b..18bdc13 100644
--- a/fesvr/syscall.cc
+++ b/fesvr/syscall.cc
@@ -299,10 +299,10 @@ reg_t syscall_t::sys_getcwd(reg_t pbuf, reg_t size, reg_t a2, reg_t a3, reg_t a4
 reg_t syscall_t::sys_getmainvars(reg_t pbuf, reg_t limit, reg_t a2, reg_t a3, reg_t a4, reg_t a5, reg_t a6)
 {
   std::vector<std::string> args = htif->target_args();
-  std::vector<uint64_t> words(args.size() + 3);
+  std::vector<target_endian<uint64_t>> words(args.size() + 3);
   words[0] = htif->to_target<uint64_t>(args.size());
-  words[args.size()+1] = 0; // argv[argc] = NULL
-  words[args.size()+2] = 0; // envp[0] = NULL
+  words[args.size()+1] = target_endian<uint64_t>::zero; // argv[argc] = NULL
+  words[args.size()+2] = target_endian<uint64_t>::zero; // envp[0] = NULL
 
   size_t sz = (args.size() + 3) * sizeof(words[0]);
   for (size_t i = 0; i < args.size(); i++)
@@ -340,7 +340,7 @@ reg_t syscall_t::sys_chdir(reg_t path, reg_t a1, reg_t a2, reg_t a3, reg_t a4, r
 
 void syscall_t::dispatch(reg_t mm)
 {
-  reg_t magicmem[8];
+  target_endian<reg_t> magicmem[8];
   memif->read(mm, sizeof(magicmem), magicmem);
 
   reg_t n = htif->from_target(magicmem[0]);