Implement WASI file functions and improve WASI structure

.github/workflows/actions.yml

@@ -133,7 +133,7 @@ jobs:
 
         install: |
           apt-get update
-          apt-get install -y cmake build-essential ninja-build pkg-config python3 clang-12
+          apt-get install -y cmake build-essential ninja-build pkg-config python3 clang-12 git
           #FIXME fix clang version as to 12
           ln -s /usr/bin/clang-12 /usr/bin/clang
           ln -s /usr/bin/clang++-12 /usr/bin/clang++
@@ -164,7 +164,7 @@ jobs:
 
         install: |
           apt-get update
-          apt-get install -y cmake build-essential ninja-build pkg-config python3 clang-12
+          apt-get install -y cmake build-essential ninja-build pkg-config python3 clang-12 git
           #FIXME fix clang version as to 12
           ln -s /usr/bin/clang-12 /usr/bin/clang
           ln -s /usr/bin/clang++-12 /usr/bin/clang++

.gitmodules

@@ -6,3 +6,6 @@
 	path = third_party/wasm-c-api
 	url = https://github.com/WebAssembly/wasm-c-api
 	ignore = untracked
+[submodule "third_party/uvwasi"]
+	path = third_party/uvwasi
+	url = https://github.com/nodejs/uvwasi.git

CMakeLists.txt

@@ -74,4 +74,5 @@ PROCESSORCOUNT (NPROCS)
 
 # INCLUDE CMAKE FILES
 INCLUDE (${PROJECT_SOURCE_DIR}/build/config.cmake)
+INCLUDE (${PROJECT_SOURCE_DIR}/build/wasi.cmake)
 INCLUDE (${PROJECT_SOURCE_DIR}/build/walrus.cmake)

build/walrus.cmake

@@ -65,7 +65,12 @@ ENDIF()
 SET (WABT_DEFINITIONS ${WALRUS_DEFINITIONS})
 SET (WITH_EXCEPTIONS TRUE)
 ADD_SUBDIRECTORY (third_party/wabt)
-SET (WALRUS_LIBRARIES ${WALRUS_LIBRARIES} wabt)
+
+# uvwasi
+INCLUDE_DIRECTORIES (${WALRUS_INCDIRS} PRIVATE ${WALRUS_THIRD_PARTY_ROOT}/uvwasi/include)
+INCLUDE_DIRECTORIES (${WALRUS_INCDIRS} PRIVATE ${CMAKE_BINARY_DIR}/_deps/libuv-src/include)
+
+SET (WALRUS_LIBRARIES ${WALRUS_LIBRARIES} wabt uvwasi_a)
 
 # BUILD
 INCLUDE_DIRECTORIES (${WALRUS_INCDIRS})

build/wasi.cmake

@@ -0,0 +1,86 @@
+# This can be a commit hash or tag
+set(LIBUV_VERSION v1.44.2)
+
+include(CMakeDependentOption)
+
+if(CMAKE_C_COMPILER_ID MATCHES "AppleClang|Clang|GNU")
+  list(APPEND uvwasi_cflags -fvisibility=hidden --std=gnu89)
+  list(APPEND uvwasi_cflags -Wall -Wsign-compare -Wextra -Wstrict-prototypes)
+  list(APPEND uvwasi_cflags -Wno-unused-parameter)
+endif()
+
+set( CMAKE_C_FLAGS -fPIC)
+
+if(DEFINED WALRUS_ARCH)
+  if(${WALRUS_ARCH} STREQUAL "x86")
+    set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -m32")
+  endif()
+endif()
+
+if(DEFINED WALRUS_MODE)
+  if(${WALRUS_MODE} STREQUAL "debug")
+    set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g") 
+  endif()
+endif()
+
+if(APPLE)
+   set(CMAKE_MACOSX_RPATH ON)
+endif()
+
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+  list(APPEND uvwasi_defines _GNU_SOURCE _POSIX_C_SOURCE=200112)
+endif()
+
+set(CMAKE_MESSAGE_LOG_LEVEL "WARNING")
+
+include(FetchContent)
+## https://libuv.org
+FetchContent_Declare(
+        libuv
+        GIT_REPOSITORY https://github.com/libuv/libuv.git
+        GIT_TAG ${LIBUV_VERSION})
+FetchContent_GetProperties(libuv)
+if(NOT libuv_POPULATED)
+    FetchContent_Populate(libuv)
+    include_directories("${libuv_SOURCE_DIR}/include")
+    add_subdirectory(${libuv_SOURCE_DIR} ${libuv_BINARY_DIR} EXCLUDE_FROM_ALL)
+endif()
+set(LIBUV_INCLUDE_DIR ${libuv_SOURCE_DIR}/include)
+set(LIBUV_LIBRARIES uv_a)
+
+## uvwasi source code files.
+set(uvwasi_sources
+    third_party/uvwasi/src/clocks.c
+    third_party/uvwasi/src/fd_table.c
+    third_party/uvwasi/src/path_resolver.c
+    third_party/uvwasi/src/poll_oneoff.c
+    third_party/uvwasi/src/sync_helpers.c
+    third_party/uvwasi/src/uv_mapping.c
+    third_party/uvwasi/src/uvwasi.c
+    third_party/uvwasi/src/wasi_rights.c
+    third_party/uvwasi/src/wasi_serdes.c
+)
+
+option(UVWASI_DEBUG_LOG "Enable debug logging" OFF)
+if(UVWASI_DEBUG_LOG)
+    list(APPEND uvwasi_cflags -DUVWASI_DEBUG_LOG)
+endif()
+
+## Static library target.
+add_library(uvwasi_a STATIC ${uvwasi_sources})
+target_compile_definitions(uvwasi_a PRIVATE ${uvwasi_defines})
+target_compile_options(uvwasi_a PRIVATE ${uvwasi_cflags})
+target_include_directories(uvwasi_a PRIVATE ${PROJECT_SOURCE_DIR}/include)
+target_link_libraries(uvwasi_a PRIVATE ${LIBUV_LIBRARIES})
+
+set(CMAKE_MESSAGE_LOG_LEVEL "DEFAULT")
+
+message(STATUS "summary of uvwasi build options:
+    Compiler:
+      C compiler:    ${CMAKE_C_COMPILER}
+      CFLAGS:        ${CMAKE_C_FLAGS_${_build_type}} ${CMAKE_C_FLAGS}
+
+    LibUV libraries: ${LIBUV_LIBRARIES}
+    LibUV includes:  ${LIBUV_INCLUDE_DIR}
+    Debug logging:   ${UVWASI_DEBUG_LOG}
+")

src/runtime/Function.cpp

@@ -149,4 +149,47 @@ void ImportedFunction::call(ExecutionState& state, Value* argv, Value* result)
     m_callback(newState, argv, result, m_data);
 }
 
+WasiFunction* WasiFunction::createWasiFunction(Store* store,
+                                               FunctionType* functionType,
+                                               WasiFunctionCallback callback)
+{
+    WasiFunction* func = new WasiFunction(functionType,
+                                          callback);
+    store->appendExtern(func);
+    return func;
+}
+
+void WasiFunction::interpreterCall(ExecutionState& state, uint8_t* bp, ByteCodeStackOffset* offsets,
+                                   uint16_t parameterOffsetCount, uint16_t resultOffsetCount)
+{
+    const FunctionType* ft = functionType();
+    const ValueTypeVector& paramTypeInfo = ft->param();
+    const ValueTypeVector& resultTypeInfo = ft->result();
+
+    ALLOCA(Value, paramVector, sizeof(Value) * paramTypeInfo.size());
+    ALLOCA(Value, resultVector, sizeof(Value) * resultTypeInfo.size());
+
+    size_t offsetIndex = 0;
+    size_t size = paramTypeInfo.size();
+    Value* paramVectorStart = paramVector;
+    for (size_t i = 0; i < size; i++) {
+        paramVector[i] = Value(paramTypeInfo[i], bp + offsets[offsetIndex]);
+        offsetIndex += valueFunctionCopyCount(paramTypeInfo[i]);
+    }
+
+    call(state, paramVectorStart, resultVector);
+
+    for (size_t i = 0; i < resultTypeInfo.size(); i++) {
+        resultVector[i].writeToMemory(bp + offsets[offsetIndex]);
+        offsetIndex += valueFunctionCopyCount(resultTypeInfo[i]);
+    }
+}
+
+void WasiFunction::call(ExecutionState& state, Value* argv, Value* result)
+{
+    ExecutionState newState(state, this);
+    CHECK_STACK_LIMIT(newState);
+    m_callback(newState, argv, result, this->m_runningInstance);
+}
+
 } // namespace Walrus

src/runtime/Function.h

@@ -43,6 +43,7 @@ class FunctionType;
 class ModuleFunction;
 class DefinedFunction;
 class ImportedFunction;
+class WasiFunction;
 
 class Function : public Extern {
 public:
@@ -72,6 +73,11 @@ class Function : public Extern {
         return false;
     }
 
+    virtual bool isWasiFunction() const
+    {
+        return false;
+    }
+
     DefinedFunction* asDefinedFunction()
     {
         ASSERT(isDefinedFunction());
@@ -84,6 +90,12 @@ class Function : public Extern {
         return reinterpret_cast<ImportedFunction*>(this);
     }
 
+    WasiFunction* asWasiFunction()
+    {
+        ASSERT(isWasiFunction());
+        return reinterpret_cast<WasiFunction*>(this);
+    }
+
 protected:
     Function(FunctionType* functionType)
         : m_functionType(functionType)
@@ -168,6 +180,41 @@ class ImportedFunction : public Function {
     void* m_data;
 };
 
+class WasiFunction : public Function {
+public:
+    typedef std::function<void(ExecutionState& state, Value* argv, Value* result, Instance* instance)> WasiFunctionCallback;
+
+    static WasiFunction* createWasiFunction(Store* store,
+                                            FunctionType* functionType,
+                                            WasiFunctionCallback callback);
+
+    virtual bool isWasiFunction() const override
+    {
+        return true;
+    }
+
+    void setRunningInstance(Instance* instance)
+    {
+        m_runningInstance = instance;
+    }
+
+    virtual void call(ExecutionState& state, Value* argv, Value* result) override;
+    virtual void interpreterCall(ExecutionState& state, uint8_t* bp, ByteCodeStackOffset* offsets,
+                                 uint16_t parameterOffsetCount, uint16_t resultOffsetCount) override;
+
+protected:
+    WasiFunction(FunctionType* functionType,
+                 WasiFunctionCallback callback)
+        : Function(functionType)
+        , m_callback(callback)
+        , m_runningInstance(nullptr)
+    {
+    }
+
+    WasiFunctionCallback m_callback;
+    Instance* m_runningInstance;
+};
+
 } // namespace Walrus
 
 #endif // __WalrusFunction__

src/runtime/Module.cpp

@@ -28,6 +28,7 @@
 #include "interpreter/ByteCode.h"
 #include "interpreter/Interpreter.h"
 #include "parser/WASMParser.h"
+#include "wasi/Wasi.h"
 
 namespace Walrus {
 
@@ -151,7 +152,11 @@ Instance* Module::instantiate(ExecutionState& state, const ExternVector& imports
             if (!imports[i]->asFunction()->functionType()->equals(m_imports[i]->functionType())) {
                 Trap::throwException(state, "imported function type mismatch");
             }
-            instance->m_functions[funcIndex++] = imports[i]->asFunction();
+            instance->m_functions[funcIndex] = imports[i]->asFunction();
+            if (imports[i]->asFunction()->isWasiFunction()) {
+                instance->m_functions[funcIndex]->asWasiFunction()->setRunningInstance(instance);
+            }
+            funcIndex++;
             break;
         }
         case ImportType::Global: {

src/runtime/SpecTest.h

@@ -26,6 +26,8 @@ class SpecTestFunctionTypes {
         // The R is meant to represent the results, after R are the result types.
         NONE = 0,
         I32R,
+        I32_RI32,
+        I32I32I32I32_RI32,
         RI32,
         I64R,
         F32R,
@@ -57,6 +59,25 @@ class SpecTestFunctionTypes {
             param->push_back(Value::Type::I32);
             m_vector[index++] = new FunctionType(param, result);
         }
+        {
+            // I32_RI32
+            param = new ValueTypeVector();
+            result = new ValueTypeVector();
+            param->push_back(Value::Type::I32);
+            result->push_back(Value::Type::I32);
+            m_vector[index++] = new FunctionType(param, result);
+        }
+        {
+            // I32I32I32I32_RI32
+            param = new ValueTypeVector();
+            result = new ValueTypeVector();
+            param->push_back(Value::Type::I32);
+            param->push_back(Value::Type::I32);
+            param->push_back(Value::Type::I32);
+            param->push_back(Value::Type::I32);
+            result->push_back(Value::Type::I32);
+            m_vector[index++] = new FunctionType(param, result);
+        }
         {
             // RI32
             param = new ValueTypeVector();