Fix endianness conversions for bigendian platforms

Signed-off-by: Matt Leon <mattleon@google.com>

Author: leonm1

include/proxy-wasm/word.h

@@ -24,8 +24,10 @@ namespace proxy_wasm {
 // Use byteswap functions only when compiling for big-endian platforms.
 #if defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) &&                                    \
     __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-#define htowasm(x, vm_uses_wasm_byte_order) ((vm_uses_wasm_byte_order) ? __builtin_bswap32(x) : (x))
-#define wasmtoh(x, vm_uses_wasm_byte_order) ((vm_uses_wasm_byte_order) ? __builtin_bswap32(x) : (x))
+static inline uint32_t bswap(uint32_t x) { return __builtin_bswap32(x); }
+static inline auto bswap(auto x) { return __builtin_bswap64(x); }
+#define htowasm(x, vm_uses_wasm_byte_order) ((vm_uses_wasm_byte_order) ? bswap(x) : (x))
+#define wasmtoh(x, vm_uses_wasm_byte_order) ((vm_uses_wasm_byte_order) ? bswap(x) : (x))
 #else
 #define htowasm(x, vm_uses_wasm_byte_order) (x)
 #define wasmtoh(x, vm_uses_wasm_byte_order) (x)

src/wasmtime/wasmtime.cc

@@ -24,6 +24,7 @@
 #include <variant>
 
 #include "include/proxy-wasm/limits.h"
+#include "include/proxy-wasm/word.h"
 
 #include "crates/c-api/include/wasmtime.hh" // IWYU pragma: keep
 
@@ -72,6 +73,19 @@ template <typename Arg, typename... Args> std::string printValues(Arg arg, Args.
   return printValue(arg) + ((", " + printValue(args)) + ... + "");
 }
 
+template <typename... Args> void InPlaceConvertWasmToHostEndianness(Args &...args) {
+  (void(args = wasmtoh(convertWordToUint32(args), true)), ...);
+}
+proxy_wasm::Word ConvertWasmToHostEndianness(const proxy_wasm::Word &arg) {
+  return proxy_wasm::Word(wasmtoh(convertWordToUint32(arg), true));
+}
+template <typename... Args> void InPlaceConvertHostToWasmEndianness(Args &...args) {
+  (void(args = htowasm(convertWordToUint32(args), true)), ...);
+}
+template <typename... Args> auto ConvertHostToWasmEndianness(const Args &...args) {
+  return std::make_tuple((htowasm(convertWordToUint32(args), true))...);
+}
+
 } // namespace
 
 class Wasmtime : public WasmVm {
@@ -283,6 +297,7 @@ void Wasmtime::registerHostFunctionImpl(std::string_view module_name,
       module_name, function_name,
       [this, function,
        function_name = std::string(module_name) + "." + std::string(function_name)](Args... args) {
+        InPlaceConvertWasmToHostEndianness(args...);
         const bool log = cmpLogLevel(LogLevel::trace);
         if (log) {
           integration()->trace("[vm->host] " + function_name + "(" + printValues(args...) + ")");
@@ -304,6 +319,7 @@ void Wasmtime::registerHostFunctionImpl(std::string_view module_name,
       module_name, function_name,
       [this, function,
        function_name = std::string(module_name) + "." + std::string(function_name)](Args... args) {
+        InPlaceConvertWasmToHostEndianness(args...);
         const bool log = cmpLogLevel(LogLevel::trace);
         if (log) {
           integration()->trace("[vm->host] " + function_name + "(" + printValues(args...) + ")");
@@ -312,7 +328,7 @@ void Wasmtime::registerHostFunctionImpl(std::string_view module_name,
         if (log) {
           integration()->trace("[vm<-host] " + function_name + " return: " + printValue(result));
         }
-        return result;
+        return ConvertHostToWasmEndianness(result);
       });
   if (!result) {
     fail(FailState::ConfigureFailed, "Failed to register host function: " + result.err().message());
@@ -340,6 +356,7 @@ void Wasmtime::getModuleFunctionImpl(std::string_view function_name,
       integration()->trace("[host->vm] " + std::string(function_name) + "(" + printValues(args...) +
                            ")");
     }
+    InPlaceConvertHostToWasmEndianness(args...);
     TrapResult<std::monostate> result = func.call(store_->context(), {args...});
     if (!result) {
       fail(FailState::RuntimeError,
@@ -372,17 +389,19 @@ void Wasmtime::getModuleFunctionImpl(std::string_view function_name,
       integration()->trace("[host->vm] " + std::string(function_name) + "(" + printValues(args...) +
                            ")");
     }
+    InPlaceConvertHostToWasmEndianness(args...);
     TrapResult<R> result = func.call(store_->context(), {args...});
     if (!result) {
       fail(FailState::RuntimeError,
            "Function: " + std::string(function_name) + " failed: " + result.err().message());
       return R{};
     }
+    R result_host = ConvertWasmToHostEndianness(result.ok());
     if (log) {
       integration()->trace("[host<-vm] " + std::string(function_name) +
-                           " return: " + printValue(result.unwrap()));
+                           " return: " + printValue(result_host));
     }
-    return result.ok();
+    return result_host;
   };
 };
 

test/wasm_vm_test.cc

@@ -85,7 +85,7 @@ TEST_P(TestVm, Memory) {
   ASSERT_EQ(100, word.u64_);
 
   uint32_t data[2] = {htowasm(static_cast<uint32_t>(-1), vm_->usesWasmByteOrder()),
-                      htowasm(200, vm_->usesWasmByteOrder())};
+                      htowasm(static_cast<uint32_t>(200), vm_->usesWasmByteOrder())};
   ASSERT_TRUE(vm_->setMemory(0x200, sizeof(int32_t) * 2, static_cast<void *>(data)));
   ASSERT_TRUE(vm_->getWord(0x200, &word));
   ASSERT_EQ(-1, static_cast<int32_t>(word.u64_));