From fcc2423258cf20e9b8d0472ee6907be69fc5ee59 Mon Sep 17 00:00:00 2001 From: Saiakt Dey Date: Mon, 5 Jun 2023 09:31:43 +0530 Subject: [PATCH 01/98] Include wasmedge_zlib in plugins/CMakeLists.txt . Signed-off-by: Saikat Dey --- plugins/CMakeLists.txt | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/plugins/CMakeLists.txt b/plugins/CMakeLists.txt index 015ea804ba1f..86dedbaaff73 100644 --- a/plugins/CMakeLists.txt +++ b/plugins/CMakeLists.txt @@ -26,3 +26,7 @@ if(WASMEDGE_PLUGIN_WASM_BPF) message(WARNING "Only Linux platforms support wasm_bpf plug-in now.") endif() endif() + +if(WASMEDGE_PLUGIN_ZLIB) + add_subdirectory(wasmedge_zlib) +endif() From 2d866db038b8dd958bf723e421443ac868b19625 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Mon, 5 Jun 2023 09:48:22 +0530 Subject: [PATCH 02/98] Add Zlib Plugin as an option in root CMakeLists.txt . Signed-off-by: Saikat Dey --- CMakeLists.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/CMakeLists.txt b/CMakeLists.txt index 94ab4981162b..db23e7924525 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -79,6 +79,7 @@ set(WASMEDGE_PLUGIN_WASI_NN_BACKEND "" CACHE STRING "Enable WasmEdge Wasi-NN plu option(WASMEDGE_PLUGIN_WASI_CRYPTO "Enable WasmEdge Wasi-crypto plugin." OFF) option(WASMEDGE_PLUGIN_PROCESS "Enable WasmEdge process plugin." OFF) option(WASMEDGE_PLUGIN_WASM_BPF "Enable WasmEdge wasm-bpf plugin." OFF) +option(WASMEDGE_PLUGIN_ZLIB "Enable WasmEdge zlib plugin." OFF) if(WASMEDGE_BUILD_TOOLS AND WASMEDGE_BUILD_FUZZING) message(FATAL_ERROR "wasmedge tool and fuzzing tool are exclusive options.") From b4d0cc4630cc77d0247fe4a932e716126fde654b Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Mon, 5 Jun 2023 22:31:25 +0530 Subject: [PATCH 03/98] Add zlib-ng dependency through FetchContent. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/CMakeLists.txt | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 plugins/wasmedge_zlib/CMakeLists.txt diff --git a/plugins/wasmedge_zlib/CMakeLists.txt b/plugins/wasmedge_zlib/CMakeLists.txt new file mode 100644 index 000000000000..820136e08ddc --- /dev/null +++ b/plugins/wasmedge_zlib/CMakeLists.txt @@ -0,0 +1,17 @@ +# SPDX-License-Identifier: Apache-2.0 +# SPDX-FileCopyrightText: 2019-2022 Second State INC + +# Don't reply on System zlib +# find_package(ZLIB REQUIRED) + +set(ZLIB_COMPAT ON) +set(ZLIBNG_ENABLE_TESTS OFF) + +FetchContent_Declare( + ZLIB + GIT_REPOSITORY "https://github.com/zlib-ng/zlib-ng.git" + GIT_TAG 2.0.7 + GIT_PROGRESS TRUE +) +FetchContent_MakeAvailable(ZLIB) + From da6a3023eaeebcf7a4e21d52b6c2eb7c756a9149 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Tue, 6 Jun 2023 00:15:53 +0530 Subject: [PATCH 04/98] Added zlib build target for job 'build_ubuntu' in build-extensions.yml . Signed-off-by: Saikat Dey --- .github/workflows/build-extensions.yml | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/.github/workflows/build-extensions.yml b/.github/workflows/build-extensions.yml index 1d192aa2ea2e..ec5db6500580 100644 --- a/.github/workflows/build-extensions.yml +++ b/.github/workflows/build-extensions.yml @@ -155,6 +155,24 @@ jobs: test_path: test/plugins/wasmedge_process test_bin: wasmedgeProcessTests build_type: Release + - name: Zlib + tar_name: wasmedge_zlib + compiler: g++ + docker_tag: ubuntu-build-gcc + output_path: plugins/wasmedge_zlib + output_bin: libwasmedgePluginWasmEdgeZlib.so + test_path: test/plugins/wasmedge_zlib + test_bin: wasmedgeZlibTests + build_type: Release + - name: Zlib + tar_name: wasmedge_zlib + compiler: clang++ + docker_tag: ubuntu-build-clang + output_path: plugins/wasmedge_zlib + output_bin: libwasmedgePluginWasmEdgeZlib.so + test_path: test/plugins/wasmedge_zlib + test_bin: wasmedgeZlibTests + build_type: Release name: Ubuntu WasmEdge ${{ matrix.name }} plugin with ${{ matrix.compiler}} ${{ matrix.build_type}} runs-on: ubuntu-latest needs: [get_version_v2] @@ -207,6 +225,14 @@ jobs: cmake -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DWASMEDGE_PLUGIN_PROCESS=ON -DWASMEDGE_BUILD_TESTS=ON .. cd ${{ matrix.test_path }} make -j + - name: Build WasmEdge Zlib plugin using ${{ matrix.compiler }} with ${{ matrix.build_type }} mode + if: contains(matrix.name, 'Zlib') + run: | + mkdir -p build + cd build + cmake -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DWASMEDGE_PLUGIN_ZLIB=ON -DWASMEDGE_BUILD_TESTS=ON .. + cd ${{ matrix.test_path }} + make -j - name: Test WasmEdge ${{ matrix.name }} plugin using ${{ matrix.compiler }} with ${{ matrix.build_type }} mode shell: bash run: | From cc0dd7cbe8c1ec08c05f259254522b66d501b53c Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Tue, 6 Jun 2023 00:18:33 +0530 Subject: [PATCH 05/98] Added zlib build target for job 'build_manylinux' in build-extensions.yml . Signed-off-by: Saikat Dey --- .github/workflows/build-extensions.yml | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/.github/workflows/build-extensions.yml b/.github/workflows/build-extensions.yml index ec5db6500580..37f001e6f299 100644 --- a/.github/workflows/build-extensions.yml +++ b/.github/workflows/build-extensions.yml @@ -341,6 +341,26 @@ jobs: cmake_plugin_option: "-DWASMEDGE_PLUGIN_PROCESS=ON" build_type: Release test: false + - name: Zlib + tar_name: wasmedge_zlib + system: manylinux2014 x86_64 + host_runner: ubuntu-latest + docker_tag: manylinux2014_x86_64 + output_path: plugins/wasmedge_zlib + output_bin: libwasmedgePluginWasmEdgeZlib.so + cmake_plugin_option: "-DWASMEDGE_PLUGIN_ZLIB=ON" + build_type: Release + test: false + - name: Zlib + tar_name: wasmedge_zlib + system: manylinux2014 aarch64 + host_runner: linux-arm64 + docker_tag: manylinux2014_aarch64 + output_path: plugins/wasmedge_zlib + output_bin: libwasmedgePluginWasmEdgeZlib.so + cmake_plugin_option: "-DWASMEDGE_PLUGIN_ZLIB=ON" + build_type: Release + test: false name: ${{ matrix.system }} WasmEdge ${{ matrix.name }} plugin with g++ ${{ matrix.build_type }} runs-on: ${{ matrix.host_runner }} needs: [get_version_v2] From 618c2e84549d2444568f7beac0101b67e79da568 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Tue, 6 Jun 2023 05:01:56 +0530 Subject: [PATCH 06/98] Init env & base headers, struct Wasm_z_stream & ZStreamMap Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibbase.h | 25 ++++++++++++++ plugins/wasmedge_zlib/zlibenv.h | 52 ++++++++++++++++++++++++++++++ plugins/wasmedge_zlib/zlibmodule.h | 23 +++++++++++++ 3 files changed, 100 insertions(+) create mode 100644 plugins/wasmedge_zlib/zlibbase.h create mode 100644 plugins/wasmedge_zlib/zlibenv.h create mode 100644 plugins/wasmedge_zlib/zlibmodule.h diff --git a/plugins/wasmedge_zlib/zlibbase.h b/plugins/wasmedge_zlib/zlibbase.h new file mode 100644 index 000000000000..11640a72d636 --- /dev/null +++ b/plugins/wasmedge_zlib/zlibbase.h @@ -0,0 +1,25 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2019-2022 Second State INC + +#pragma once + +#include "zlibenv.h" + +#include "common/errcode.h" +#include "runtime/callingframe.h" +#include "runtime/hostfunc.h" + +namespace WasmEdge { +namespace Host { + +template class WasmEdgeZlib : public Runtime::HostFunction { +public: + WasmEdgeZlib(WasmEdgeZlibEnvironment &HostEnv) + : Runtime::HostFunction(0), Env(HostEnv) {} + +protected: + WasmEdgeZlibEnvironment &Env; +}; + +} // namespace Host +} // namespace WasmEdge diff --git a/plugins/wasmedge_zlib/zlibenv.h b/plugins/wasmedge_zlib/zlibenv.h new file mode 100644 index 000000000000..8851833ddce0 --- /dev/null +++ b/plugins/wasmedge_zlib/zlibenv.h @@ -0,0 +1,52 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2019-2022 Second State INC + +#pragma once + +#include "plugin/plugin.h" + +#include +#include +#include + +#include + +/** + * @brief A struct which maps perfectly to a wasm 32bit z_stream object + * + */ +struct Wasm_z_stream { + uint32_t next_in; + uint32_t avail_in; + uint32_t total_in; + + uint32_t next_out; + uint32_t avail_out; + uint32_t total_out; + + uint32_t msg; + uint32_t state; + + uint32_t zalloc; + uint32_t zfree; + uint32_t opaque; + + int32_t data_type; // +ve & 2's complement in memory so int ~ uint + + uint32_t adler; + uint32_t reserved; +}; // 56 bytes + +namespace WasmEdge { +namespace Host { + +class WasmEdgeZlibEnvironment { +public: + std::unordered_map> ZStreamMap; + + /// Initial Configurations + static Plugin::PluginRegister Register; +}; + +} // namespace Host +} // namespace WasmEdge diff --git a/plugins/wasmedge_zlib/zlibmodule.h b/plugins/wasmedge_zlib/zlibmodule.h new file mode 100644 index 000000000000..e502993c73f2 --- /dev/null +++ b/plugins/wasmedge_zlib/zlibmodule.h @@ -0,0 +1,23 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2019-2022 Second State INC + +#pragma once + +#include "runtime/instance/module.h" +#include "zlibenv.h" + +namespace WasmEdge { +namespace Host { + +class WasmEdgeZlibModule : public Runtime::Instance::ModuleInstance { +public: + WasmEdgeZlibModule(); + + WasmEdgeZlibEnvironment &getEnv() { return Env; } + +private: + WasmEdgeZlibEnvironment Env; +}; + +} // namespace Host +} // namespace WasmEdge From c167c297a01082cb978b610b39687a4de8dbb6c1 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Tue, 6 Jun 2023 05:07:39 +0530 Subject: [PATCH 07/98] Added basic zlib function declarations. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.h | 58 ++++++++++++++++++++++++++++++++ 1 file changed, 58 insertions(+) create mode 100644 plugins/wasmedge_zlib/zlibfunc.h diff --git a/plugins/wasmedge_zlib/zlibfunc.h b/plugins/wasmedge_zlib/zlibfunc.h new file mode 100644 index 000000000000..513c10ce2117 --- /dev/null +++ b/plugins/wasmedge_zlib/zlibfunc.h @@ -0,0 +1,58 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2019-2022 Second State INC + +#pragma once + +#include "zlibbase.h" + +namespace WasmEdge { +namespace Host { + +class WasmEdgeZlibDeflateInit_ : public WasmEdgeZlib { +public: + WasmEdgeZlibDeflateInit_(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + int32_t Level, uint32_t VersionPtr, uint32_t StreamSize); +}; + +class WasmEdgeZlibInflateInit_ : public WasmEdgeZlib { +public: + WasmEdgeZlibInflateInit_(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + uint32_t VersionPtr, uint32_t StreamSize); +}; + +class WasmEdgeZlibDeflate : public WasmEdgeZlib { +public: + WasmEdgeZlibDeflate(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + int32_t Flush); +}; + +class WasmEdgeZlibInflate : public WasmEdgeZlib { +public: + WasmEdgeZlibInflate(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + int32_t Flush); +}; + +class WasmEdgeZlibDeflateEnd : public WasmEdgeZlib { +public: + WasmEdgeZlibDeflateEnd(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr); +}; + +class WasmEdgeZlibInflateEnd : public WasmEdgeZlib { +public: + WasmEdgeZlibInflateEnd(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr); +}; + +} // namespace Host +} // namespace WasmEdge From 9b9e14de7ddccec003de1fc96937b01527fae9ce Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Tue, 6 Jun 2023 05:09:05 +0530 Subject: [PATCH 08/98] Added zlib env implementation & PluginDescriptor. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibenv.cpp | 39 +++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 plugins/wasmedge_zlib/zlibenv.cpp diff --git a/plugins/wasmedge_zlib/zlibenv.cpp b/plugins/wasmedge_zlib/zlibenv.cpp new file mode 100644 index 000000000000..45654a288e4b --- /dev/null +++ b/plugins/wasmedge_zlib/zlibenv.cpp @@ -0,0 +1,39 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2019-2022 Second State INC + +#include "zlibenv.h" +#include "zlibmodule.h" + +namespace WasmEdge { +namespace Host { + +namespace { + +Runtime::Instance::ModuleInstance * +create(const Plugin::PluginModule::ModuleDescriptor *) noexcept { + return new WasmEdgeZlibModule; +} + +Plugin::Plugin::PluginDescriptor Descriptor{ + .Name = "wasmedge_zlib", + .Description = "", + .APIVersion = Plugin::Plugin::CurrentAPIVersion, + .Version = {0, 10, 1, 0}, + .ModuleCount = 1, + .ModuleDescriptions = + (Plugin::PluginModule::ModuleDescriptor[]){ + { + .Name = "wasmedge_zlib", + .Description = "", + .Create = create, + }, + }, + .AddOptions = nullptr, +}; + +} // namespace + +Plugin::PluginRegister WasmEdgeZlibEnvironment::Register(&Descriptor); + +} // namespace Host +} // namespace WasmEdge From fcaa19904597c16d793e680329194b8211b5ba99 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Tue, 6 Jun 2023 05:15:02 +0530 Subject: [PATCH 09/98] Added zlib module implementation, and added Host Functions. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibmodule.cpp | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 plugins/wasmedge_zlib/zlibmodule.cpp diff --git a/plugins/wasmedge_zlib/zlibmodule.cpp b/plugins/wasmedge_zlib/zlibmodule.cpp new file mode 100644 index 000000000000..2ed39b509212 --- /dev/null +++ b/plugins/wasmedge_zlib/zlibmodule.cpp @@ -0,0 +1,27 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2019-2022 Second State INC + +#include "zlibmodule.h" +#include "zlibfunc.h" + +namespace WasmEdge { +namespace Host { + +/// Register your functions in module. +WasmEdgeZlibModule::WasmEdgeZlibModule() : ModuleInstance("wasmedge_zlib") { + addHostFunc("wasmedge_zlib_deflateInit_", + std::make_unique(Env)); + addHostFunc("wasmedge_zlib_inflateInit_", + std::make_unique(Env)); + addHostFunc("wasmedge_zlib_deflate", + std::make_unique(Env)); + addHostFunc("wasmedge_zlib_inflate", + std::make_unique(Env)); + addHostFunc("wasmedge_zlib_deflateEnd", + std::make_unique(Env)); + addHostFunc("wasmedge_zlib_inflateEnd", + std::make_unique(Env)); +} + +} // namespace Host +} // namespace WasmEdge From bf6adcdb00a2859bcedddcfa1c82e6a4ae961bfb Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Tue, 6 Jun 2023 06:37:01 +0530 Subject: [PATCH 10/98] Added zlib plugin WasmEdgeZlibDeflateInit_ implementation. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 55 ++++++++++++++++++++++++++++++ 1 file changed, 55 insertions(+) create mode 100644 plugins/wasmedge_zlib/zlibfunc.cpp diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp new file mode 100644 index 000000000000..6d38852ee105 --- /dev/null +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -0,0 +1,55 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2019-2022 Second State INC + +#include "zlibfunc.h" + +#include +#include + +namespace WasmEdge { +namespace Host { + +Expect +WasmEdgeZlibDeflateInit_::body(const Runtime::CallingFrame &Frame, + uint32_t ZStreamPtr, int32_t Level, + uint32_t VersionPtr, uint32_t StreamSize) { + + auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + // Wasm_z_stream *WasmZStream = MemInst->getPointer(ZStreamPtr); + if (StreamSize != 56) { + spdlog::error("[WasmEdge Zlib] [WasmEdgeZlibDeflateInit_] WASM " + "sizeof(z_stream) != 56 but {}", + StreamSize); + return Unexpect(ErrCode::Value::HostFuncError); + } + + const char *WasmZlibVersion = MemInst->getPointer(VersionPtr); + if (WasmZlibVersion[0] != ZLIB_VERSION[0]) { + spdlog::error("[WasmEdge Zlib] [WasmEdgeZlibDeflateInit_] Major Zlib " + "version of Host ({}) & Wasm ({}) " + "does not match", + ZLIB_VERSION[0], WasmZlibVersion[0]); + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto HostZStream = std::make_unique(); + + HostZStream.get()->zalloc = Z_NULL; + HostZStream.get()->zfree = Z_NULL; + HostZStream.get()->opaque = + Z_NULL; // ignore opaque since zmalloc and zfree was ignored + + const auto z_res = + deflateInit_(HostZStream.get(), Level, ZLIB_VERSION, sizeof(z_stream)); + + Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); + + return static_cast(z_res); +} + +} // namespace Host +} // namespace WasmEdge From 9615d7b6a44ea11cea9986e913fc5a77b3fb3350 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Tue, 6 Jun 2023 06:38:29 +0530 Subject: [PATCH 11/98] Added zlib plugin WasmEdgeZlibInflateInit_ implementation. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 42 ++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 6d38852ee105..8c08eefe3caa 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -51,5 +51,47 @@ WasmEdgeZlibDeflateInit_::body(const Runtime::CallingFrame &Frame, return static_cast(z_res); } +Expect +WasmEdgeZlibInflateInit_::body(const Runtime::CallingFrame &Frame, + uint32_t ZStreamPtr, uint32_t VersionPtr, + uint32_t StreamSize) { + + auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + // Wasm_z_stream *WasmZStream = MemInst->getPointer(ZStreamPtr); + if (StreamSize != 56) { + spdlog::error("[WasmEdge Zlib] [WasmEdgeZlibInflateInit_] WASM " + "sizeof(z_stream) != 56 but {}", + StreamSize); + return Unexpect(ErrCode::Value::HostFuncError); + } + + const char *WasmZlibVersion = MemInst->getPointer(VersionPtr); + if (WasmZlibVersion[0] != ZLIB_VERSION[0]) { + spdlog::error("[WasmEdge Zlib] [WasmEdgeZlibInflateInit_] Major Zlib " + "version of Host ({}) & Wasm ({}) " + "does not match", + ZLIB_VERSION[0], WasmZlibVersion[0]); + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto HostZStream = std::make_unique(); + + HostZStream.get()->zalloc = Z_NULL; + HostZStream.get()->zfree = Z_NULL; + HostZStream.get()->opaque = + Z_NULL; // ignore opaque since zmalloc and zfree was ignored + + const auto z_res = + inflateInit_(HostZStream.get(), ZLIB_VERSION, sizeof(z_stream)); + + Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); + + return static_cast(z_res); +} + } // namespace Host } // namespace WasmEdge From 73e1dcb76f079805fe9e5c38170d94cdbadccb0e Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Tue, 6 Jun 2023 06:44:29 +0530 Subject: [PATCH 12/98] Added zlib plugin WasmEdgeZlibDeflate implementation. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 8c08eefe3caa..78c5440ffc85 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -93,5 +93,33 @@ WasmEdgeZlibInflateInit_::body(const Runtime::CallingFrame &Frame, return static_cast(z_res); } +Expect WasmEdgeZlibDeflate::WasmEdgeZlibDeflate::body( + const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t Flush) { + + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + auto HostZStream = HostZStreamIt->second.get(); + auto *MemInst = Frame.getMemoryByIndex(0); + Wasm_z_stream *WasmZStream = MemInst->getPointer(ZStreamPtr); + // get the whole memory from start + unsigned char *WasmMemStart = MemInst->getPointer(0); + + HostZStream->avail_in = WasmZStream->avail_in; // value + HostZStream->avail_out = WasmZStream->avail_out; // value + HostZStream->next_in = WasmMemStart + WasmZStream->next_in; // ptr + HostZStream->next_out = WasmMemStart + WasmZStream->next_out; // ptr + + const auto z_res = deflate(HostZStream, Flush); + + WasmZStream->avail_in = HostZStream->avail_in; + WasmZStream->avail_out = HostZStream->avail_out; + WasmZStream->next_in = HostZStream->next_in - WasmMemStart; + WasmZStream->next_out = HostZStream->next_out - WasmMemStart; + + return static_cast(z_res); +} + } // namespace Host } // namespace WasmEdge From 0e61ff487c0cd25a3ea59dde3fdb40d0843803e9 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Tue, 6 Jun 2023 06:46:14 +0530 Subject: [PATCH 13/98] Added zlib plugin WasmEdgeZlibInflate implementation. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 78c5440ffc85..f0fe1761f77f 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -121,5 +121,31 @@ Expect WasmEdgeZlibDeflate::WasmEdgeZlibDeflate::body( return static_cast(z_res); } +Expect WasmEdgeZlibInflate::body(const Runtime::CallingFrame &Frame, + uint32_t ZStreamPtr, int32_t Flush) { + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + auto HostZStream = HostZStreamIt->second.get(); + auto *MemInst = Frame.getMemoryByIndex(0); + Wasm_z_stream *WasmZStream = MemInst->getPointer(ZStreamPtr); + unsigned char *WasmMemStart = MemInst->getPointer(0); + + HostZStream->avail_in = WasmZStream->avail_in; // value + HostZStream->avail_out = WasmZStream->avail_out; // value + HostZStream->next_in = WasmMemStart + WasmZStream->next_in; // ptr + HostZStream->next_out = WasmMemStart + WasmZStream->next_out; // ptr + + const auto z_res = inflate(HostZStream, Flush); + + WasmZStream->avail_in = HostZStream->avail_in; + WasmZStream->avail_out = HostZStream->avail_out; + WasmZStream->next_in = HostZStream->next_in - WasmMemStart; + WasmZStream->next_out = HostZStream->next_out - WasmMemStart; + + return static_cast(z_res); +} + } // namespace Host } // namespace WasmEdge From 9f692f00b9b7ef50acf6b7562dd6629745048210 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Tue, 6 Jun 2023 06:49:30 +0530 Subject: [PATCH 14/98] Added zlib plugin WasmEdgeZlibDeflateEnd implementation. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index f0fe1761f77f..e2ea2d4427da 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -147,5 +147,24 @@ Expect WasmEdgeZlibInflate::body(const Runtime::CallingFrame &Frame, return static_cast(z_res); } +Expect WasmEdgeZlibDeflateEnd::body(const Runtime::CallingFrame &, + uint32_t ZStreamPtr) { + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + auto HostZStream = HostZStreamIt->second.get(); + int32_t ZRes = deflateEnd(HostZStream); + + Env.ZStreamMap.erase(ZStreamPtr); + + return static_cast(ZRes); +} + } // namespace Host } // namespace WasmEdge + +/* +TODO: +sync *msg in [inflate|deflate]End() +*/ From face6ab6df477905441777c8c375542b0465b793 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Tue, 6 Jun 2023 06:50:59 +0530 Subject: [PATCH 15/98] Added zlib plugin WasmEdgeZlibInflateEnd implementation. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index e2ea2d4427da..508c8b816264 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -161,6 +161,20 @@ Expect WasmEdgeZlibDeflateEnd::body(const Runtime::CallingFrame &, return static_cast(ZRes); } +Expect WasmEdgeZlibInflateEnd::body(const Runtime::CallingFrame &, + uint32_t ZStreamPtr) { + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + auto HostZStream = HostZStreamIt->second.get(); + int32_t ZRes = inflateEnd(HostZStream); + + Env.ZStreamMap.erase(ZStreamPtr); + + return static_cast(ZRes); +} + } // namespace Host } // namespace WasmEdge From a0cc2d24acd2f2c27ba6f939fd6c9d2748edbdc9 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Tue, 6 Jun 2023 07:10:19 +0530 Subject: [PATCH 16/98] Populated plugins/wasmedge_zlib/CMakeLists.txt to build & link the zlib plugin source. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/CMakeLists.txt | 31 ++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/plugins/wasmedge_zlib/CMakeLists.txt b/plugins/wasmedge_zlib/CMakeLists.txt index 820136e08ddc..64907bb37f92 100644 --- a/plugins/wasmedge_zlib/CMakeLists.txt +++ b/plugins/wasmedge_zlib/CMakeLists.txt @@ -15,3 +15,34 @@ FetchContent_Declare( ) FetchContent_MakeAvailable(ZLIB) +wasmedge_add_library(wasmedgePluginWasmEdgeZlib + SHARED + zlibenv.cpp + zlibfunc.cpp + zlibmodule.cpp +) + +target_compile_options(wasmedgePluginWasmEdgeZlib + PUBLIC + -DWASMEDGE_PLUGIN +) + +target_include_directories(wasmedgePluginWasmEdgeZlib + PUBLIC + $ + ${CMAKE_CURRENT_SOURCE_DIR} +) + +if(WASMEDGE_LINK_PLUGINS_STATIC) + target_link_libraries(wasmedgePluginWasmEdgeZlib + PRIVATE + wasmedgeCAPI + ) +else() + target_link_libraries(wasmedgePluginWasmEdgeZlib + PRIVATE + wasmedge_shared + ) +endif() + +install(TARGETS wasmedgePluginWasmEdgeZlib DESTINATION ${CMAKE_INSTALL_LIBDIR}/wasmedge) From a98bca1ff6fcc073fc675c1d10ee272435fbcb86 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Tue, 6 Jun 2023 07:40:39 +0530 Subject: [PATCH 17/98] Fix: Added ZLIB as link dep to wasmedge_zlib plugin. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/CMakeLists.txt | 2 ++ 1 file changed, 2 insertions(+) diff --git a/plugins/wasmedge_zlib/CMakeLists.txt b/plugins/wasmedge_zlib/CMakeLists.txt index 64907bb37f92..70dd17ec4228 100644 --- a/plugins/wasmedge_zlib/CMakeLists.txt +++ b/plugins/wasmedge_zlib/CMakeLists.txt @@ -37,11 +37,13 @@ if(WASMEDGE_LINK_PLUGINS_STATIC) target_link_libraries(wasmedgePluginWasmEdgeZlib PRIVATE wasmedgeCAPI + ZLIB ) else() target_link_libraries(wasmedgePluginWasmEdgeZlib PRIVATE wasmedge_shared + ZLIB ) endif() From 2b8668580ec73cdc0a3b737107385735c13b389d Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Tue, 6 Jun 2023 08:26:36 +0530 Subject: [PATCH 18/98] Added basic test for zlib plugin; WIP/TODO. Signed-off-by: Saikat Dey --- test/plugins/wasmedge_zlib/wasmedge_zlib.cpp | 54 ++++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 test/plugins/wasmedge_zlib/wasmedge_zlib.cpp diff --git a/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp b/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp new file mode 100644 index 000000000000..04c768294525 --- /dev/null +++ b/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp @@ -0,0 +1,54 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2019-2022 Second State INC + +#include "common/defines.h" +#include "zlibfunc.h" +#include "zlibmodule.h" +#include "runtime/instance/module.h" + +#include +#include +#include +#include +#include +#include + +namespace { +WasmEdge::Runtime::CallingFrame DummyCallFrame(nullptr, nullptr); + +WasmEdge::Runtime::Instance::ModuleInstance *createModule() { + using namespace std::literals::string_view_literals; + WasmEdge::Plugin::Plugin::load(std::filesystem::u8path( + "../../../plugins/wasmedge_zlib/" + "libwasmedgePluginWasmEdgeZlib" WASMEDGE_LIB_EXTENSION)); + if (const auto *Plugin = WasmEdge::Plugin::Plugin::find("wasmedge_zlib"sv)) { + if (const auto *Module = Plugin->findModule("wasmedge_zlib"sv)) { + return Module->create().release(); + } + } + return nullptr; +} + +} // namespace + +TEST(WasmEdgeZlibTest, Module) { + // Create the wasmedge_process module instance. + auto *ZlibMod = + dynamic_cast(createModule()); + EXPECT_FALSE(ZlibMod == nullptr); + EXPECT_TRUE(ZlibMod->getEnv().ZStreamMap.empty()); + EXPECT_EQ(ZlibMod->getFuncExportNum(), 6U); + EXPECT_NE(ZlibMod->findFuncExports("wasmedge_zlib_deflateInit_"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("wasmedge_zlib_inflateInit_"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("wasmedge_zlib_deflate"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("wasmedge_zlib_inflate"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("wasmedge_zlib_deflateEnd"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("wasmedge_zlib_inflateEnd"), nullptr); + + delete ZlibMod; +} + +GTEST_API_ int main(int argc, char **argv) { + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} From bc857cce1c8e1299470bc85537d9ffb8d95cea0f Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Tue, 6 Jun 2023 08:28:11 +0530 Subject: [PATCH 19/98] Added test/plugins/wasmedge_zlib/CMakeLists.txt to build and create zlib test executable. Signed-off-by: Saikat Dey --- test/plugins/wasmedge_zlib/CMakeLists.txt | 35 +++++++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 test/plugins/wasmedge_zlib/CMakeLists.txt diff --git a/test/plugins/wasmedge_zlib/CMakeLists.txt b/test/plugins/wasmedge_zlib/CMakeLists.txt new file mode 100644 index 000000000000..7159ab83d922 --- /dev/null +++ b/test/plugins/wasmedge_zlib/CMakeLists.txt @@ -0,0 +1,35 @@ +# SPDX-License-Identifier: Apache-2.0 +# SPDX-FileCopyrightText: 2019-2022 Second State INC + +wasmedge_add_executable(wasmedgeZlibTests + wasmedge_zlib.cpp +) + +add_dependencies(wasmedgeZlibTests + wasmedgePluginWasmEdgeZlib +) + +target_include_directories(wasmedgeZlibTests + PUBLIC + $ + $ +) + +target_link_libraries(wasmedgeZlibTests + PRIVATE + ${GTEST_BOTH_LIBRARIES} +) +# Link to the WasmEdge library +if(WASMEDGE_LINK_PLUGINS_STATIC) + target_link_libraries(wasmedgeZlibTests + PRIVATE + wasmedgeCAPI + ) +else() + target_link_libraries(wasmedgeZlibTests + PRIVATE + wasmedge_shared + ) +endif() + +add_test(wasmedgeZlibTests wasmedgeZlibTests) From 7b0ed641b3777d704520bfec70e9ebaee42543ca Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Tue, 6 Jun 2023 08:30:18 +0530 Subject: [PATCH 20/98] Include zlib plugin test sub directory in test/plugins/CMakeLists.txt. Signed-off-by: Saikat Dey --- test/plugins/CMakeLists.txt | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/test/plugins/CMakeLists.txt b/test/plugins/CMakeLists.txt index 5a5f7c353d6b..190854e50d67 100644 --- a/test/plugins/CMakeLists.txt +++ b/test/plugins/CMakeLists.txt @@ -7,6 +7,10 @@ if(WASMEDGE_PLUGIN_PROCESS) endif() endif() +if(WASMEDGE_PLUGIN_ZLIB) + add_subdirectory(wasmedge_zlib) +endif() + if(WASMEDGE_PLUGIN_WASI_NN_BACKEND) add_subdirectory(wasi_nn) endif() From d6d969f87da1603f7926d9764e85c42d3557d5c9 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Tue, 6 Jun 2023 09:17:09 +0530 Subject: [PATCH 21/98] Fixed naming convention by omitting namespace prefix from function name. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibmodule.cpp | 18 ++++++------------ test/plugins/wasmedge_zlib/wasmedge_zlib.cpp | 12 ++++++------ 2 files changed, 12 insertions(+), 18 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibmodule.cpp b/plugins/wasmedge_zlib/zlibmodule.cpp index 2ed39b509212..191151e300d5 100644 --- a/plugins/wasmedge_zlib/zlibmodule.cpp +++ b/plugins/wasmedge_zlib/zlibmodule.cpp @@ -9,18 +9,12 @@ namespace Host { /// Register your functions in module. WasmEdgeZlibModule::WasmEdgeZlibModule() : ModuleInstance("wasmedge_zlib") { - addHostFunc("wasmedge_zlib_deflateInit_", - std::make_unique(Env)); - addHostFunc("wasmedge_zlib_inflateInit_", - std::make_unique(Env)); - addHostFunc("wasmedge_zlib_deflate", - std::make_unique(Env)); - addHostFunc("wasmedge_zlib_inflate", - std::make_unique(Env)); - addHostFunc("wasmedge_zlib_deflateEnd", - std::make_unique(Env)); - addHostFunc("wasmedge_zlib_inflateEnd", - std::make_unique(Env)); + addHostFunc("deflateInit_", std::make_unique(Env)); + addHostFunc("inflateInit_", std::make_unique(Env)); + addHostFunc("deflate", std::make_unique(Env)); + addHostFunc("inflate", std::make_unique(Env)); + addHostFunc("deflateEnd", std::make_unique(Env)); + addHostFunc("inflateEnd", std::make_unique(Env)); } } // namespace Host diff --git a/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp b/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp index 04c768294525..46b5edfa0496 100644 --- a/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp +++ b/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp @@ -38,12 +38,12 @@ TEST(WasmEdgeZlibTest, Module) { EXPECT_FALSE(ZlibMod == nullptr); EXPECT_TRUE(ZlibMod->getEnv().ZStreamMap.empty()); EXPECT_EQ(ZlibMod->getFuncExportNum(), 6U); - EXPECT_NE(ZlibMod->findFuncExports("wasmedge_zlib_deflateInit_"), nullptr); - EXPECT_NE(ZlibMod->findFuncExports("wasmedge_zlib_inflateInit_"), nullptr); - EXPECT_NE(ZlibMod->findFuncExports("wasmedge_zlib_deflate"), nullptr); - EXPECT_NE(ZlibMod->findFuncExports("wasmedge_zlib_inflate"), nullptr); - EXPECT_NE(ZlibMod->findFuncExports("wasmedge_zlib_deflateEnd"), nullptr); - EXPECT_NE(ZlibMod->findFuncExports("wasmedge_zlib_inflateEnd"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("deflateInit_"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("inflateInit_"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("deflate"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("inflate"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("deflateEnd"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("inflateEnd"), nullptr); delete ZlibMod; } From 2027eacfb574416c9b0ec9f8c0c969a4b72e964f Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Wed, 7 Jun 2023 07:29:21 +0530 Subject: [PATCH 22/98] Fix case sensitivity in CMake of zlib library. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/CMakeLists.txt | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/plugins/wasmedge_zlib/CMakeLists.txt b/plugins/wasmedge_zlib/CMakeLists.txt index 70dd17ec4228..30fa7d733d40 100644 --- a/plugins/wasmedge_zlib/CMakeLists.txt +++ b/plugins/wasmedge_zlib/CMakeLists.txt @@ -8,12 +8,12 @@ set(ZLIB_COMPAT ON) set(ZLIBNG_ENABLE_TESTS OFF) FetchContent_Declare( - ZLIB + zlib GIT_REPOSITORY "https://github.com/zlib-ng/zlib-ng.git" GIT_TAG 2.0.7 GIT_PROGRESS TRUE ) -FetchContent_MakeAvailable(ZLIB) +FetchContent_MakeAvailable(zlib) wasmedge_add_library(wasmedgePluginWasmEdgeZlib SHARED @@ -37,13 +37,13 @@ if(WASMEDGE_LINK_PLUGINS_STATIC) target_link_libraries(wasmedgePluginWasmEdgeZlib PRIVATE wasmedgeCAPI - ZLIB + zlib ) else() target_link_libraries(wasmedgePluginWasmEdgeZlib PRIVATE wasmedge_shared - ZLIB + zlib ) endif() From 28cc2cf6f9c8ba90a5d53ed6b429a1afb75973e2 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Wed, 7 Jun 2023 08:40:31 +0530 Subject: [PATCH 23/98] Refactor build-extensions.yml to be in-line with upstream master. Signed-off-by: Saikat Dey --- .github/workflows/build-extensions.yml | 626 +++++++++++++------------ 1 file changed, 315 insertions(+), 311 deletions(-) diff --git a/.github/workflows/build-extensions.yml b/.github/workflows/build-extensions.yml index 37f001e6f299..f329ecce7cca 100644 --- a/.github/workflows/build-extensions.yml +++ b/.github/workflows/build-extensions.yml @@ -55,126 +55,112 @@ jobs: echo "Set version: $(git describe --match "[0-9].[0-9]*" --tag)" echo "version=$(git describe --match '[0-9].[0-9]*' --tag)" >> $GITHUB_OUTPUT - build_ubuntu: + # Due to the dependencies and exclusions of WASI-NN, build them saperately. + build_ubuntu_wasi_nn: strategy: matrix: include: - - name: WASI-NN PyTorch - tar_name: wasi_nn-pytorch - backend: PyTorch - compiler: clang++ - docker_tag: ubuntu-build-clang - output_path: plugins/wasi_nn - output_bin: libwasmedgePluginWasiNN.so - test_path: test/plugins/wasi_nn - test_bin: wasiNNTests - build_type: Release - - name: WASI-NN PyTorch - tar_name: wasi_nn-pytorch - backend: PyTorch - compiler: g++ - docker_tag: ubuntu-build-gcc - output_path: plugins/wasi_nn - output_bin: libwasmedgePluginWasiNN.so - test_path: test/plugins/wasi_nn - test_bin: wasiNNTests - build_type: Release - - name: WASI-NN OpenVINO - tar_name: wasi_nn-openvino - backend: OpenVINO - compiler: g++ - docker_tag: ubuntu-build-gcc - output_path: plugins/wasi_nn - output_bin: libwasmedgePluginWasiNN.so - test_path: test/plugins/wasi_nn - test_bin: wasiNNTests - build_type: Release - - name: WASI-NN OpenVINO - tar_name: wasi_nn-openvino - backend: OpenVINO - compiler: clang++ - docker_tag: ubuntu-build-clang - output_path: plugins/wasi_nn - output_bin: libwasmedgePluginWasiNN.so - test_path: test/plugins/wasi_nn - test_bin: wasiNNTests - build_type: Release - - name: WASI-NN TensorFlowLite - tar_name: wasi_nn-tensorflowlite - backend: TensorFlowLite - compiler: g++ - docker_tag: ubuntu-build-gcc - output_path: plugins/wasi_nn - output_bin: libwasmedgePluginWasiNN.so - test_path: test/plugins/wasi_nn - test_bin: wasiNNTests - build_type: Release - - name: WASI-NN TensorFlowLite - tar_name: wasi_nn-tensorflowlite - backend: TensorFlowLite - compiler: clang++ - docker_tag: ubuntu-build-clang - output_path: plugins/wasi_nn - output_bin: libwasmedgePluginWasiNN.so - test_path: test/plugins/wasi_nn - test_bin: wasiNNTests - build_type: Release - - name: WASI-Crypto - tar_name: wasi_crypto - compiler: g++ - docker_tag: ubuntu-build-gcc - output_path: plugins/wasi_crypto - output_bin: libwasmedgePluginWasiCrypto.so - test_path: test/plugins/wasi_crypto - test_bin: wasiCryptoTests - build_type: Release - - name: WASI-Crypto - tar_name: wasi_crypto - compiler: clang++ - docker_tag: ubuntu-build-clang - output_path: plugins/wasi_crypto - output_bin: libwasmedgePluginWasiCrypto.so - test_path: test/plugins/wasi_crypto - test_bin: wasiCryptoTests - build_type: Release - - name: Process - tar_name: wasmedge_process + - name: Plugins_g++ compiler: g++ docker_tag: ubuntu-build-gcc - output_path: plugins/wasmedge_process - output_bin: libwasmedgePluginWasmEdgeProcess.so - test_path: test/plugins/wasmedge_process - test_bin: wasmedgeProcessTests build_type: Release - - name: Process - tar_name: wasmedge_process + - name: Plugins_clang++ compiler: clang++ docker_tag: ubuntu-build-clang - output_path: plugins/wasmedge_process - output_bin: libwasmedgePluginWasmEdgeProcess.so - test_path: test/plugins/wasmedge_process - test_bin: wasmedgeProcessTests build_type: Release - - name: Zlib - tar_name: wasmedge_zlib + name: Ubuntu WASI-NN with ${{ matrix.compiler }} ${{ matrix.build_type }} + runs-on: ubuntu-latest + env: + output_dir: build/plugins/wasi_nn + test_dir: build/test/plugins/wasi_nn + build_options: -DWASMEDGE_PLUGIN_WASI_NN_BACKEND=PyTorch -DWASMEDGE_PLUGIN_WASI_NN_BACKEND=OpenVINO -DWASMEDGE_PLUGIN_WASI_NN_BACKEND=TensorFlowLite + tar_names: wasi_nn-pytorch wasi_nn-openvino wasi_nn-tensorflowlite + test_bin: wasiNNTests + output_bin: libwasmedgePluginWasiNN.so + OPENVINO_VERSION: "2021.4.582" + OPENVINO_YEAR: "2021" + PYTORCH_VERSION: "1.8.2" + PYTORCH_INSTALL_TO: "build" + needs: [get_version_v2] + container: + image: wasmedge/wasmedge:${{ matrix.docker_tag }} + steps: + - uses: actions/checkout@v3 + with: + fetch-depth: 0 + - name: Install dependencies + shell: bash + run: | + apt update + apt install unzip + mkdir -p build + bash utils/wasi-nn/install-openvino.sh + bash utils/wasi-nn/install-pytorch.sh + - name: Build and test WASI-NN using ${{ matrix.compiler }} with ${{ matrix.build_type }} mode + shell: bash + run: | + source /opt/intel/openvino_2021/bin/setupvars.sh + export Torch_DIR=$(pwd)/${PYTORCH_INSTALL_TO}/libtorch + ldconfig + plugin_array=(${tar_names}) + option_array=(${build_options}) + cd build + cmake -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DWASMEDGE_BUILD_TESTS=ON .. + cd .. + for (( i=0; i<${#plugin_array[@]}; i++ )); + do + echo "Building ${plugin_array[$i]} backend:" + cd build + cmake ${option_array[$i]} .. + cd .. + cd ${test_dir} + make -j + + echo "Testing ${plugin_array[$i]} backend:" + ./${test_bin} + cd - + + echo "Copying ${plugin_array[$i]} backend:" + cp -f ${output_dir}/${output_bin} ${output_bin} + tar -zcvf plugin_${plugin_array[$i]}.tar.gz ${output_bin} + done + - name: Upload artifact - wasi_nn-pytorch + uses: actions/upload-artifact@v3 + with: + name: WasmEdge-plugin-wasi_nn-pytorch-${{ needs.get_version_v2.outputs.version }}-ubuntu22.04-${{ matrix.compiler }}.tar.gz + path: plugin_wasi_nn-pytorch.tar.gz + - name: Upload artifact - wasi_nn-openvino + uses: actions/upload-artifact@v3 + with: + name: WasmEdge-plugin-wasi_nn-openvino-${{ needs.get_version_v2.outputs.version }}-ubuntu22.04-${{ matrix.compiler }}.tar.gz + path: plugin_wasi_nn-openvino.tar.gz + - name: Upload artifact - wasi_nn-tensorflowlite + uses: actions/upload-artifact@v3 + with: + name: WasmEdge-plugin-wasi_nn-tensorflowlite-${{ needs.get_version_v2.outputs.version }}-ubuntu22.04-${{ matrix.compiler }}.tar.gz + path: plugin_wasi_nn-tensorflowlite.tar.gz + + build_ubuntu: + strategy: + matrix: + include: + - name: Plugins_g++ compiler: g++ docker_tag: ubuntu-build-gcc - output_path: plugins/wasmedge_zlib - output_bin: libwasmedgePluginWasmEdgeZlib.so - test_path: test/plugins/wasmedge_zlib - test_bin: wasmedgeZlibTests build_type: Release - - name: Zlib - tar_name: wasmedge_zlib + - name: Plugins_clang++ compiler: clang++ docker_tag: ubuntu-build-clang - output_path: plugins/wasmedge_zlib - output_bin: libwasmedgePluginWasmEdgeZlib.so - test_path: test/plugins/wasmedge_zlib - test_bin: wasmedgeZlibTests build_type: Release - name: Ubuntu WasmEdge ${{ matrix.name }} plugin with ${{ matrix.compiler}} ${{ matrix.build_type}} + name: Ubuntu plugins with ${{ matrix.compiler }} ${{ matrix.build_type }} runs-on: ubuntu-latest + env: + output_prefix: build/plugins + test_prefix: build/test/plugins + build_options: -DWASMEDGE_PLUGIN_PROCESS=ON -DWASMEDGE_PLUGIN_WASI_CRYPTO=ON -DWASMEDGE_PLUGIN_WASI_ZLIB=ON + tar_names: wasi_crypto wasmedge_process wasmedge_zlib + test_bins: wasiCryptoTests wasmedgeProcessTests wasmedgeZlibTests + output_bins: libwasmedgePluginWasiCrypto.so libwasmedgePluginWasmEdgeProcess.so libwasmedgePluginWasmEdgeZlib.so needs: [get_version_v2] container: image: wasmedge/wasmedge:${{ matrix.docker_tag }} @@ -182,187 +168,163 @@ jobs: - uses: actions/checkout@v3 with: fetch-depth: 0 - - name: Build WasmEdge WASI-NN ${{ matrix.backend }} plugin using ${{ matrix.compiler }} with ${{ matrix.build_type }} mode - shell: bash - if: contains(matrix.name, 'WASI-NN') - env: - OPENVINO_VERSION: "2021.4.582" - OPENVINO_YEAR: "2021" - PYTORCH_VERSION: "1.8.2" - PYTORCH_INSTALL_TO: "build" - run: | - mkdir -p build - if [[ "${{ matrix.name }}" == *"OpenVINO"* ]]; then - bash utils/wasi-nn/install-openvino.sh - source /opt/intel/openvino_2021/bin/setupvars.sh - ldconfig - fi - if [[ "${{ matrix.name }}" == *"PyTorch"* ]]; then - apt update - apt install unzip - bash utils/wasi-nn/install-pytorch.sh - export Torch_DIR=$(pwd)/${PYTORCH_INSTALL_TO}/libtorch - fi - cd build - cmake -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DWASMEDGE_PLUGIN_WASI_NN_BACKEND="${{ matrix.backend }}" -DWASMEDGE_BUILD_TESTS=ON .. - cd ${{ matrix.test_path }} - make -j - - name: Build WasmEdge WASI-Crypto plugin using ${{ matrix.compiler }} with ${{ matrix.build_type }} mode - if: contains(matrix.name, 'WASI-Crypto') + - name: Install dependencies run: | apt update apt install -y libssl-dev - mkdir -p build - cd build - cmake -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DWASMEDGE_PLUGIN_WASI_CRYPTO=On -DWASMEDGE_BUILD_TESTS=ON .. - cd ${{ matrix.test_path }} - make -j - - name: Build WasmEdge Process plugin using ${{ matrix.compiler }} with ${{ matrix.build_type }} mode - if: contains(matrix.name, 'Process') - run: | - mkdir -p build - cd build - cmake -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DWASMEDGE_PLUGIN_PROCESS=ON -DWASMEDGE_BUILD_TESTS=ON .. - cd ${{ matrix.test_path }} - make -j - - name: Build WasmEdge Zlib plugin using ${{ matrix.compiler }} with ${{ matrix.build_type }} mode - if: contains(matrix.name, 'Zlib') + - name: Build plugins using ${{ matrix.compiler }} with ${{ matrix.build_type }} mode + shell: bash run: | + plugin_array=(${tar_names}) mkdir -p build cd build - cmake -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DWASMEDGE_PLUGIN_ZLIB=ON -DWASMEDGE_BUILD_TESTS=ON .. - cd ${{ matrix.test_path }} - make -j - - name: Test WasmEdge ${{ matrix.name }} plugin using ${{ matrix.compiler }} with ${{ matrix.build_type }} mode + cmake -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DWASMEDGE_BUILD_TESTS=ON ${build_options} .. + cd .. + for (( i=0; i<${#plugin_array[@]}; i++ )); + do + echo "Building ${plugin_array[$i]} :" + cd ${test_prefix}/${plugin_array[$i]} + make -j + cd - + done + - name: Test plugins shell: bash run: | - if [[ "${{ matrix.name }}" == *"OpenVINO"* ]]; then - source /opt/intel/openvino_2021/bin/setupvars.sh - ldconfig - fi - if [[ "${{ matrix.name }}" == *"PyTorch"* ]]; then - export LD_LIBRARY_PATH=$Torch_DIR/lib:$LD_LIBRARY_PATH - fi - cd build/${{ matrix.test_path }} - ./${{ matrix.test_bin }} - - name: Prepare the WasmEdge ${{ matrix.name }} plugin tar.gz package + plugin_array=(${tar_names}) + testbin_array=(${test_bins}) + for (( i=0; i<${#plugin_array[@]}; i++ )); + do + echo "Testing ${plugin_array[$i]} :" + cd ${test_prefix}/${plugin_array[$i]} + ./${testbin_array[$i]} + cd - + done + - name: Prepare the plugins tar.gz package + shell: bash run: | - cp build/${{ matrix.output_path }}/${{ matrix.output_bin }} ${{ matrix.output_bin }} - tar -zcvf plugin.tar.gz ${{ matrix.output_bin }} - - name: Upload artifact + plugin_array=(${tar_names}) + outbin_array=(${output_bins}) + for (( i=0; i<${#plugin_array[@]}; i++ )); + do + echo "Copying ${plugin_array[$i]} :" + cp ${output_prefix}/${plugin_array[$i]}/${outbin_array[$i]} ${outbin_array[$i]} + tar -zcvf plugin_${plugin_array[$i]}.tar.gz ${outbin_array[$i]} + done + - name: Upload artifact - wasi_crypto + uses: actions/upload-artifact@v3 + with: + name: WasmEdge-plugin-wasi_crypto-${{ needs.get_version_v2.outputs.version }}-ubuntu22.04-${{ matrix.compiler }}.tar.gz + path: plugin_wasi_crypto.tar.gz + - name: Upload artifact - wasmedge_process + uses: actions/upload-artifact@v3 + with: + name: WasmEdge-plugin-wasmedge_process-${{ needs.get_version_v2.outputs.version }}-ubuntu22.04-${{ matrix.compiler }}.tar.gz + path: plugin_wasmedge_process.tar.gz + - name: Upload artifact - wasmedge_zlib uses: actions/upload-artifact@v3 with: - name: WasmEdge-plugin-${{ matrix.tar_name }}-${{ needs.get_version_v2.outputs.version }}-ubuntu22.04-${{ matrix.compiler }}.tar.gz - path: plugin.tar.gz + name: WasmEdge-plugin-wasmedge_zlib-${{ needs.get_version_v2.outputs.version }}-ubuntu22.04-${{ matrix.compiler }}.tar.gz + path: plugin_wasmedge_zlib.tar.gz - build_manylinux: + # Due to the dependencies and exclusions of WASI-NN, build them saperately. + build_manylinux_wasi_nn: strategy: matrix: include: - - name: WASI-NN PyTorch - tar_name: wasi_nn-pytorch - backend: PyTorch - system: manylinux2014 x86_64 - host_runner: ubuntu-latest - docker_tag: manylinux2014_x86_64 - test_path: test/plugins/wasi_nn - test_bin: wasiNNTests - output_path: plugins/wasi_nn - output_bin: libwasmedgePluginWasiNN.so - deps_path: "utils/wasi-nn/install-pytorch.sh --disable-cxx11-abi" - cmake_plugin_option: "-DWASMEDGE_PLUGIN_WASI_NN_BACKEND=PyTorch" - build_type: Release - test: true - - name: WASI-NN Tensorflow Lite - tar_name: wasi_nn-tensorflowlite - backend: Tensorflowlite - system: manylinux2014 x86_64 - host_runner: ubuntu-latest - docker_tag: manylinux2014_x86_64 - test_path: test/plugins/wasi_nn - test_bin: wasiNNTests - output_path: plugins/wasi_nn - output_bin: libwasmedgePluginWasiNN.so - cmake_plugin_option: "-DWASMEDGE_PLUGIN_WASI_NN_BACKEND=TensorflowLite" - build_type: Release - test: true - - name: WASI-NN Tensorflow Lite - tar_name: wasi_nn-tensorflowlite - backend: Tensorflowlite - system: manylinux2014 aarch64 - host_runner: linux-arm64 - docker_tag: manylinux2014_aarch64 - test_path: test/plugins/wasi_nn - test_bin: wasiNNTests - output_path: plugins/wasi_nn - output_bin: libwasmedgePluginWasiNN.so - cmake_plugin_option: "-DWASMEDGE_PLUGIN_WASI_NN_BACKEND=TensorflowLite" - build_type: Release - test: true - - name: WASI-Crypto - tar_name: wasi_crypto - system: manylinux2014 x86_64 - host_runner: ubuntu-latest - docker_tag: manylinux2014_x86_64 - output_path: plugins/wasi_crypto - output_bin: libwasmedgePluginWasiCrypto.so - deps_path: "utils/wasi-crypto/build-openssl.sh" - cmake_plugin_option: "-DWASMEDGE_PLUGIN_WASI_CRYPTO=ON -DOPENSSL_ROOT_DIR=$(pwd)/openssl-1.1.1n/openssl" - build_type: Release - test: false - - name: WASI-Crypto - tar_name: wasi_crypto - system: manylinux2014 aarch64 - host_runner: linux-arm64 - docker_tag: manylinux2014_aarch64 - output_path: plugins/wasi_crypto - output_bin: libwasmedgePluginWasiCrypto.so - deps_path: "utils/wasi-crypto/build-openssl.sh" - cmake_plugin_option: "-DWASMEDGE_PLUGIN_WASI_CRYPTO=ON -DOPENSSL_ROOT_DIR=$(pwd)/openssl-1.1.1n/openssl" - build_type: Release - test: false - - name: Process - tar_name: wasmedge_process - system: manylinux2014 x86_64 + - name: Plugins_x86_64 host_runner: ubuntu-latest docker_tag: manylinux2014_x86_64 - output_path: plugins/wasmedge_process - output_bin: libwasmedgePluginWasmEdgeProcess.so - cmake_plugin_option: "-DWASMEDGE_PLUGIN_PROCESS=ON" build_type: Release - test: false - - name: Process - tar_name: wasmedge_process - system: manylinux2014 aarch64 + - name: Plugins_aarch64 host_runner: linux-arm64 docker_tag: manylinux2014_aarch64 - output_path: plugins/wasmedge_process - output_bin: libwasmedgePluginWasmEdgeProcess.so - cmake_plugin_option: "-DWASMEDGE_PLUGIN_PROCESS=ON" build_type: Release - test: false - - name: Zlib - tar_name: wasmedge_zlib - system: manylinux2014 x86_64 + name: ${{ matrix.docker_tag }} WASI-NN with g++ ${{ matrix.build_type }} + runs-on: ${{ matrix.host_runner }} + env: + output_dir: build/plugins/wasi_nn + test_dir: build/test/plugins/wasi_nn + build_options_manylinux2014_x86_64: -DWASMEDGE_PLUGIN_WASI_NN_BACKEND=PyTorch -DWASMEDGE_PLUGIN_WASI_NN_BACKEND=TensorFlowLite + build_options_manylinux2014_aarch64: -DWASMEDGE_PLUGIN_WASI_NN_BACKEND=TensorFlowLite + tar_names_manylinux2014_x86_64: wasi_nn-pytorch wasi_nn-tensorflowlite + tar_names_manylinux2014_aarch64: wasi_nn-tensorflowlite + test_bin: wasiNNTests + output_bin: libwasmedgePluginWasiNN.so + OPENVINO_VERSION: "2021.4.582" + OPENVINO_YEAR: "2021" + PYTORCH_VERSION: "1.8.2" + PYTORCH_INSTALL_TO: "build" + needs: [get_version_v2] + container: + image: wasmedge/wasmedge:${{ matrix.docker_tag }} + steps: + - uses: actions/checkout@v3 + with: + fetch-depth: 0 + - name: Install dependencies + shell: bash + run: | + mkdir -p build + bash ./utils/wasi-nn/install-pytorch.sh --disable-cxx11-abi + - name: Build and test WASI-NN using g++ with ${{ matrix.build_type }} mode + shell: bash + run: | + export Torch_DIR=$(pwd)/${PYTORCH_INSTALL_TO}/libtorch + plugin_array=(${tar_names_${{ matrix.docker_tag }}}) + option_array=(${build_options_${{ matrix.docker_tag }}}) + cd build + cmake -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DWASMEDGE_BUILD_TESTS=ON .. + cd .. + for (( i=0; i<${#plugin_array[@]}; i++ )); + do + echo "Building ${plugin_array[$i]} backend:" + cd build + cmake ${option_array[$i]} .. + cd .. + cd ${test_dir} + make -j + + echo "Testing ${plugin_array[$i]} backend:" + ./${test_bin} + cd - + + echo "Copying ${plugin_array[$i]} backend:" + cp -f ${output_dir}/${output_bin} ${output_bin} + tar -zcvf plugin_${plugin_array[$i]}.tar.gz ${output_bin} + done + - name: Upload artifact - wasi_nn-pytorch + if: contains(matrix.docker_tag, 'manylinux2014_x86_64') + uses: actions/upload-artifact@v3 + with: + name: WasmEdge-plugin-wasi_nn-pytorch-${{ needs.get_version_v2.outputs.version }}-${{ matrix.docker_tag }}.tar.gz + path: plugin_wasi_nn-pytorch.tar.gz + - name: Upload artifact - wasi_nn-tensorflowlite + uses: actions/upload-artifact@v3 + with: + name: WasmEdge-plugin-wasi_nn-tensorflowlite-${{ needs.get_version_v2.outputs.version }}-${{ matrix.docker_tag }}.tar.gz + path: plugin_wasi_nn-tensorflowlite.tar.gz + + build_manylinux: + strategy: + matrix: + include: + - name: Plugins_x86_64 host_runner: ubuntu-latest docker_tag: manylinux2014_x86_64 - output_path: plugins/wasmedge_zlib - output_bin: libwasmedgePluginWasmEdgeZlib.so - cmake_plugin_option: "-DWASMEDGE_PLUGIN_ZLIB=ON" build_type: Release - test: false - - name: Zlib - tar_name: wasmedge_zlib - system: manylinux2014 aarch64 + - name: Plugins_aarch64 host_runner: linux-arm64 docker_tag: manylinux2014_aarch64 - output_path: plugins/wasmedge_zlib - output_bin: libwasmedgePluginWasmEdgeZlib.so - cmake_plugin_option: "-DWASMEDGE_PLUGIN_ZLIB=ON" build_type: Release - test: false - name: ${{ matrix.system }} WasmEdge ${{ matrix.name }} plugin with g++ ${{ matrix.build_type }} + name: ${{ matrix.docker_tag }} plugins with g++ ${{ matrix.build_type }} runs-on: ${{ matrix.host_runner }} + env: + output_prefix: build/plugins + test_prefix: build/test/plugins + build_options: -DWASMEDGE_PLUGIN_PROCESS=ON -DWASMEDGE_PLUGIN_WASI_CRYPTO=ON -DWASMEDGE_PLUGIN_WASI_ZLIB=ON + tar_names: wasi_crypto wasmedge_process wasmedge_zlib + test_bins: wasiCryptoTests wasmedgeProcessTests wasmedgeZlibTests + output_bins: libwasmedgePluginWasiCrypto.so libwasmedgePluginWasmEdgeProcess.so libwasmedgePluginWasmEdgeZlib.so needs: [get_version_v2] container: image: wasmedge/wasmedge:${{ matrix.docker_tag }} @@ -370,95 +332,137 @@ jobs: - uses: actions/checkout@v3 with: fetch-depth: 0 - - name: Build ${{ matrix.name }} dependency - if: matrix.deps_path - env: - PYTORCH_VERSION: "1.8.2" + - name: Build and install dependencies run: | - bash ${{ matrix.deps_path }} - - name: Build ${{ matrix.name }} plugin + mkdir -p build + bash ./utils/wasi-crypto/build-openssl.sh + - name: Build and test plugins using g++ with ${{ matrix.build_type }} mode shell: bash run: | - if [[ "${{ matrix.name }}" == *"PyTorch"* ]]; then - export Torch_DIR=$(pwd)/libtorch - fi - if ${{ matrix.test }}; then - bash utils/docker/build-manylinux.sh --${{ matrix.build_type }} --not-build --not-ninja ${{ matrix.cmake_plugin_option }} -DWASMEDGE_BUILD_TESTS=ON - cd build/${{ matrix.test_path }} - make -j - else - bash utils/docker/build-manylinux.sh --${{ matrix.build_type }} --not-build --not-ninja ${{ matrix.cmake_plugin_option }} - cd build/${{ matrix.output_path }} + plugin_array=(${tar_names}) + cd build + cmake -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DWASMEDGE_BUILD_TESTS=ON ${build_options} -DOPENSSL_ROOT_DIR=$(pwd)/../openssl-1.1.1n/openssl .. + cd .. + for (( i=0; i<${#plugin_array[@]}; i++ )); + do + echo "Building ${plugin_array[$i]} :" + cd ${test_prefix}/${plugin_array[$i]} make -j - fi - - name: Test WasmEdge ${{ matrix.name }} plugin using ${{ matrix.compiler }} with ${{ matrix.build_type }} mode - if: matrix.test + cd - + done + - name: Test plugins + shell: bash run: | - cd build/${{ matrix.test_path }} - ./${{ matrix.test_bin }} - - name: Prepare the WasmEdge ${{ matrix.name }} plugin tar.gz package + plugin_array=(${tar_names}) + testbin_array=(${test_bins}) + for (( i=0; i<${#plugin_array[@]}; i++ )); + do + echo "Testing ${plugin_array[$i]} :" + cd ${test_prefix}/${plugin_array[$i]} + ./${testbin_array[$i]} + cd - + done + - name: Prepare the WasmEdge plugins tar.gz package + shell: bash run: | - cp build/${{ matrix.output_path }}/${{ matrix.output_bin }} ${{ matrix.output_bin }} - tar -zcvf plugin.tar.gz ${{ matrix.output_bin }} - - name: Upload artifact + plugin_array=(${tar_names}) + outbin_array=(${output_bins}) + for (( i=0; i<${#plugin_array[@]}; i++ )); + do + echo "Copying ${plugin_array[$i]} :" + cp ${output_prefix}/${plugin_array[$i]}/${outbin_array[$i]} ${outbin_array[$i]} + tar -zcvf plugin_${plugin_array[$i]}.tar.gz ${outbin_array[$i]} + done + - name: Upload artifact - wasi_crypto + uses: actions/upload-artifact@v3 + with: + name: WasmEdge-plugin-wasi_crypto-${{ needs.get_version_v2.outputs.version }}-${{ matrix.docker_tag }}.tar.gz + path: plugin_wasi_crypto.tar.gz + - name: Upload artifact - wasmedge_process uses: actions/upload-artifact@v3 with: - name: WasmEdge-plugin-${{ matrix.tar_name }}-${{ needs.get_version_v2.outputs.version }}-${{ matrix.docker_tag }}.tar.gz - path: plugin.tar.gz + name: WasmEdge-plugin-wasmedge_process-${{ needs.get_version_v2.outputs.version }}-${{ matrix.docker_tag }}.tar.gz + path: plugin_wasmedge_process.tar.gz + - name: Upload artifact - wasmedge_zlib + uses: actions/upload-artifact@v3 + with: + name: WasmEdge-plugin-wasmedge_zlib-${{ needs.get_version_v2.outputs.version }}-${{ matrix.docker_tag }}.tar.gz + path: plugin_wasmedge_zlib.tar.gz build_macos: strategy: matrix: include: - - name: WASI-Crypto - tar_name: wasi_crypto + - name: Plugins_MacOS_11 system: MacOS 11 host_runner: macos-11 darwin_version: darwin_20 - output_path: plugins/wasi_crypto - output_bin: libwasmedgePluginWasiCrypto.dylib - test_path: test/plugins/wasi_crypto - test_bin: wasiCryptoTests build_type: Release - - name: WASI-Crypto - tar_name: wasi_crypto + - name: Plugins_MacOS_12 system: MacOS 12 host_runner: macos-12 darwin_version: darwin_21 - output_path: plugins/wasi_crypto - output_bin: libwasmedgePluginWasiCrypto.dylib - test_path: test/plugins/wasi_crypto - test_bin: wasiCryptoTests build_type: Release - name: ${{ matrix.system }} WasmEdge ${{ matrix.name }} plugin with clang++ ${{ matrix.build_type }} + name: ${{ matrix.system }} plugin with clang++ ${{ matrix.build_type }} runs-on: ${{ matrix.host_runner }} + env: + output_prefix: build/plugins + test_prefix: build/test/plugins + build_options: -DWASMEDGE_PLUGIN_WASI_CRYPTO=ON + tar_names: wasi_crypto + test_bins: wasiCryptoTests + output_bins: libwasmedgePluginWasiCrypto.dylib needs: [get_version_v2] steps: - uses: actions/checkout@v3 with: fetch-depth: 0 - - name: Build WasmEdge ${{ matrix.name }} plugin using clang++ with ${{ matrix.build_type }} mode + - name: Build and install dependencies run: | brew install llvm ninja boost cmake openssl + - name: Build WasmEdge plugins using clang++ with ${{ matrix.build_type }} mode + shell: bash + run: | + plugin_array=(${tar_names}) export LLVM_DIR="/usr/local/opt/llvm/lib/cmake" export CC=clang export CXX=clang++ mkdir -p build cd build - cmake -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DOPENSSL_ROOT_DIR=/usr/local/opt/openssl -DWASMEDGE_PLUGIN_WASI_CRYPTO=ON -DWASMEDGE_BUILD_TESTS=ON .. - cd ${{ matrix.test_path }} - make -j - - name: Test WasmEdge ${{ matrix.name }} plugin using clang++ with ${{ matrix.build_type }} mode - continue-on-error: true + cmake -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DOPENSSL_ROOT_DIR=/usr/local/opt/openssl -DWASMEDGE_BUILD_TESTS=ON ${build_options} .. + cd .. + for (( i=0; i<${#plugin_array[@]}; i++ )); + do + echo "Building ${plugin_array[$i]} :" + cd ${test_prefix}/${plugin_array[$i]} + make -j + cd - + done + - name: Test WasmEdge plugins + shell: bash run: | - cd build/${{ matrix.test_path }} - ./${{ matrix.test_bin }} - - name: Prepare the WasmEdge ${{ matrix.name }} plugin tar.gz package + plugin_array=(${tar_names}) + testbin_array=(${test_bins}) + for (( i=0; i<${#plugin_array[@]}; i++ )); + do + echo "Testing ${plugin_array[$i]} :" + cd ${test_prefix}/${plugin_array[$i]} + ./${testbin_array[$i]} + cd - + done + - name: Prepare the WasmEdge plugins tar.gz package + shell: bash run: | - cp build/${{ matrix.output_path }}/${{ matrix.output_bin }} ${{ matrix.output_bin }} - tar -zcvf plugin.tar.gz ${{ matrix.output_bin }} - - name: Upload artifact + plugin_array=(${tar_names}) + outbin_array=(${output_bins}) + for (( i=0; i<${#plugin_array[@]}; i++ )); + do + echo "Copying ${plugin_array[$i]} :" + cp ${output_prefix}/${plugin_array[$i]}/${outbin_array[$i]} ${outbin_array[$i]} + tar -zcvf plugin_${plugin_array[$i]}.tar.gz ${outbin_array[$i]} + done + - name: Upload artifact - wasi_crypto uses: actions/upload-artifact@v3 with: - name: WasmEdge-plugin-${{ matrix.tar_name }}-${{ needs.get_version_v2.outputs.version }}-${{ matrix.darwin_version }}_x86_64.tar.gz - path: plugin.tar.gz + name: WasmEdge-plugin-wasi_crypto-${{ needs.get_version_v2.outputs.version }}-${{ matrix.darwin_version }}_x86_64.tar.gz + path: plugin_wasi_crypto.tar.gz From 0d8c9b1873c1da8f5269f02e8be25cfa69ec1bc8 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Wed, 7 Jun 2023 08:44:37 +0530 Subject: [PATCH 24/98] Fix typo in build-extensions.yml on zlib cmake option Signed-off-by: Saikat Dey --- .github/workflows/build-extensions.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/build-extensions.yml b/.github/workflows/build-extensions.yml index f329ecce7cca..0f1c131045d8 100644 --- a/.github/workflows/build-extensions.yml +++ b/.github/workflows/build-extensions.yml @@ -157,7 +157,7 @@ jobs: env: output_prefix: build/plugins test_prefix: build/test/plugins - build_options: -DWASMEDGE_PLUGIN_PROCESS=ON -DWASMEDGE_PLUGIN_WASI_CRYPTO=ON -DWASMEDGE_PLUGIN_WASI_ZLIB=ON + build_options: -DWASMEDGE_PLUGIN_ZLIB=ON -DWASMEDGE_PLUGIN_PROCESS=ON -DWASMEDGE_PLUGIN_WASI_CRYPTO=ON tar_names: wasi_crypto wasmedge_process wasmedge_zlib test_bins: wasiCryptoTests wasmedgeProcessTests wasmedgeZlibTests output_bins: libwasmedgePluginWasiCrypto.so libwasmedgePluginWasmEdgeProcess.so libwasmedgePluginWasmEdgeZlib.so @@ -321,7 +321,7 @@ jobs: env: output_prefix: build/plugins test_prefix: build/test/plugins - build_options: -DWASMEDGE_PLUGIN_PROCESS=ON -DWASMEDGE_PLUGIN_WASI_CRYPTO=ON -DWASMEDGE_PLUGIN_WASI_ZLIB=ON + build_options: -DWASMEDGE_PLUGIN_ZLIB=ON -DWASMEDGE_PLUGIN_PROCESS=ON -DWASMEDGE_PLUGIN_WASI_CRYPTO=ON tar_names: wasi_crypto wasmedge_process wasmedge_zlib test_bins: wasiCryptoTests wasmedgeProcessTests wasmedgeZlibTests output_bins: libwasmedgePluginWasiCrypto.so libwasmedgePluginWasmEdgeProcess.so libwasmedgePluginWasmEdgeZlib.so From d5d4f36480e2f3f65f0fc3115eca91cb4066f677 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Sat, 24 Jun 2023 17:23:18 +0530 Subject: [PATCH 25/98] Minor type changes to better reflect the Zlib API. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 5 +++-- plugins/wasmedge_zlib/zlibfunc.h | 4 ++-- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 508c8b816264..604361e54b02 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -12,7 +12,7 @@ namespace Host { Expect WasmEdgeZlibDeflateInit_::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t Level, - uint32_t VersionPtr, uint32_t StreamSize) { + uint32_t VersionPtr, int32_t StreamSize) { auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { @@ -54,7 +54,7 @@ WasmEdgeZlibDeflateInit_::body(const Runtime::CallingFrame &Frame, Expect WasmEdgeZlibInflateInit_::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, uint32_t VersionPtr, - uint32_t StreamSize) { + int32_t StreamSize) { auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { @@ -123,6 +123,7 @@ Expect WasmEdgeZlibDeflate::WasmEdgeZlibDeflate::body( Expect WasmEdgeZlibInflate::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t Flush) { + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); if (HostZStreamIt == Env.ZStreamMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); diff --git a/plugins/wasmedge_zlib/zlibfunc.h b/plugins/wasmedge_zlib/zlibfunc.h index 513c10ce2117..735d7b1486b8 100644 --- a/plugins/wasmedge_zlib/zlibfunc.h +++ b/plugins/wasmedge_zlib/zlibfunc.h @@ -13,7 +13,7 @@ class WasmEdgeZlibDeflateInit_ : public WasmEdgeZlib { WasmEdgeZlibDeflateInit_(WasmEdgeZlibEnvironment &HostEnv) : WasmEdgeZlib(HostEnv) {} Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, - int32_t Level, uint32_t VersionPtr, uint32_t StreamSize); + int32_t Level, uint32_t VersionPtr, int32_t StreamSize); }; class WasmEdgeZlibInflateInit_ : public WasmEdgeZlib { @@ -21,7 +21,7 @@ class WasmEdgeZlibInflateInit_ : public WasmEdgeZlib { WasmEdgeZlibInflateInit_(WasmEdgeZlibEnvironment &HostEnv) : WasmEdgeZlib(HostEnv) {} Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, - uint32_t VersionPtr, uint32_t StreamSize); + uint32_t VersionPtr, int32_t StreamSize); }; class WasmEdgeZlibDeflate : public WasmEdgeZlib { From a9e1bc206b6aa6f8ae23cb5e6d0136402f8f1e33 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Sat, 24 Jun 2023 17:27:30 +0530 Subject: [PATCH 26/98] Added Deflate Inflate Integration Test Signed-off-by: Saikat Dey --- test/plugins/wasmedge_zlib/wasmedge_zlib.cpp | 223 ++++++++++++++++++- 1 file changed, 222 insertions(+), 1 deletion(-) diff --git a/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp b/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp index 46b5edfa0496..39405016f6f7 100644 --- a/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp +++ b/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp @@ -2,13 +2,14 @@ // SPDX-FileCopyrightText: 2019-2022 Second State INC #include "common/defines.h" +#include "runtime/instance/module.h" #include "zlibfunc.h" #include "zlibmodule.h" -#include "runtime/instance/module.h" #include #include #include +#include #include #include #include @@ -31,6 +32,226 @@ WasmEdge::Runtime::Instance::ModuleInstance *createModule() { } // namespace +void fillMemContent(WasmEdge::Runtime::Instance::MemoryInstance &MemInst, + uint32_t Offset, uint32_t Cnt, uint8_t C = 0) noexcept { + std::fill_n(MemInst.getPointer(Offset), Cnt, C); +} + +static constexpr size_t DATA_SIZE = 1 * 1024 * 1024ULL; +// static constexpr size_t INPUT_BUFFER_SIZE = 32 * 1024llu; +static constexpr size_t OUTPUT_BUFFER_SIZE = 64 * 1024ULL; + +constexpr auto randChar = []() -> char { + constexpr char charset[] = "0123456789" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "abcdefghijklmnopqrstuvwxyz"; + constexpr size_t max_index = (sizeof(charset) - 1); + return charset[std::rand() % max_index]; +}; + +TEST(WasmEdgeZlibTest, DeflateInflateCycle) { + auto *ZlibMod = + dynamic_cast(createModule()); + ASSERT_TRUE(ZlibMod != nullptr); + + // Create the calling frame with memory instance. + WasmEdge::Runtime::Instance::ModuleInstance Mod(""); + Mod.addHostMemory( + "memory", std::make_unique( + WasmEdge::AST::MemoryType(16 * 64, 16 * 64))); + auto *MemInstPtr = Mod.findMemoryExports("memory"); + ASSERT_TRUE(MemInstPtr != nullptr); + auto &MemInst = *MemInstPtr; + uint32_t + // WASM Memory Heap Pointer + wasm_hp = 0, + wasm_data, wasm_zlib_version, wasm_z_stream, wasm_compressed_data, + wasm_decompressed_data; + uint32_t wasm_compressed_data_size = 0, wasm_decompressed_data_size = 0; + WasmEdge::Runtime::CallingFrame CallFrame(nullptr, &Mod); + + auto *FuncInst = ZlibMod->findFuncExports("deflateInit_"); + EXPECT_NE(FuncInst, nullptr); + EXPECT_TRUE(FuncInst->isHostFunction()); + auto &__deflateInit_ = + dynamic_cast( + FuncInst->getHostFunc()); + + FuncInst = ZlibMod->findFuncExports("deflate"); + EXPECT_NE(FuncInst, nullptr); + EXPECT_TRUE(FuncInst->isHostFunction()); + auto &__deflate = dynamic_cast( + FuncInst->getHostFunc()); + + FuncInst = ZlibMod->findFuncExports("deflateEnd"); + EXPECT_NE(FuncInst, nullptr); + EXPECT_TRUE(FuncInst->isHostFunction()); + auto &__deflateEnd = dynamic_cast( + FuncInst->getHostFunc()); + + FuncInst = ZlibMod->findFuncExports("inflateInit_"); + EXPECT_NE(FuncInst, nullptr); + EXPECT_TRUE(FuncInst->isHostFunction()); + auto &__inflateInit_ = + dynamic_cast( + FuncInst->getHostFunc()); + + FuncInst = ZlibMod->findFuncExports("inflate"); + EXPECT_NE(FuncInst, nullptr); + EXPECT_TRUE(FuncInst->isHostFunction()); + auto &__inflate = dynamic_cast( + FuncInst->getHostFunc()); + + FuncInst = ZlibMod->findFuncExports("inflateEnd"); + EXPECT_NE(FuncInst, nullptr); + EXPECT_TRUE(FuncInst->isHostFunction()); + auto &__inflateEnd = dynamic_cast( + FuncInst->getHostFunc()); + + std::array RetVal; + + wasm_zlib_version = wasm_hp; + std::snprintf(MemInst.getPointer(wasm_hp), std::strlen(ZLIB_VERSION), + ZLIB_VERSION); + wasm_hp += std::strlen(ZLIB_VERSION); + + wasm_data = wasm_hp; + std::generate_n(MemInst.getPointer(wasm_hp), DATA_SIZE, randChar); + wasm_hp += DATA_SIZE; + + wasm_z_stream = wasm_hp; + Wasm_z_stream *strm = MemInst.getPointer(wasm_z_stream); + wasm_hp += sizeof(Wasm_z_stream); + + // ----- Deflate Routine START------ + fillMemContent(MemInst, wasm_z_stream, sizeof(Wasm_z_stream), 0U); + strm->zalloc = Z_NULL, strm->zfree = Z_NULL, strm->opaque = Z_NULL; + + // deflateInit_ Test + // WASM z_stream size Mismatch + EXPECT_FALSE(__deflateInit_.run( + CallFrame, + std::initializer_list{wasm_z_stream, INT32_C(-1), + wasm_zlib_version, + sizeof(Wasm_z_stream) + 16}, + RetVal)); + + // Version Mismatch + EXPECT_FALSE(__deflateInit_.run( + CallFrame, + std::initializer_list{wasm_z_stream, INT32_C(-1), + wasm_zlib_version + 2, + sizeof(Wasm_z_stream)}, + RetVal)); + + EXPECT_TRUE(__deflateInit_.run( + CallFrame, + std::initializer_list{ + wasm_z_stream, INT32_C(-1), wasm_zlib_version, sizeof(Wasm_z_stream)}, + RetVal)); + EXPECT_EQ(RetVal[0].get(), Z_OK); + + wasm_compressed_data = wasm_hp; + + strm->avail_in = DATA_SIZE; + strm->next_in = wasm_data; + strm->avail_out = OUTPUT_BUFFER_SIZE; + strm->next_out = wasm_compressed_data; + + // deflate Test + do { + if (strm->avail_out == 0) { + wasm_hp += OUTPUT_BUFFER_SIZE; + strm->avail_out = OUTPUT_BUFFER_SIZE; + strm->next_out = wasm_hp; + } + + EXPECT_TRUE(__deflate.run(CallFrame, + std::initializer_list{ + wasm_z_stream, + INT32_C(Z_FINISH), + }, + RetVal)); + EXPECT_NE(RetVal[0].get(), Z_STREAM_ERROR); + } while (RetVal[0].get() != Z_STREAM_END); + + // deflateEnd Test + EXPECT_TRUE(__deflateEnd.run( + CallFrame, std::initializer_list{wasm_z_stream}, + RetVal)); + EXPECT_EQ(RetVal[0].get(), Z_OK); + wasm_hp += OUTPUT_BUFFER_SIZE - strm->avail_out; + wasm_compressed_data_size = wasm_hp - wasm_compressed_data; + // ----- Deflate Routine END------ + + // ----- Inflate Routine START------ + fillMemContent(MemInst, wasm_z_stream, sizeof(Wasm_z_stream), 0U); + strm->zalloc = Z_NULL, strm->zfree = Z_NULL, strm->opaque = Z_NULL; + + // inflateInit_ Test + // WASM z_stream size Mismatch + EXPECT_FALSE(__inflateInit_.run( + CallFrame, + std::initializer_list{ + wasm_z_stream, wasm_zlib_version, sizeof(Wasm_z_stream) + 16}, + RetVal)); + + // Version Mismatch + EXPECT_FALSE(__inflateInit_.run( + CallFrame, + std::initializer_list{ + wasm_z_stream, wasm_zlib_version + 2, sizeof(Wasm_z_stream)}, + RetVal)); + + EXPECT_TRUE(__inflateInit_.run( + CallFrame, + std::initializer_list{ + wasm_z_stream, wasm_zlib_version, sizeof(Wasm_z_stream)}, + RetVal)); + EXPECT_EQ(RetVal[0].get(), Z_OK); + + wasm_decompressed_data = wasm_hp; + + strm->avail_in = wasm_compressed_data_size; + strm->next_in = wasm_compressed_data; + strm->avail_out = OUTPUT_BUFFER_SIZE; + strm->next_out = wasm_decompressed_data; + + // inflate test + do { + if (strm->avail_out == 0) { + wasm_hp += OUTPUT_BUFFER_SIZE; + strm->avail_out = OUTPUT_BUFFER_SIZE; + strm->next_out = wasm_hp; + } + + EXPECT_TRUE(__inflate.run(CallFrame, + std::initializer_list{ + wasm_z_stream, + INT32_C(Z_FINISH), + }, + RetVal)); + EXPECT_NE(RetVal[0].get(), Z_STREAM_ERROR); + } while (RetVal[0].get() != Z_STREAM_END); + + EXPECT_TRUE(__inflateEnd.run( + CallFrame, std::initializer_list{wasm_z_stream}, + RetVal)); + EXPECT_EQ(RetVal[0].get(), Z_OK); + wasm_hp += OUTPUT_BUFFER_SIZE - strm->avail_out; + wasm_decompressed_data_size = wasm_hp - wasm_decompressed_data; + // ----- Inflate Routine END------ + + // Test Decompressed Buffer size against source Data size. + EXPECT_EQ(wasm_decompressed_data_size, DATA_SIZE); + // Test Decompressed Buffer content against source Data. + EXPECT_TRUE( + std::equal(MemInst.getPointer(wasm_decompressed_data), + MemInst.getPointer(wasm_decompressed_data + + wasm_decompressed_data_size), + MemInst.getPointer(wasm_data))); +} + TEST(WasmEdgeZlibTest, Module) { // Create the wasmedge_process module instance. auto *ZlibMod = From ba8bff1813d9d9d8aab23ddb1f34627a2bcfd94a Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Mon, 26 Jun 2023 13:13:49 +0530 Subject: [PATCH 27/98] Removed unnecessary nulling of wasm module's z_stream allocators | The host ignores them. Signed-off-by: Saikat Dey --- test/plugins/wasmedge_zlib/wasmedge_zlib.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp b/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp index 39405016f6f7..24ae5dc1d5d5 100644 --- a/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp +++ b/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp @@ -125,7 +125,6 @@ TEST(WasmEdgeZlibTest, DeflateInflateCycle) { // ----- Deflate Routine START------ fillMemContent(MemInst, wasm_z_stream, sizeof(Wasm_z_stream), 0U); - strm->zalloc = Z_NULL, strm->zfree = Z_NULL, strm->opaque = Z_NULL; // deflateInit_ Test // WASM z_stream size Mismatch @@ -186,7 +185,6 @@ TEST(WasmEdgeZlibTest, DeflateInflateCycle) { // ----- Inflate Routine START------ fillMemContent(MemInst, wasm_z_stream, sizeof(Wasm_z_stream), 0U); - strm->zalloc = Z_NULL, strm->zfree = Z_NULL, strm->opaque = Z_NULL; // inflateInit_ Test // WASM z_stream size Mismatch From c081bf7acba97f54db57e1471dd13e6a39a8a9f8 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Wed, 28 Jun 2023 05:23:16 +0530 Subject: [PATCH 28/98] Added static_assert on Wasm_z_stream struct size. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibenv.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/plugins/wasmedge_zlib/zlibenv.h b/plugins/wasmedge_zlib/zlibenv.h index 8851833ddce0..c2fea31646a5 100644 --- a/plugins/wasmedge_zlib/zlibenv.h +++ b/plugins/wasmedge_zlib/zlibenv.h @@ -37,6 +37,8 @@ struct Wasm_z_stream { uint32_t reserved; }; // 56 bytes +static_assert(sizeof(Wasm_z_stream) == 56, "Wasm_z_stream should be 56 bytes"); + namespace WasmEdge { namespace Host { From 8a0ab936de0d08ff13a27329ff220de9a04763fd Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Wed, 28 Jun 2023 05:27:11 +0530 Subject: [PATCH 29/98] Start writing to the wasm heap from address 1 onwards, to nto collide with the semantic meaning of address/offset 0 as nullptr. Signed-off-by: Saikat Dey --- test/plugins/wasmedge_zlib/wasmedge_zlib.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp b/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp index 24ae5dc1d5d5..5a59911f623b 100644 --- a/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp +++ b/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp @@ -64,7 +64,7 @@ TEST(WasmEdgeZlibTest, DeflateInflateCycle) { auto &MemInst = *MemInstPtr; uint32_t // WASM Memory Heap Pointer - wasm_hp = 0, + wasm_hp = 1, wasm_data, wasm_zlib_version, wasm_z_stream, wasm_compressed_data, wasm_decompressed_data; uint32_t wasm_compressed_data_size = 0, wasm_decompressed_data_size = 0; From 20cf963e9d9ed67cfff06e180f920bb0f38e39e1 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Wed, 28 Jun 2023 05:55:49 +0530 Subject: [PATCH 30/98] Fix: Correct Version Check and Stream Size Check Error code, and API behaviour, along with relevant test case changes. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 41 ++++++-------------- test/plugins/wasmedge_zlib/wasmedge_zlib.cpp | 12 ++++-- 2 files changed, 19 insertions(+), 34 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 604361e54b02..163c3d2a0832 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -6,6 +6,13 @@ #include #include +constexpr bool CheckVersionSize(const char *WasmZlibVersion, + int32_t StreamSize) { + + return (WasmZlibVersion != 0 && WasmZlibVersion[0] == ZLIB_VERSION[0] && + StreamSize == (int32_t)sizeof(Wasm_z_stream)); +} + namespace WasmEdge { namespace Host { @@ -18,23 +25,10 @@ WasmEdgeZlibDeflateInit_::body(const Runtime::CallingFrame &Frame, if (MemInst == nullptr) { return Unexpect(ErrCode::Value::HostFuncError); } - // Wasm_z_stream *WasmZStream = MemInst->getPointer(ZStreamPtr); - if (StreamSize != 56) { - spdlog::error("[WasmEdge Zlib] [WasmEdgeZlibDeflateInit_] WASM " - "sizeof(z_stream) != 56 but {}", - StreamSize); - return Unexpect(ErrCode::Value::HostFuncError); - } const char *WasmZlibVersion = MemInst->getPointer(VersionPtr); - if (WasmZlibVersion[0] != ZLIB_VERSION[0]) { - spdlog::error("[WasmEdge Zlib] [WasmEdgeZlibDeflateInit_] Major Zlib " - "version of Host ({}) & Wasm ({}) " - "does not match", - ZLIB_VERSION[0], WasmZlibVersion[0]); - return Unexpect(ErrCode::Value::HostFuncError); - } + if (!CheckVersionSize(WasmZlibVersion, StreamSize)) + return static_cast(Z_VERSION_ERROR); auto HostZStream = std::make_unique(); @@ -60,23 +54,10 @@ WasmEdgeZlibInflateInit_::body(const Runtime::CallingFrame &Frame, if (MemInst == nullptr) { return Unexpect(ErrCode::Value::HostFuncError); } - // Wasm_z_stream *WasmZStream = MemInst->getPointer(ZStreamPtr); - if (StreamSize != 56) { - spdlog::error("[WasmEdge Zlib] [WasmEdgeZlibInflateInit_] WASM " - "sizeof(z_stream) != 56 but {}", - StreamSize); - return Unexpect(ErrCode::Value::HostFuncError); - } const char *WasmZlibVersion = MemInst->getPointer(VersionPtr); - if (WasmZlibVersion[0] != ZLIB_VERSION[0]) { - spdlog::error("[WasmEdge Zlib] [WasmEdgeZlibInflateInit_] Major Zlib " - "version of Host ({}) & Wasm ({}) " - "does not match", - ZLIB_VERSION[0], WasmZlibVersion[0]); - return Unexpect(ErrCode::Value::HostFuncError); - } + if (!CheckVersionSize(WasmZlibVersion, StreamSize)) + return static_cast(Z_VERSION_ERROR); auto HostZStream = std::make_unique(); diff --git a/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp b/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp index 5a59911f623b..833ce63bbd59 100644 --- a/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp +++ b/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp @@ -128,20 +128,22 @@ TEST(WasmEdgeZlibTest, DeflateInflateCycle) { // deflateInit_ Test // WASM z_stream size Mismatch - EXPECT_FALSE(__deflateInit_.run( + EXPECT_TRUE(__deflateInit_.run( CallFrame, std::initializer_list{wasm_z_stream, INT32_C(-1), wasm_zlib_version, sizeof(Wasm_z_stream) + 16}, RetVal)); + EXPECT_EQ(RetVal[0].get(), Z_VERSION_ERROR); // Version Mismatch - EXPECT_FALSE(__deflateInit_.run( + EXPECT_TRUE(__deflateInit_.run( CallFrame, std::initializer_list{wasm_z_stream, INT32_C(-1), wasm_zlib_version + 2, sizeof(Wasm_z_stream)}, RetVal)); + EXPECT_EQ(RetVal[0].get(), Z_VERSION_ERROR); EXPECT_TRUE(__deflateInit_.run( CallFrame, @@ -188,18 +190,20 @@ TEST(WasmEdgeZlibTest, DeflateInflateCycle) { // inflateInit_ Test // WASM z_stream size Mismatch - EXPECT_FALSE(__inflateInit_.run( + EXPECT_TRUE(__inflateInit_.run( CallFrame, std::initializer_list{ wasm_z_stream, wasm_zlib_version, sizeof(Wasm_z_stream) + 16}, RetVal)); + EXPECT_EQ(RetVal[0].get(), Z_VERSION_ERROR); // Version Mismatch - EXPECT_FALSE(__inflateInit_.run( + EXPECT_TRUE(__inflateInit_.run( CallFrame, std::initializer_list{ wasm_z_stream, wasm_zlib_version + 2, sizeof(Wasm_z_stream)}, RetVal)); + EXPECT_EQ(RetVal[0].get(), Z_VERSION_ERROR); EXPECT_TRUE(__inflateInit_.run( CallFrame, From 43def5948309900e09cc219df1bb0091b000d35d Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Wed, 28 Jun 2023 06:01:06 +0530 Subject: [PATCH 31/98] Added in-code documentation/pointer/reason on why we just compare only the first character of zlib version strings. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 163c3d2a0832..54757acca48a 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -8,6 +8,11 @@ constexpr bool CheckVersionSize(const char *WasmZlibVersion, int32_t StreamSize) { + /* + Reason behind just comparing the first character of zlib version strings. + https://github.com/zlib-ng/zlib-ng/blob/2f4ebe2bb68380366b90f1db1f3c5b32601130a0/zutil.h#L130 + https://github.com/madler/zlib/blob/04f42ceca40f73e2978b50e93806c2a18c1281fc/inflate.c#L207 + */ return (WasmZlibVersion != 0 && WasmZlibVersion[0] == ZLIB_VERSION[0] && StreamSize == (int32_t)sizeof(Wasm_z_stream)); From cce004ac0a792a9ead6dfc4708885912dc6adb5f Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Thu, 29 Jun 2023 23:16:01 +0530 Subject: [PATCH 32/98] Remove unsafe usage of wasm MemStart(pointer from base{0}). Converted to offset based pointer calculation, based on pointer increment after zlib operation.. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 37 ++++++++++++++++++------------ 1 file changed, 22 insertions(+), 15 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 54757acca48a..56234ecd035c 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -89,20 +89,23 @@ Expect WasmEdgeZlibDeflate::WasmEdgeZlibDeflate::body( auto HostZStream = HostZStreamIt->second.get(); auto *MemInst = Frame.getMemoryByIndex(0); Wasm_z_stream *WasmZStream = MemInst->getPointer(ZStreamPtr); - // get the whole memory from start - unsigned char *WasmMemStart = MemInst->getPointer(0); - HostZStream->avail_in = WasmZStream->avail_in; // value - HostZStream->avail_out = WasmZStream->avail_out; // value - HostZStream->next_in = WasmMemStart + WasmZStream->next_in; // ptr - HostZStream->next_out = WasmMemStart + WasmZStream->next_out; // ptr + HostZStream->avail_in = WasmZStream->avail_in; // value + HostZStream->avail_out = WasmZStream->avail_out; // value + HostZStream->next_in = + MemInst->getPointer(WasmZStream->next_in); // ptr + HostZStream->next_out = + MemInst->getPointer(WasmZStream->next_out); // ptr + + const auto PreComputeNextIn = HostZStream->next_in; + const auto PreComputeNextOut = HostZStream->next_out; const auto z_res = deflate(HostZStream, Flush); WasmZStream->avail_in = HostZStream->avail_in; WasmZStream->avail_out = HostZStream->avail_out; - WasmZStream->next_in = HostZStream->next_in - WasmMemStart; - WasmZStream->next_out = HostZStream->next_out - WasmMemStart; + WasmZStream->next_in += HostZStream->next_in - PreComputeNextIn; + WasmZStream->next_out += HostZStream->next_out - PreComputeNextOut; return static_cast(z_res); } @@ -117,19 +120,23 @@ Expect WasmEdgeZlibInflate::body(const Runtime::CallingFrame &Frame, auto HostZStream = HostZStreamIt->second.get(); auto *MemInst = Frame.getMemoryByIndex(0); Wasm_z_stream *WasmZStream = MemInst->getPointer(ZStreamPtr); - unsigned char *WasmMemStart = MemInst->getPointer(0); - HostZStream->avail_in = WasmZStream->avail_in; // value - HostZStream->avail_out = WasmZStream->avail_out; // value - HostZStream->next_in = WasmMemStart + WasmZStream->next_in; // ptr - HostZStream->next_out = WasmMemStart + WasmZStream->next_out; // ptr + HostZStream->avail_in = WasmZStream->avail_in; // value + HostZStream->avail_out = WasmZStream->avail_out; // value + HostZStream->next_in = + MemInst->getPointer(WasmZStream->next_in); // ptr + HostZStream->next_out = + MemInst->getPointer(WasmZStream->next_out); // ptr + + const auto PreComputeNextIn = HostZStream->next_in; + const auto PreComputeNextOut = HostZStream->next_out; const auto z_res = inflate(HostZStream, Flush); WasmZStream->avail_in = HostZStream->avail_in; WasmZStream->avail_out = HostZStream->avail_out; - WasmZStream->next_in = HostZStream->next_in - WasmMemStart; - WasmZStream->next_out = HostZStream->next_out - WasmMemStart; + WasmZStream->next_in += HostZStream->next_in - PreComputeNextIn; + WasmZStream->next_out += HostZStream->next_out - PreComputeNextOut; return static_cast(z_res); } From c74505d1cc0785cb78c6eba3afc346c05be913d3 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Thu, 29 Jun 2023 23:32:58 +0530 Subject: [PATCH 33/98] Added in-code documentation to every field in Wasm_z_stream. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibenv.h | 20 ++++++++++++++++++-- 1 file changed, 18 insertions(+), 2 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibenv.h b/plugins/wasmedge_zlib/zlibenv.h index c2fea31646a5..7bb3d4df12e6 100644 --- a/plugins/wasmedge_zlib/zlibenv.h +++ b/plugins/wasmedge_zlib/zlibenv.h @@ -16,26 +16,42 @@ * */ struct Wasm_z_stream { + /* [Wasm Offset] next input byte */ uint32_t next_in; + /* number of bytes available at next_in */ uint32_t avail_in; + /* total number of input bytes read so far */ uint32_t total_in; + /* [Wasm Offset] next output byte will go here */ uint32_t next_out; + /* remaining free space at next_out */ uint32_t avail_out; + /* total number of bytes output so far */ uint32_t total_out; + /* [Wasm Offset] last error message, NULL if no error */ uint32_t msg; + /* [Wasm Offset] not visible by applications */ uint32_t state; + /* used to allocate the internal state */ uint32_t zalloc; + /* used to free the internal state */ uint32_t zfree; + /* [Wasm Offset] private data object passed to zalloc and zfree */ uint32_t opaque; - int32_t data_type; // +ve & 2's complement in memory so int ~ uint + /* best guess about the data type: binary or text + for deflate, or the decoding state + for inflate */ + int32_t data_type; + /* Adler-32 or CRC-32 value of the uncompressed data */ uint32_t adler; + /* reserved for future use */ uint32_t reserved; -}; // 56 bytes +}; static_assert(sizeof(Wasm_z_stream) == 56, "Wasm_z_stream should be 56 bytes"); From 89004feaa93b434d164561a5dc6c563f78162833 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Fri, 30 Jun 2023 02:28:29 +0530 Subject: [PATCH 34/98] Honor LLVM Naming Convention: Change 'Wasm_z_stream' struct name to 'WasmZStream'. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibenv.h | 4 +- plugins/wasmedge_zlib/zlibfunc.cpp | 40 ++++++++++---------- test/plugins/wasmedge_zlib/wasmedge_zlib.cpp | 20 +++++----- 3 files changed, 33 insertions(+), 31 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibenv.h b/plugins/wasmedge_zlib/zlibenv.h index 7bb3d4df12e6..03b59002da48 100644 --- a/plugins/wasmedge_zlib/zlibenv.h +++ b/plugins/wasmedge_zlib/zlibenv.h @@ -15,7 +15,7 @@ * @brief A struct which maps perfectly to a wasm 32bit z_stream object * */ -struct Wasm_z_stream { +struct WasmZStream { /* [Wasm Offset] next input byte */ uint32_t next_in; /* number of bytes available at next_in */ @@ -53,7 +53,7 @@ struct Wasm_z_stream { uint32_t reserved; }; -static_assert(sizeof(Wasm_z_stream) == 56, "Wasm_z_stream should be 56 bytes"); +static_assert(sizeof(WasmZStream) == 56, "WasmZStream should be 56 bytes"); namespace WasmEdge { namespace Host { diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 56234ecd035c..bac4929713b7 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -15,7 +15,7 @@ constexpr bool CheckVersionSize(const char *WasmZlibVersion, */ return (WasmZlibVersion != 0 && WasmZlibVersion[0] == ZLIB_VERSION[0] && - StreamSize == (int32_t)sizeof(Wasm_z_stream)); + StreamSize == (int32_t)sizeof(WasmZStream)); } namespace WasmEdge { @@ -88,24 +88,25 @@ Expect WasmEdgeZlibDeflate::WasmEdgeZlibDeflate::body( } auto HostZStream = HostZStreamIt->second.get(); auto *MemInst = Frame.getMemoryByIndex(0); - Wasm_z_stream *WasmZStream = MemInst->getPointer(ZStreamPtr); + WasmZStream *ModuleZStream = + MemInst->getPointer(ZStreamPtr); - HostZStream->avail_in = WasmZStream->avail_in; // value - HostZStream->avail_out = WasmZStream->avail_out; // value + HostZStream->avail_in = ModuleZStream->avail_in; // value + HostZStream->avail_out = ModuleZStream->avail_out; // value HostZStream->next_in = - MemInst->getPointer(WasmZStream->next_in); // ptr + MemInst->getPointer(ModuleZStream->next_in); // ptr HostZStream->next_out = - MemInst->getPointer(WasmZStream->next_out); // ptr + MemInst->getPointer(ModuleZStream->next_out); // ptr const auto PreComputeNextIn = HostZStream->next_in; const auto PreComputeNextOut = HostZStream->next_out; const auto z_res = deflate(HostZStream, Flush); - WasmZStream->avail_in = HostZStream->avail_in; - WasmZStream->avail_out = HostZStream->avail_out; - WasmZStream->next_in += HostZStream->next_in - PreComputeNextIn; - WasmZStream->next_out += HostZStream->next_out - PreComputeNextOut; + ModuleZStream->avail_in = HostZStream->avail_in; + ModuleZStream->avail_out = HostZStream->avail_out; + ModuleZStream->next_in += HostZStream->next_in - PreComputeNextIn; + ModuleZStream->next_out += HostZStream->next_out - PreComputeNextOut; return static_cast(z_res); } @@ -119,24 +120,25 @@ Expect WasmEdgeZlibInflate::body(const Runtime::CallingFrame &Frame, } auto HostZStream = HostZStreamIt->second.get(); auto *MemInst = Frame.getMemoryByIndex(0); - Wasm_z_stream *WasmZStream = MemInst->getPointer(ZStreamPtr); + WasmZStream *ModuleZStream = + MemInst->getPointer(ZStreamPtr); - HostZStream->avail_in = WasmZStream->avail_in; // value - HostZStream->avail_out = WasmZStream->avail_out; // value + HostZStream->avail_in = ModuleZStream->avail_in; // value + HostZStream->avail_out = ModuleZStream->avail_out; // value HostZStream->next_in = - MemInst->getPointer(WasmZStream->next_in); // ptr + MemInst->getPointer(ModuleZStream->next_in); // ptr HostZStream->next_out = - MemInst->getPointer(WasmZStream->next_out); // ptr + MemInst->getPointer(ModuleZStream->next_out); // ptr const auto PreComputeNextIn = HostZStream->next_in; const auto PreComputeNextOut = HostZStream->next_out; const auto z_res = inflate(HostZStream, Flush); - WasmZStream->avail_in = HostZStream->avail_in; - WasmZStream->avail_out = HostZStream->avail_out; - WasmZStream->next_in += HostZStream->next_in - PreComputeNextIn; - WasmZStream->next_out += HostZStream->next_out - PreComputeNextOut; + ModuleZStream->avail_in = HostZStream->avail_in; + ModuleZStream->avail_out = HostZStream->avail_out; + ModuleZStream->next_in += HostZStream->next_in - PreComputeNextIn; + ModuleZStream->next_out += HostZStream->next_out - PreComputeNextOut; return static_cast(z_res); } diff --git a/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp b/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp index 833ce63bbd59..1ba17655a16e 100644 --- a/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp +++ b/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp @@ -120,11 +120,11 @@ TEST(WasmEdgeZlibTest, DeflateInflateCycle) { wasm_hp += DATA_SIZE; wasm_z_stream = wasm_hp; - Wasm_z_stream *strm = MemInst.getPointer(wasm_z_stream); - wasm_hp += sizeof(Wasm_z_stream); + WasmZStream *strm = MemInst.getPointer(wasm_z_stream); + wasm_hp += sizeof(WasmZStream); // ----- Deflate Routine START------ - fillMemContent(MemInst, wasm_z_stream, sizeof(Wasm_z_stream), 0U); + fillMemContent(MemInst, wasm_z_stream, sizeof(WasmZStream), 0U); // deflateInit_ Test // WASM z_stream size Mismatch @@ -132,7 +132,7 @@ TEST(WasmEdgeZlibTest, DeflateInflateCycle) { CallFrame, std::initializer_list{wasm_z_stream, INT32_C(-1), wasm_zlib_version, - sizeof(Wasm_z_stream) + 16}, + sizeof(WasmZStream) + 16}, RetVal)); EXPECT_EQ(RetVal[0].get(), Z_VERSION_ERROR); @@ -141,14 +141,14 @@ TEST(WasmEdgeZlibTest, DeflateInflateCycle) { CallFrame, std::initializer_list{wasm_z_stream, INT32_C(-1), wasm_zlib_version + 2, - sizeof(Wasm_z_stream)}, + sizeof(WasmZStream)}, RetVal)); EXPECT_EQ(RetVal[0].get(), Z_VERSION_ERROR); EXPECT_TRUE(__deflateInit_.run( CallFrame, std::initializer_list{ - wasm_z_stream, INT32_C(-1), wasm_zlib_version, sizeof(Wasm_z_stream)}, + wasm_z_stream, INT32_C(-1), wasm_zlib_version, sizeof(WasmZStream)}, RetVal)); EXPECT_EQ(RetVal[0].get(), Z_OK); @@ -186,14 +186,14 @@ TEST(WasmEdgeZlibTest, DeflateInflateCycle) { // ----- Deflate Routine END------ // ----- Inflate Routine START------ - fillMemContent(MemInst, wasm_z_stream, sizeof(Wasm_z_stream), 0U); + fillMemContent(MemInst, wasm_z_stream, sizeof(WasmZStream), 0U); // inflateInit_ Test // WASM z_stream size Mismatch EXPECT_TRUE(__inflateInit_.run( CallFrame, std::initializer_list{ - wasm_z_stream, wasm_zlib_version, sizeof(Wasm_z_stream) + 16}, + wasm_z_stream, wasm_zlib_version, sizeof(WasmZStream) + 16}, RetVal)); EXPECT_EQ(RetVal[0].get(), Z_VERSION_ERROR); @@ -201,14 +201,14 @@ TEST(WasmEdgeZlibTest, DeflateInflateCycle) { EXPECT_TRUE(__inflateInit_.run( CallFrame, std::initializer_list{ - wasm_z_stream, wasm_zlib_version + 2, sizeof(Wasm_z_stream)}, + wasm_z_stream, wasm_zlib_version + 2, sizeof(WasmZStream)}, RetVal)); EXPECT_EQ(RetVal[0].get(), Z_VERSION_ERROR); EXPECT_TRUE(__inflateInit_.run( CallFrame, std::initializer_list{ - wasm_z_stream, wasm_zlib_version, sizeof(Wasm_z_stream)}, + wasm_z_stream, wasm_zlib_version, sizeof(WasmZStream)}, RetVal)); EXPECT_EQ(RetVal[0].get(), Z_OK); From 705dea5cf2787c0eb96753501436a273b425a810 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Fri, 30 Jun 2023 02:47:47 +0530 Subject: [PATCH 35/98] Honor LLVM Naming Convention: Change 'Wasm_z_stream' struct name to 'WasmZStream'. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index bac4929713b7..386a47294fe6 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -88,8 +88,7 @@ Expect WasmEdgeZlibDeflate::WasmEdgeZlibDeflate::body( } auto HostZStream = HostZStreamIt->second.get(); auto *MemInst = Frame.getMemoryByIndex(0); - WasmZStream *ModuleZStream = - MemInst->getPointer(ZStreamPtr); + WasmZStream *ModuleZStream = MemInst->getPointer(ZStreamPtr); HostZStream->avail_in = ModuleZStream->avail_in; // value HostZStream->avail_out = ModuleZStream->avail_out; // value @@ -120,8 +119,7 @@ Expect WasmEdgeZlibInflate::body(const Runtime::CallingFrame &Frame, } auto HostZStream = HostZStreamIt->second.get(); auto *MemInst = Frame.getMemoryByIndex(0); - WasmZStream *ModuleZStream = - MemInst->getPointer(ZStreamPtr); + WasmZStream *ModuleZStream = MemInst->getPointer(ZStreamPtr); HostZStream->avail_in = ModuleZStream->avail_in; // value HostZStream->avail_out = ModuleZStream->avail_out; // value From c7b4de2296111970e0b9a0c08a31f30cdfcf398c Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Tue, 1 Aug 2023 18:44:32 +0530 Subject: [PATCH 36/98] Changed c style cast to static_cast. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 386a47294fe6..bb3cadf7becc 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -15,7 +15,7 @@ constexpr bool CheckVersionSize(const char *WasmZlibVersion, */ return (WasmZlibVersion != 0 && WasmZlibVersion[0] == ZLIB_VERSION[0] && - StreamSize == (int32_t)sizeof(WasmZStream)); + StreamSize == static_cast(sizeof(WasmZStream))); } namespace WasmEdge { From 7465495da118be34e2cc25d5830838ff1a3852c8 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Tue, 1 Aug 2023 18:46:21 +0530 Subject: [PATCH 37/98] Updated a few variable name to reflect LLVM standards. Signed-off-by: Saikat Dey --- test/plugins/wasmedge_zlib/wasmedge_zlib.cpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp b/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp index 1ba17655a16e..d9e86e382b85 100644 --- a/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp +++ b/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp @@ -41,12 +41,12 @@ static constexpr size_t DATA_SIZE = 1 * 1024 * 1024ULL; // static constexpr size_t INPUT_BUFFER_SIZE = 32 * 1024llu; static constexpr size_t OUTPUT_BUFFER_SIZE = 64 * 1024ULL; -constexpr auto randChar = []() -> char { - constexpr char charset[] = "0123456789" +constexpr auto RandChar = []() -> char { + constexpr char Charset[] = "0123456789" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "abcdefghijklmnopqrstuvwxyz"; - constexpr size_t max_index = (sizeof(charset) - 1); - return charset[std::rand() % max_index]; + constexpr size_t MaxIndex = (sizeof(Charset) - 1); + return Charset[std::rand() % MaxIndex]; }; TEST(WasmEdgeZlibTest, DeflateInflateCycle) { @@ -116,7 +116,7 @@ TEST(WasmEdgeZlibTest, DeflateInflateCycle) { wasm_hp += std::strlen(ZLIB_VERSION); wasm_data = wasm_hp; - std::generate_n(MemInst.getPointer(wasm_hp), DATA_SIZE, randChar); + std::generate_n(MemInst.getPointer(wasm_hp), DATA_SIZE, RandChar); wasm_hp += DATA_SIZE; wasm_z_stream = wasm_hp; From 4805d6daba4c3530a1f168649d0d443ef050e7b4 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Tue, 1 Aug 2023 18:48:48 +0530 Subject: [PATCH 38/98] Updated a few more variable name to reflect LLVM standards. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index bb3cadf7becc..fd74bf3176a1 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -42,12 +42,12 @@ WasmEdgeZlibDeflateInit_::body(const Runtime::CallingFrame &Frame, HostZStream.get()->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored - const auto z_res = + const auto ZRes = deflateInit_(HostZStream.get(), Level, ZLIB_VERSION, sizeof(z_stream)); Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); - return static_cast(z_res); + return static_cast(ZRes); } Expect @@ -71,12 +71,12 @@ WasmEdgeZlibInflateInit_::body(const Runtime::CallingFrame &Frame, HostZStream.get()->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored - const auto z_res = + const auto ZRes = inflateInit_(HostZStream.get(), ZLIB_VERSION, sizeof(z_stream)); Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); - return static_cast(z_res); + return static_cast(ZRes); } Expect WasmEdgeZlibDeflate::WasmEdgeZlibDeflate::body( @@ -100,14 +100,14 @@ Expect WasmEdgeZlibDeflate::WasmEdgeZlibDeflate::body( const auto PreComputeNextIn = HostZStream->next_in; const auto PreComputeNextOut = HostZStream->next_out; - const auto z_res = deflate(HostZStream, Flush); + const auto ZRes = deflate(HostZStream, Flush); ModuleZStream->avail_in = HostZStream->avail_in; ModuleZStream->avail_out = HostZStream->avail_out; ModuleZStream->next_in += HostZStream->next_in - PreComputeNextIn; ModuleZStream->next_out += HostZStream->next_out - PreComputeNextOut; - return static_cast(z_res); + return static_cast(ZRes); } Expect WasmEdgeZlibInflate::body(const Runtime::CallingFrame &Frame, @@ -131,14 +131,14 @@ Expect WasmEdgeZlibInflate::body(const Runtime::CallingFrame &Frame, const auto PreComputeNextIn = HostZStream->next_in; const auto PreComputeNextOut = HostZStream->next_out; - const auto z_res = inflate(HostZStream, Flush); + const auto ZRes = inflate(HostZStream, Flush); ModuleZStream->avail_in = HostZStream->avail_in; ModuleZStream->avail_out = HostZStream->avail_out; ModuleZStream->next_in += HostZStream->next_in - PreComputeNextIn; ModuleZStream->next_out += HostZStream->next_out - PreComputeNextOut; - return static_cast(z_res); + return static_cast(ZRes); } Expect WasmEdgeZlibDeflateEnd::body(const Runtime::CallingFrame &, From 731d55a5c084e8381b680487f2daa57f26d808dd Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Mon, 7 Aug 2023 09:19:39 +0530 Subject: [PATCH 39/98] Added a more comprehensive Host and Wasm ZStream Syncronization Func, and wrapped all zlib calls with it. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 133 +++++++++++++++++------------ 1 file changed, 77 insertions(+), 56 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index fd74bf3176a1..f5edbc6b03c9 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -6,6 +6,9 @@ #include #include +namespace WasmEdge { +namespace Host { + constexpr bool CheckVersionSize(const char *WasmZlibVersion, int32_t StreamSize) { /* @@ -18,8 +21,51 @@ constexpr bool CheckVersionSize(const char *WasmZlibVersion, StreamSize == static_cast(sizeof(WasmZStream))); } -namespace WasmEdge { -namespace Host { +template +auto SyncRun(z_stream *HostZStream, uint32_t ZStreamPtr, + const Runtime::CallingFrame &Frame, T Callback) { + auto *MemInst = Frame.getMemoryByIndex(0); + WasmZStream *ModuleZStream = MemInst->getPointer(ZStreamPtr); + + HostZStream->next_in = + MemInst->getPointer(ModuleZStream->next_in); + HostZStream->avail_in = ModuleZStream->avail_in; + HostZStream->total_in = ModuleZStream->total_in; + + HostZStream->next_out = + MemInst->getPointer(ModuleZStream->next_out); + HostZStream->avail_out = ModuleZStream->avail_out; + HostZStream->total_out = ModuleZStream->total_out; + + // ignore msg, state + // ignore zalloc, zfree, opaque + + HostZStream->data_type = ModuleZStream->data_type; + HostZStream->adler = ModuleZStream->adler; + HostZStream->reserved = ModuleZStream->reserved; + + const auto PreComputeNextIn = HostZStream->next_in; + const auto PreComputeNextOut = HostZStream->next_out; + + const auto ZRes = Callback(); + + ModuleZStream->next_in += HostZStream->next_in - PreComputeNextIn; + ModuleZStream->avail_in = HostZStream->avail_in; + ModuleZStream->total_in = HostZStream->total_in; + + ModuleZStream->next_out += HostZStream->next_out - PreComputeNextOut; + ModuleZStream->avail_out = HostZStream->avail_out; + ModuleZStream->total_out = HostZStream->total_out; + + // ignore msg, state + // ignore zalloc, zfree, opaque + + ModuleZStream->data_type = HostZStream->data_type; + ModuleZStream->adler = HostZStream->adler; + ModuleZStream->reserved = HostZStream->reserved; + + return ZRes; +} Expect WasmEdgeZlibDeflateInit_::body(const Runtime::CallingFrame &Frame, @@ -42,12 +88,14 @@ WasmEdgeZlibDeflateInit_::body(const Runtime::CallingFrame &Frame, HostZStream.get()->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored - const auto ZRes = - deflateInit_(HostZStream.get(), Level, ZLIB_VERSION, sizeof(z_stream)); + const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { + return deflateInit_(HostZStream.get(), Level, ZLIB_VERSION, + sizeof(z_stream)); + }); Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); - return static_cast(ZRes); + return ZRes; } Expect @@ -71,12 +119,13 @@ WasmEdgeZlibInflateInit_::body(const Runtime::CallingFrame &Frame, HostZStream.get()->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored - const auto ZRes = - inflateInit_(HostZStream.get(), ZLIB_VERSION, sizeof(z_stream)); + const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { + return inflateInit_(HostZStream.get(), ZLIB_VERSION, sizeof(z_stream)); + }); Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); - return static_cast(ZRes); + return ZRes; } Expect WasmEdgeZlibDeflate::WasmEdgeZlibDeflate::body( @@ -86,28 +135,12 @@ Expect WasmEdgeZlibDeflate::WasmEdgeZlibDeflate::body( if (HostZStreamIt == Env.ZStreamMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); } - auto HostZStream = HostZStreamIt->second.get(); - auto *MemInst = Frame.getMemoryByIndex(0); - WasmZStream *ModuleZStream = MemInst->getPointer(ZStreamPtr); - - HostZStream->avail_in = ModuleZStream->avail_in; // value - HostZStream->avail_out = ModuleZStream->avail_out; // value - HostZStream->next_in = - MemInst->getPointer(ModuleZStream->next_in); // ptr - HostZStream->next_out = - MemInst->getPointer(ModuleZStream->next_out); // ptr - - const auto PreComputeNextIn = HostZStream->next_in; - const auto PreComputeNextOut = HostZStream->next_out; - const auto ZRes = deflate(HostZStream, Flush); + const int32_t ZRes = + SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, + [&]() { return deflate(HostZStreamIt->second.get(), Flush); }); - ModuleZStream->avail_in = HostZStream->avail_in; - ModuleZStream->avail_out = HostZStream->avail_out; - ModuleZStream->next_in += HostZStream->next_in - PreComputeNextIn; - ModuleZStream->next_out += HostZStream->next_out - PreComputeNextOut; - - return static_cast(ZRes); + return ZRes; } Expect WasmEdgeZlibInflate::body(const Runtime::CallingFrame &Frame, @@ -117,56 +150,44 @@ Expect WasmEdgeZlibInflate::body(const Runtime::CallingFrame &Frame, if (HostZStreamIt == Env.ZStreamMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); } - auto HostZStream = HostZStreamIt->second.get(); - auto *MemInst = Frame.getMemoryByIndex(0); - WasmZStream *ModuleZStream = MemInst->getPointer(ZStreamPtr); - HostZStream->avail_in = ModuleZStream->avail_in; // value - HostZStream->avail_out = ModuleZStream->avail_out; // value - HostZStream->next_in = - MemInst->getPointer(ModuleZStream->next_in); // ptr - HostZStream->next_out = - MemInst->getPointer(ModuleZStream->next_out); // ptr + const int32_t ZRes = + SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, + [&]() { return inflate(HostZStreamIt->second.get(), Flush); }); - const auto PreComputeNextIn = HostZStream->next_in; - const auto PreComputeNextOut = HostZStream->next_out; - - const auto ZRes = inflate(HostZStream, Flush); - - ModuleZStream->avail_in = HostZStream->avail_in; - ModuleZStream->avail_out = HostZStream->avail_out; - ModuleZStream->next_in += HostZStream->next_in - PreComputeNextIn; - ModuleZStream->next_out += HostZStream->next_out - PreComputeNextOut; - - return static_cast(ZRes); + return ZRes; } -Expect WasmEdgeZlibDeflateEnd::body(const Runtime::CallingFrame &, +Expect WasmEdgeZlibDeflateEnd::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr) { const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); if (HostZStreamIt == Env.ZStreamMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); } - auto HostZStream = HostZStreamIt->second.get(); - int32_t ZRes = deflateEnd(HostZStream); + + const int32_t ZRes = + SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, + [&]() { return deflateEnd(HostZStreamIt->second.get()); }); Env.ZStreamMap.erase(ZStreamPtr); - return static_cast(ZRes); + return ZRes; } -Expect WasmEdgeZlibInflateEnd::body(const Runtime::CallingFrame &, +Expect WasmEdgeZlibInflateEnd::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr) { const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); if (HostZStreamIt == Env.ZStreamMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); } - auto HostZStream = HostZStreamIt->second.get(); - int32_t ZRes = inflateEnd(HostZStream); + + const int32_t ZRes = + SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, + [&]() { return inflateEnd(HostZStreamIt->second.get()); }); Env.ZStreamMap.erase(ZStreamPtr); - return static_cast(ZRes); + return ZRes; } } // namespace Host From 31517720ef0fb52338bd1f287b4693f78b82a3de Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Mon, 7 Aug 2023 09:37:05 +0530 Subject: [PATCH 40/98] Change few comments. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index f5edbc6b03c9..e628c0e266e0 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -37,7 +37,8 @@ auto SyncRun(z_stream *HostZStream, uint32_t ZStreamPtr, HostZStream->avail_out = ModuleZStream->avail_out; HostZStream->total_out = ModuleZStream->total_out; - // ignore msg, state + // TODO: ignore msg for now + // ignore state // ignore zalloc, zfree, opaque HostZStream->data_type = ModuleZStream->data_type; @@ -57,7 +58,8 @@ auto SyncRun(z_stream *HostZStream, uint32_t ZStreamPtr, ModuleZStream->avail_out = HostZStream->avail_out; ModuleZStream->total_out = HostZStream->total_out; - // ignore msg, state + // TODO: ignore msg for now + // ignore state // ignore zalloc, zfree, opaque ModuleZStream->data_type = HostZStream->data_type; @@ -192,8 +194,3 @@ Expect WasmEdgeZlibInflateEnd::body(const Runtime::CallingFrame &Frame, } // namespace Host } // namespace WasmEdge - -/* -TODO: -sync *msg in [inflate|deflate]End() -*/ From dbb9f7aac80179a320b96ebeaabfd1c3f0308557 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Mon, 7 Aug 2023 10:03:49 +0530 Subject: [PATCH 41/98] Add Condition to only add ZStream to internal registry, if init succeeded. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index e628c0e266e0..52838ece2ebf 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -95,7 +95,8 @@ WasmEdgeZlibDeflateInit_::body(const Runtime::CallingFrame &Frame, sizeof(z_stream)); }); - Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); + if (ZRes == Z_OK) + Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); return ZRes; } @@ -125,7 +126,8 @@ WasmEdgeZlibInflateInit_::body(const Runtime::CallingFrame &Frame, return inflateInit_(HostZStream.get(), ZLIB_VERSION, sizeof(z_stream)); }); - Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); + if (ZRes == Z_OK) + Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); return ZRes; } From a23011d2748b85503a7845149b532f1cc1db1cf2 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Mon, 7 Aug 2023 10:21:53 +0530 Subject: [PATCH 42/98] Remove unnecessary zlib version check in wasmedge, delegated it to the zlib implementation. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 21 +++++++-------------- 1 file changed, 7 insertions(+), 14 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 52838ece2ebf..e39fc3766c6a 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -9,16 +9,9 @@ namespace WasmEdge { namespace Host { -constexpr bool CheckVersionSize(const char *WasmZlibVersion, - int32_t StreamSize) { - /* - Reason behind just comparing the first character of zlib version strings. - https://github.com/zlib-ng/zlib-ng/blob/2f4ebe2bb68380366b90f1db1f3c5b32601130a0/zutil.h#L130 - https://github.com/madler/zlib/blob/04f42ceca40f73e2978b50e93806c2a18c1281fc/inflate.c#L207 - */ - - return (WasmZlibVersion != 0 && WasmZlibVersion[0] == ZLIB_VERSION[0] && - StreamSize == static_cast(sizeof(WasmZStream))); +constexpr bool CheckSize(int32_t StreamSize) { + + return (StreamSize == static_cast(sizeof(WasmZStream))); } template @@ -80,7 +73,7 @@ WasmEdgeZlibDeflateInit_::body(const Runtime::CallingFrame &Frame, } const char *WasmZlibVersion = MemInst->getPointer(VersionPtr); - if (!CheckVersionSize(WasmZlibVersion, StreamSize)) + if (!CheckSize(StreamSize)) return static_cast(Z_VERSION_ERROR); auto HostZStream = std::make_unique(); @@ -91,7 +84,7 @@ WasmEdgeZlibDeflateInit_::body(const Runtime::CallingFrame &Frame, Z_NULL; // ignore opaque since zmalloc and zfree was ignored const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { - return deflateInit_(HostZStream.get(), Level, ZLIB_VERSION, + return deflateInit_(HostZStream.get(), Level, WasmZlibVersion, sizeof(z_stream)); }); @@ -112,7 +105,7 @@ WasmEdgeZlibInflateInit_::body(const Runtime::CallingFrame &Frame, } const char *WasmZlibVersion = MemInst->getPointer(VersionPtr); - if (!CheckVersionSize(WasmZlibVersion, StreamSize)) + if (!CheckSize(StreamSize)) return static_cast(Z_VERSION_ERROR); auto HostZStream = std::make_unique(); @@ -123,7 +116,7 @@ WasmEdgeZlibInflateInit_::body(const Runtime::CallingFrame &Frame, Z_NULL; // ignore opaque since zmalloc and zfree was ignored const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { - return inflateInit_(HostZStream.get(), ZLIB_VERSION, sizeof(z_stream)); + return inflateInit_(HostZStream.get(), WasmZlibVersion, sizeof(z_stream)); }); if (ZRes == Z_OK) From 0bafab8428d763bdc81da762add6fbac4eb5a3e8 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Mon, 7 Aug 2023 11:11:17 +0530 Subject: [PATCH 43/98] Added WasmEdgeZlibDeflateSetDictionary and WasmEdgeZlibDeflateGetDictionary. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 47 ++++++++++++++++++++++++++++-- plugins/wasmedge_zlib/zlibfunc.h | 18 ++++++++++++ 2 files changed, 63 insertions(+), 2 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index e39fc3766c6a..9855ece7dc8d 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -72,7 +72,7 @@ WasmEdgeZlibDeflateInit_::body(const Runtime::CallingFrame &Frame, return Unexpect(ErrCode::Value::HostFuncError); } - const char *WasmZlibVersion = MemInst->getPointer(VersionPtr); + const auto *WasmZlibVersion = MemInst->getPointer(VersionPtr); if (!CheckSize(StreamSize)) return static_cast(Z_VERSION_ERROR); @@ -104,7 +104,7 @@ WasmEdgeZlibInflateInit_::body(const Runtime::CallingFrame &Frame, return Unexpect(ErrCode::Value::HostFuncError); } - const char *WasmZlibVersion = MemInst->getPointer(VersionPtr); + const auto *WasmZlibVersion = MemInst->getPointer(VersionPtr); if (!CheckSize(StreamSize)) return static_cast(Z_VERSION_ERROR); @@ -187,5 +187,48 @@ Expect WasmEdgeZlibInflateEnd::body(const Runtime::CallingFrame &Frame, return ZRes; } +Expect WasmEdgeZlibDeflateSetDictionary::body( + const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + uint32_t DictionaryPtr, uint32_t DictLength) { + + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto *MemInst = Frame.getMemoryByIndex(0); + const auto *Dictionary = MemInst->getPointer(DictionaryPtr); + + const int32_t ZRes = + SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { + return deflateSetDictionary(HostZStreamIt->second.get(), Dictionary, + DictLength); + }); + + return ZRes; +} + +Expect WasmEdgeZlibDeflateGetDictionary::body( + const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + uint32_t DictionaryPtr, uint32_t DictLengthPtr) { + + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto *MemInst = Frame.getMemoryByIndex(0); + auto *Dictionary = MemInst->getPointer(DictionaryPtr); + auto *DictLength = MemInst->getPointer(DictLengthPtr); + + const int32_t ZRes = + SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { + return deflateGetDictionary(HostZStreamIt->second.get(), Dictionary, + DictLength); + }); + + return ZRes; +} + } // namespace Host } // namespace WasmEdge diff --git a/plugins/wasmedge_zlib/zlibfunc.h b/plugins/wasmedge_zlib/zlibfunc.h index 735d7b1486b8..58d273fda2d1 100644 --- a/plugins/wasmedge_zlib/zlibfunc.h +++ b/plugins/wasmedge_zlib/zlibfunc.h @@ -54,5 +54,23 @@ class WasmEdgeZlibInflateEnd : public WasmEdgeZlib { Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr); }; +class WasmEdgeZlibDeflateSetDictionary + : public WasmEdgeZlib { +public: + WasmEdgeZlibDeflateSetDictionary(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + uint32_t DictionaryPtr, uint32_t DictLength); +}; + +class WasmEdgeZlibDeflateGetDictionary + : public WasmEdgeZlib { +public: + WasmEdgeZlibDeflateGetDictionary(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + uint32_t DictionaryPtr, uint32_t DictLengthPtr); +}; + } // namespace Host } // namespace WasmEdge From e5c147e2969e6c5e35ee960cfe9a69f72406dab8 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Mon, 7 Aug 2023 11:58:31 +0530 Subject: [PATCH 44/98] Added WasmEdgeZlibDeflateCopy with a comment on impl. ref. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 29 +++++++++++++++++++++++++++++ plugins/wasmedge_zlib/zlibfunc.h | 8 ++++++++ 2 files changed, 37 insertions(+) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 9855ece7dc8d..28bb387dccb9 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -230,5 +230,34 @@ Expect WasmEdgeZlibDeflateGetDictionary::body( return ZRes; } +/* +"The deflateCopy() function shall copy the compression state information in +source to the uninitialized z_stream structure referenced by dest." + +https://refspecs.linuxbase.org/LSB_3.0.0/LSB-Core-generic/LSB-Core-generic/zlib-deflatecopy-1.html +*/ +Expect +WasmEdgeZlibDeflateCopy::body(const Runtime::CallingFrame &Frame, + uint32_t DestPtr, uint32_t SourcePtr) { + + const auto SourceZStreamIt = Env.ZStreamMap.find(SourcePtr); + if (SourceZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto DestZStream = std::make_unique(); + + SyncRun(SourceZStreamIt->second.get(), SourcePtr, Frame, []() { return 0; }); + + const int32_t ZRes = SyncRun(DestZStream.get(), DestPtr, Frame, [&]() { + return deflateCopy(DestZStream.get(), SourceZStreamIt->second.get()); + }); + + if (ZRes == Z_OK) + Env.ZStreamMap.emplace(std::make_pair(DestPtr, std::move(DestZStream))); + + return ZRes; +} + } // namespace Host } // namespace WasmEdge diff --git a/plugins/wasmedge_zlib/zlibfunc.h b/plugins/wasmedge_zlib/zlibfunc.h index 58d273fda2d1..5538349e9de3 100644 --- a/plugins/wasmedge_zlib/zlibfunc.h +++ b/plugins/wasmedge_zlib/zlibfunc.h @@ -72,5 +72,13 @@ class WasmEdgeZlibDeflateGetDictionary uint32_t DictionaryPtr, uint32_t DictLengthPtr); }; +class WasmEdgeZlibDeflateCopy : public WasmEdgeZlib { +public: + WasmEdgeZlibDeflateCopy(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t DestPtr, + uint32_t SourcePtr); +}; + } // namespace Host } // namespace WasmEdge From 076cd31dd377024b8da05ceebcb6063bb67efbe7 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Fri, 11 Aug 2023 05:56:42 +0530 Subject: [PATCH 45/98] Added deflateReset Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 16 ++++++++++++++++ plugins/wasmedge_zlib/zlibfunc.h | 7 +++++++ 2 files changed, 23 insertions(+) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 28bb387dccb9..72a689459bf0 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -259,5 +259,21 @@ WasmEdgeZlibDeflateCopy::body(const Runtime::CallingFrame &Frame, return ZRes; } +Expect +WasmEdgeZlibDeflateReset::body(const Runtime::CallingFrame &Frame, + uint32_t ZStreamPtr) { + + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + const int32_t ZRes = + SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, + [&]() { return deflateReset(HostZStreamIt->second.get()); }); + + return ZRes; +} + } // namespace Host } // namespace WasmEdge diff --git a/plugins/wasmedge_zlib/zlibfunc.h b/plugins/wasmedge_zlib/zlibfunc.h index 5538349e9de3..c379cd372920 100644 --- a/plugins/wasmedge_zlib/zlibfunc.h +++ b/plugins/wasmedge_zlib/zlibfunc.h @@ -80,5 +80,12 @@ class WasmEdgeZlibDeflateCopy : public WasmEdgeZlib { uint32_t SourcePtr); }; +class WasmEdgeZlibDeflateReset : public WasmEdgeZlib { +public: + WasmEdgeZlibDeflateReset(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr); +}; + } // namespace Host } // namespace WasmEdge From 6242f27efe63f14a5072615cb88da5e3766b5310 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Fri, 11 Aug 2023 06:00:41 +0530 Subject: [PATCH 46/98] Added deflateParams Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 18 ++++++++++++++++++ plugins/wasmedge_zlib/zlibfunc.h | 9 +++++++++ 2 files changed, 27 insertions(+) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 72a689459bf0..37f277342d75 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -275,5 +275,23 @@ WasmEdgeZlibDeflateReset::body(const Runtime::CallingFrame &Frame, return ZRes; } +Expect +WasmEdgeZlibDeflateParams::body(const Runtime::CallingFrame &Frame, + uint32_t ZStreamPtr, int32_t Level, + int32_t Strategy) { + + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + const int32_t ZRes = + SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { + return deflateParams(HostZStreamIt->second.get(), Level, Strategy); + }); + + return ZRes; +} + } // namespace Host } // namespace WasmEdge diff --git a/plugins/wasmedge_zlib/zlibfunc.h b/plugins/wasmedge_zlib/zlibfunc.h index c379cd372920..b3be00cea235 100644 --- a/plugins/wasmedge_zlib/zlibfunc.h +++ b/plugins/wasmedge_zlib/zlibfunc.h @@ -87,5 +87,14 @@ class WasmEdgeZlibDeflateReset : public WasmEdgeZlib { Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr); }; +class WasmEdgeZlibDeflateParams + : public WasmEdgeZlib { +public: + WasmEdgeZlibDeflateParams(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + int32_t Level, int32_t Strategy); +}; + } // namespace Host } // namespace WasmEdge From 57df5c780ee956fb32e69b49984601d46f469d88 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Fri, 11 Aug 2023 06:37:50 +0530 Subject: [PATCH 47/98] Added deflateTune & deflateBound. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 35 ++++++++++++++++++++++++++++++ plugins/wasmedge_zlib/zlibfunc.h | 19 ++++++++++++++++ 2 files changed, 54 insertions(+) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 37f277342d75..ee1bcd84bc9e 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -293,5 +293,40 @@ WasmEdgeZlibDeflateParams::body(const Runtime::CallingFrame &Frame, return ZRes; } +Expect WasmEdgeZlibDeflateTune::body( + const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t GoodLength, + int32_t MaxLazy, int32_t NiceLength, int32_t MaxChain) { + + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + const int32_t ZRes = + SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { + return deflateTune(HostZStreamIt->second.get(), GoodLength, MaxLazy, + NiceLength, MaxChain); + }); + + return ZRes; +} + +Expect +WasmEdgeZlibDeflateBound::body(const Runtime::CallingFrame &Frame, + uint32_t ZStreamPtr, uint32_t SourceLen) { + + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + const int32_t ZRes = + SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { + return deflateBound(HostZStreamIt->second.get(), SourceLen); + }); + + return ZRes; +} + } // namespace Host } // namespace WasmEdge diff --git a/plugins/wasmedge_zlib/zlibfunc.h b/plugins/wasmedge_zlib/zlibfunc.h index b3be00cea235..b9e78ff9d693 100644 --- a/plugins/wasmedge_zlib/zlibfunc.h +++ b/plugins/wasmedge_zlib/zlibfunc.h @@ -96,5 +96,24 @@ class WasmEdgeZlibDeflateParams int32_t Level, int32_t Strategy); }; +class WasmEdgeZlibDeflateTune : public WasmEdgeZlib { +public: + WasmEdgeZlibDeflateTune(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + int32_t GoodLength, int32_t MaxLazy, int32_t NiceLength, + int32_t MaxChain); +}; + +// https://github.com/emscripten-core/emscripten/issues/17009 +// Using 32bit, because on wasm-side it will be 32bit long +class WasmEdgeZlibDeflateBound : public WasmEdgeZlib { +public: + WasmEdgeZlibDeflateBound(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + uint32_t SourceLen); +}; + } // namespace Host } // namespace WasmEdge From 84a3e9cb571ce203ee31d3712500d3261d521c1b Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Fri, 11 Aug 2023 06:45:02 +0530 Subject: [PATCH 48/98] Added deflatePending & deflatePrime. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 40 ++++++++++++++++++++++++++++++ plugins/wasmedge_zlib/zlibfunc.h | 17 +++++++++++++ 2 files changed, 57 insertions(+) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index ee1bcd84bc9e..eebfa0e0b802 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -328,5 +328,45 @@ WasmEdgeZlibDeflateBound::body(const Runtime::CallingFrame &Frame, return ZRes; } +Expect +WasmEdgeZlibDeflatePending::body(const Runtime::CallingFrame &Frame, + uint32_t ZStreamPtr, uint32_t PendingPtr, + uint32_t BitsPtr) { + + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto *MemInst = Frame.getMemoryByIndex(0); + auto *Pending = MemInst->getPointer(PendingPtr); + auto *Bits = MemInst->getPointer(BitsPtr); + + const int32_t ZRes = + SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { + return deflatePending(HostZStreamIt->second.get(), Pending, Bits); + }); + + return ZRes; +} + +Expect +WasmEdgeZlibDeflatePrime::body(const Runtime::CallingFrame &Frame, + uint32_t ZStreamPtr, int32_t Bits, + int32_t Value) { + + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + const int32_t ZRes = + SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { + return deflatePrime(HostZStreamIt->second.get(), Bits, Value); + }); + + return ZRes; +} + } // namespace Host } // namespace WasmEdge diff --git a/plugins/wasmedge_zlib/zlibfunc.h b/plugins/wasmedge_zlib/zlibfunc.h index b9e78ff9d693..9db735aa516c 100644 --- a/plugins/wasmedge_zlib/zlibfunc.h +++ b/plugins/wasmedge_zlib/zlibfunc.h @@ -115,5 +115,22 @@ class WasmEdgeZlibDeflateBound : public WasmEdgeZlib { uint32_t SourceLen); }; +class WasmEdgeZlibDeflatePending + : public WasmEdgeZlib { +public: + WasmEdgeZlibDeflatePending(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + uint32_t PendingPtr, uint32_t BitsPtr); +}; + +class WasmEdgeZlibDeflatePrime : public WasmEdgeZlib { +public: + WasmEdgeZlibDeflatePrime(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + int32_t Bits, int32_t Value); +}; + } // namespace Host } // namespace WasmEdge From 0a9329c0faf65b2f8188d66de848f01416b3fd5d Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Fri, 18 Aug 2023 07:41:22 +0530 Subject: [PATCH 49/98] Defined the Wasm gz_header struct. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibenv.h | 23 ++++++++++++++++++++++- 1 file changed, 22 insertions(+), 1 deletion(-) diff --git a/plugins/wasmedge_zlib/zlibenv.h b/plugins/wasmedge_zlib/zlibenv.h index 03b59002da48..a0baa455c04e 100644 --- a/plugins/wasmedge_zlib/zlibenv.h +++ b/plugins/wasmedge_zlib/zlibenv.h @@ -52,9 +52,30 @@ struct WasmZStream { /* reserved for future use */ uint32_t reserved; }; - static_assert(sizeof(WasmZStream) == 56, "WasmZStream should be 56 bytes"); +/* + gzip header information passed to and from zlib routines. See RFC 1952 + for more details on the meanings of these fields. +*/ +struct WasmGZHeader { + int32_t text; /* true if compressed data believed to be text */ + uint32_t time; /* modification time */ + int32_t xflags; /* extra flags (not used when writing a gzip file) */ + int32_t os; /* operating system */ + uint32_t extra; /* pointer to extra field or Z_NULL if none */ + uint32_t extra_len; /* extra field length (valid if extra != Z_NULL) */ + uint32_t extra_max; /* space at extra (only when reading header) */ + uint32_t name; /* pointer to zero-terminated file name or Z_NULL */ + uint32_t name_max; /* space at name (only when reading header) */ + uint32_t comment; /* pointer to zero-terminated comment or Z_NULL */ + uint32_t comm_max; /* space at comment (only when reading header) */ + int32_t hcrc; /* true if there was or will be a header crc */ + int32_t done; /* true when done reading gzip header (not used + when writing a gzip file) */ +}; +static_assert(sizeof(WasmGZHeader) == 52, "WasmGZHeader should be 52 bytes"); + namespace WasmEdge { namespace Host { From ff5154dfcb68efc9c78526207795fd58f65189b4 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Sat, 19 Aug 2023 22:39:04 +0530 Subject: [PATCH 50/98] Added few function impl of zlib. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 187 +++++++++++++++++++++++++++++ plugins/wasmedge_zlib/zlibfunc.h | 80 ++++++++++++ 2 files changed, 267 insertions(+) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index eebfa0e0b802..798d25b5f092 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -368,5 +368,192 @@ WasmEdgeZlibDeflatePrime::body(const Runtime::CallingFrame &Frame, return ZRes; } +Expect WasmEdgeZlibInflateSetDictionary::body( + const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + uint32_t DictionaryPtr, uint32_t DictLength) { + + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto *MemInst = Frame.getMemoryByIndex(0); + auto *Dictionary = MemInst->getPointer(DictionaryPtr); + + const int32_t ZRes = + SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { + return inflateSetDictionary(HostZStreamIt->second.get(), Dictionary, + DictLength); + }); + + return ZRes; +} + +Expect WasmEdgeZlibInflateSetDictionary::body( + const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + uint32_t DictionaryPtr, uint32_t DictLength) { + + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto *MemInst = Frame.getMemoryByIndex(0); + auto *Dictionary = MemInst->getPointer(DictionaryPtr); + + const int32_t ZRes = + SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { + return inflateSetDictionary(HostZStreamIt->second.get(), Dictionary, + DictLength); + }); + + return ZRes; +} + +Expect WasmEdgeZlibInflateSetDictionary::body( + const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + uint32_t DictionaryPtr, uint32_t DictLengthPtr) { + + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto *MemInst = Frame.getMemoryByIndex(0); + auto *Dictionary = MemInst->getPointer(DictionaryPtr); + auto *DictLength = MemInst->getPointer(DictLengthPtr); + + const int32_t ZRes = + SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { + return inflateGetDictionary(HostZStreamIt->second.get(), Dictionary, + DictLength); + }); + + return ZRes; +} + +Expect +WasmEdgeZlibInflateSync::body(const Runtime::CallingFrame &Frame, + uint32_t ZStreamPtr) { + + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + const int32_t ZRes = + SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, + [&]() { return inflateSync(HostZStreamIt->second.get()); }); + + return ZRes; +} + +Expect +WasmEdgeZlibInflateCopy::body(const Runtime::CallingFrame &Frame, + uint32_t DestPtr, uint32_t SourcePtr) { + + const auto SourceZStreamIt = Env.ZStreamMap.find(SourcePtr); + if (SourceZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto DestZStream = std::make_unique(); + + SyncRun(SourceZStreamIt->second.get(), SourcePtr, Frame, []() { return 0; }); + + const int32_t ZRes = SyncRun(DestZStream.get(), DestPtr, Frame, [&]() { + return inflateCopy(DestZStream.get(), SourceZStreamIt->second.get()); + }); + + if (ZRes == Z_OK) + Env.ZStreamMap.emplace(std::make_pair(DestPtr, std::move(DestZStream))); + + return ZRes; +} + +Expect +WasmEdgeZlibInflateReset::body(const Runtime::CallingFrame &Frame, + uint32_t ZStreamPtr) { + + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + const int32_t ZRes = + SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, + [&]() { return inflateReset(HostZStreamIt->second.get()); }); + + return ZRes; +} + +Expect +WasmEdgeZlibInflateReset2::body(const Runtime::CallingFrame &Frame, + uint32_t ZStreamPtr, int32_t WindowBits) { + + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + const int32_t ZRes = + SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { + return inflateReset2(HostZStreamIt->second.get(), WindowBits); + }); + + return ZRes; +} + +Expect +WasmEdgeZlibInflatePrime::body(const Runtime::CallingFrame &Frame, + uint32_t ZStreamPtr, int32_t Bits, + int32_t Value) { + + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + const int32_t ZRes = + SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { + return inflatePrime(HostZStreamIt->second.get(), Bits, Value); + }); + + return ZRes; +} + +Expect +WasmEdgeZlibInflateMark::body(const Runtime::CallingFrame &Frame, + uint32_t ZStreamPtr) { + + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + const int32_t ZRes = + SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, + [&]() { return inflateMark(HostZStreamIt->second.get()); }); + + return ZRes; +} + +Expect +WasmEdgeZlibInflateBackEnd::body(const Runtime::CallingFrame &Frame, + uint32_t ZStreamPtr) { + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + const int32_t ZRes = + SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, + [&]() { return inflateBackEnd(HostZStreamIt->second.get()); }); + + Env.ZStreamMap.erase(ZStreamPtr); + + return ZRes; +} + } // namespace Host } // namespace WasmEdge diff --git a/plugins/wasmedge_zlib/zlibfunc.h b/plugins/wasmedge_zlib/zlibfunc.h index 9db735aa516c..045d0ff4f2f9 100644 --- a/plugins/wasmedge_zlib/zlibfunc.h +++ b/plugins/wasmedge_zlib/zlibfunc.h @@ -132,5 +132,85 @@ class WasmEdgeZlibDeflatePrime : public WasmEdgeZlib { int32_t Bits, int32_t Value); }; +class WasmEdgeZlibInflateSetDictionary + : public WasmEdgeZlib { +public: + WasmEdgeZlibInflateSetDictionary(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + uint32_t DictionaryPtr, uint32_t DictLength); +}; + +class WasmEdgeZlibInflateGetDictionary + : public WasmEdgeZlib { +public: + WasmEdgeZlibInflateGetDictionary(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + uint32_t DictionaryPtr, uint32_t DictLengthPtr); +}; + +class WasmEdgeZlibInflateSync : public WasmEdgeZlib { +public: + WasmEdgeZlibInflateSync(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr); +}; + +class WasmEdgeZlibInflateCopy : public WasmEdgeZlib { +public: + WasmEdgeZlibInflateCopy(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t DestPtr, + uint32_t SourcePtr); +}; + +class WasmEdgeZlibInflateReset : public WasmEdgeZlib { +public: + WasmEdgeZlibInflateReset(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr); +}; + +class WasmEdgeZlibInflateReset2 + : public WasmEdgeZlib { +public: + WasmEdgeZlibInflateReset2(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + int32_t WindowBits); +}; + +class WasmEdgeZlibInflatePrime : public WasmEdgeZlib { +public: + WasmEdgeZlibInflatePrime(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + int32_t Bits, int32_t Value); +}; + +class WasmEdgeZlibInflateMark : public WasmEdgeZlib { +public: + WasmEdgeZlibInflateMark(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr); +}; + +class WasmEdgeZlibInflateBack : public WasmEdgeZlib { +public: + WasmEdgeZlibInflateBack(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + int32_t Bits, int32_t Value); +}; + +class WasmEdgeZlibInflateBackEnd + : public WasmEdgeZlib { +public: + WasmEdgeZlibInflateBackEnd(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr); +}; + } // namespace Host } // namespace WasmEdge From 10125fd541230e547ee361e2308603e83282f23c Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Sat, 19 Aug 2023 23:44:53 +0530 Subject: [PATCH 51/98] Added most of non gz functions. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 134 +++++++++++++++++++++++++++++ plugins/wasmedge_zlib/zlibfunc.h | 52 +++++++++++ 2 files changed, 186 insertions(+) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 798d25b5f092..bf4e205abec1 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -197,6 +197,10 @@ Expect WasmEdgeZlibDeflateSetDictionary::body( } auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + const auto *Dictionary = MemInst->getPointer(DictionaryPtr); const int32_t ZRes = @@ -218,6 +222,10 @@ Expect WasmEdgeZlibDeflateGetDictionary::body( } auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + auto *Dictionary = MemInst->getPointer(DictionaryPtr); auto *DictLength = MemInst->getPointer(DictLengthPtr); @@ -339,6 +347,10 @@ WasmEdgeZlibDeflatePending::body(const Runtime::CallingFrame &Frame, } auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + auto *Pending = MemInst->getPointer(PendingPtr); auto *Bits = MemInst->getPointer(BitsPtr); @@ -378,6 +390,10 @@ Expect WasmEdgeZlibInflateSetDictionary::body( } auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + auto *Dictionary = MemInst->getPointer(DictionaryPtr); const int32_t ZRes = @@ -399,6 +415,10 @@ Expect WasmEdgeZlibInflateSetDictionary::body( } auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + auto *Dictionary = MemInst->getPointer(DictionaryPtr); const int32_t ZRes = @@ -420,6 +440,10 @@ Expect WasmEdgeZlibInflateSetDictionary::body( } auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + auto *Dictionary = MemInst->getPointer(DictionaryPtr); auto *DictLength = MemInst->getPointer(DictLengthPtr); @@ -555,5 +579,115 @@ WasmEdgeZlibInflateBackEnd::body(const Runtime::CallingFrame &Frame, return ZRes; } +Expect +WasmEdgeZlibZlibCompilerFlags::body(const Runtime::CallingFrame &Frame) { + const int32_t ZRes = zlibCompileFlags(); + + return ZRes; +} + +Expect WasmEdgeZlibCompress::body(const Runtime::CallingFrame &Frame, + uint32_t DestPtr, + uint32_t DestLenPtr, + uint32_t SourcePtr, + uint32_t SourceLen) { + + auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto *Dest = MemInst->getPointer(DestPtr); + auto *DestLen = MemInst->getPointer(DestLenPtr); + auto *Source = MemInst->getPointer(SourcePtr); + + unsigned long *HostDestLen; + *HostDestLen = *DestLen; + const int32_t ZRes = compress(Dest, HostDestLen, Source, SourceLen); + *DestLen = *HostDestLen; + + return ZRes; +} + +Expect WasmEdgeZlibCompress2::body(const Runtime::CallingFrame &Frame, + uint32_t DestPtr, + uint32_t DestLenPtr, + uint32_t SourcePtr, + uint32_t SourceLen, int32_t Level) { + + auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto *Dest = MemInst->getPointer(DestPtr); + auto *DestLen = MemInst->getPointer(DestLenPtr); + auto *Source = MemInst->getPointer(SourcePtr); + + unsigned long *HostDestLen; + *HostDestLen = *DestLen; + const int32_t ZRes = compress2(Dest, HostDestLen, Source, SourceLen, Level); + *DestLen = *HostDestLen; + + return ZRes; +} + +Expect +WasmEdgeZlibCompressBound::body(const Runtime::CallingFrame &Frame, + uint32_t SourceLen) { + const int32_t ZRes = compressBound(SourceLen); + + return ZRes; +} + +Expect WasmEdgeZlibUncompress::body(const Runtime::CallingFrame &Frame, + uint32_t DestPtr, + uint32_t DestLenPtr, + uint32_t SourcePtr, + uint32_t SourceLen) { + + auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto *Dest = MemInst->getPointer(DestPtr); + auto *DestLen = MemInst->getPointer(DestLenPtr); + auto *Source = MemInst->getPointer(SourcePtr); + + unsigned long *HostDestLen; + *HostDestLen = *DestLen; + const int32_t ZRes = uncompress(Dest, HostDestLen, Source, SourceLen); + *DestLen = *HostDestLen; + + return ZRes; +} + +Expect WasmEdgeZlibUncompress::body(const Runtime::CallingFrame &Frame, + uint32_t DestPtr, + uint32_t DestLenPtr, + uint32_t SourcePtr, + uint32_t SourceLenPtr) { + + auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto *Dest = MemInst->getPointer(DestPtr); + auto *DestLen = MemInst->getPointer(DestLenPtr); + auto *Source = MemInst->getPointer(SourcePtr); + auto *SourceLen = MemInst->getPointer(SourceLenPtr); + + unsigned long *HostDestLen, *HostSourceLen; + *HostDestLen = *DestLen; + *HostSourceLen = *SourceLen; + const int32_t ZRes = uncompress2(Dest, HostDestLen, Source, HostSourceLen); + *DestLen = *HostDestLen; + *SourceLen = *HostSourceLen; + + return ZRes; +} + } // namespace Host } // namespace WasmEdge diff --git a/plugins/wasmedge_zlib/zlibfunc.h b/plugins/wasmedge_zlib/zlibfunc.h index 045d0ff4f2f9..6ddefbce2102 100644 --- a/plugins/wasmedge_zlib/zlibfunc.h +++ b/plugins/wasmedge_zlib/zlibfunc.h @@ -212,5 +212,57 @@ class WasmEdgeZlibInflateBackEnd Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr); }; +class WasmEdgeZlibZlibCompilerFlags + : public WasmEdgeZlib { +public: + WasmEdgeZlibZlibCompilerFlags(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame); +}; + +class WasmEdgeZlibCompress : public WasmEdgeZlib { +public: + WasmEdgeZlibCompress(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t DestPtr, + uint32_t DestLenPtr, uint32_t SourcePtr, + uint32_t SourceLen); +}; + +class WasmEdgeZlibCompress2 : public WasmEdgeZlib { +public: + WasmEdgeZlibCompress2(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t DestPtr, + uint32_t DestLenPtr, uint32_t SourcePtr, + uint32_t SourceLen, int32_t Level); +}; + +class WasmEdgeZlibCompressBound + : public WasmEdgeZlib { +public: + WasmEdgeZlibCompressBound(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t SourceLen); +}; + +class WasmEdgeZlibUncompress : public WasmEdgeZlib { +public: + WasmEdgeZlibUncompress(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t DestPtr, + uint32_t DestLenPtr, uint32_t SourcePtr, + uint32_t SourceLen); +}; + +class WasmEdgeZlibUncompress2 : public WasmEdgeZlib { +public: + WasmEdgeZlibUncompress2(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t DestPtr, + uint32_t DestLenPtr, uint32_t SourcePtr, + uint32_t SourceLenPtr); +}; + } // namespace Host } // namespace WasmEdge From 9102cbb0db678867f88a089f4c996ac8be3fd821 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Sun, 20 Aug 2023 00:10:31 +0530 Subject: [PATCH 52/98] Added adler32, adler32_z, crc32, crc32_z. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 73 ++++++++++++++++++++++++++++-- plugins/wasmedge_zlib/zlibfunc.h | 31 +++++++++++++ 2 files changed, 99 insertions(+), 5 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index bf4e205abec1..7934cb3bf644 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -663,11 +663,10 @@ Expect WasmEdgeZlibUncompress::body(const Runtime::CallingFrame &Frame, return ZRes; } -Expect WasmEdgeZlibUncompress::body(const Runtime::CallingFrame &Frame, - uint32_t DestPtr, - uint32_t DestLenPtr, - uint32_t SourcePtr, - uint32_t SourceLenPtr) { +Expect +WasmEdgeZlibUncompress2::body(const Runtime::CallingFrame &Frame, + uint32_t DestPtr, uint32_t DestLenPtr, + uint32_t SourcePtr, uint32_t SourceLenPtr) { auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { @@ -689,5 +688,69 @@ Expect WasmEdgeZlibUncompress::body(const Runtime::CallingFrame &Frame, return ZRes; } +Expect WasmEdgeZlibAdler32::body(const Runtime::CallingFrame &Frame, + uint32_t Adler, uint32_t BufPtr, + uint32_t Len) { + + auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto *Buf = MemInst->getPointer(BufPtr); + + const int32_t ZRes = adler32(Adler, Buf, Len); + + return ZRes; +} + +Expect WasmEdgeZlibAdler32_z::body(const Runtime::CallingFrame &Frame, + uint32_t Adler, uint32_t BufPtr, + uint32_t Len) { + + auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto *Buf = MemInst->getPointer(BufPtr); + + const int32_t ZRes = adler32_z(Adler, Buf, Len); + + return ZRes; +} + +Expect WasmEdgeZlibCRC32::body(const Runtime::CallingFrame &Frame, + uint32_t CRC, uint32_t BufPtr, + uint32_t Len) { + + auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto *Buf = MemInst->getPointer(BufPtr); + + const int32_t ZRes = crc32(CRC, Buf, Len); + + return ZRes; +} + +Expect WasmEdgeZlibCRC32_z::body(const Runtime::CallingFrame &Frame, + uint32_t CRC, uint32_t BufPtr, + uint32_t Len) { + + auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto *Buf = MemInst->getPointer(BufPtr); + + const int32_t ZRes = crc32_z(CRC, Buf, Len); + + return ZRes; +} + } // namespace Host } // namespace WasmEdge diff --git a/plugins/wasmedge_zlib/zlibfunc.h b/plugins/wasmedge_zlib/zlibfunc.h index 6ddefbce2102..543ebeb5ce08 100644 --- a/plugins/wasmedge_zlib/zlibfunc.h +++ b/plugins/wasmedge_zlib/zlibfunc.h @@ -264,5 +264,36 @@ class WasmEdgeZlibUncompress2 : public WasmEdgeZlib { uint32_t SourceLenPtr); }; +class WasmEdgeZlibAdler32 : public WasmEdgeZlib { +public: + WasmEdgeZlibAdler32(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t Adler, + uint32_t BufPtr, uint32_t Len); +}; + +class WasmEdgeZlibAdler32_z : public WasmEdgeZlib { +public: + WasmEdgeZlibAdler32_z(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t Adler, + uint32_t BufPtr, uint32_t Len); +}; + +class WasmEdgeZlibCRC32 : public WasmEdgeZlib { +public: + WasmEdgeZlibCRC32(WasmEdgeZlibEnvironment &HostEnv) : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t CRC, + uint32_t BufPtr, uint32_t Len); +}; + +class WasmEdgeZlibCRC32_z : public WasmEdgeZlib { +public: + WasmEdgeZlibCRC32_z(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t CRC, + uint32_t BufPtr, uint32_t Len); +}; + } // namespace Host } // namespace WasmEdge From 28bf85d99fdc87c69b6d9192ce105e6dd5720246 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Thu, 24 Aug 2023 22:15:41 +0530 Subject: [PATCH 53/98] Remove _v2 postfix Signed-off-by: Saikat Dey --- .github/workflows/build-extensions.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/build-extensions.yml b/.github/workflows/build-extensions.yml index b672d9e60938..412386a4767d 100644 --- a/.github/workflows/build-extensions.yml +++ b/.github/workflows/build-extensions.yml @@ -259,7 +259,7 @@ jobs: - name: Upload artifact - wasmedge_zlib uses: actions/upload-artifact@v3 with: - name: WasmEdge-plugin-wasmedge_zlib-${{ needs.get_version_v2.outputs.version }}-ubuntu22.04-${{ matrix.compiler }}.tar.gz + name: WasmEdge-plugin-wasmedge_zlib-${{ needs.get_version.outputs.version }}-ubuntu22.04-${{ matrix.compiler }}.tar.gz path: plugin_wasmedge_zlib.tar.gz # Due to the dependencies and exclusions of WASI-NN, build them saperately. @@ -462,7 +462,7 @@ jobs: - name: Upload artifact - wasmedge_zlib uses: actions/upload-artifact@v3 with: - name: WasmEdge-plugin-wasmedge_zlib-${{ needs.get_version_v2.outputs.version }}-${{ matrix.docker_tag }}.tar.gz + name: WasmEdge-plugin-wasmedge_zlib-${{ needs.get_version.outputs.version }}-${{ matrix.docker_tag }}.tar.gz path: plugin_wasmedge_zlib.tar.gz build_macos: From 1e31c2d57a7110e85ab85a784c3f4698c9488826 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Thu, 24 Aug 2023 22:39:41 +0530 Subject: [PATCH 54/98] Remove duplicate impl. of WasmEdgeZlibInflateSetDictionary. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 27 +-------------------------- 1 file changed, 1 insertion(+), 26 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 7934cb3bf644..117b1a8de9b2 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -405,32 +405,7 @@ Expect WasmEdgeZlibInflateSetDictionary::body( return ZRes; } -Expect WasmEdgeZlibInflateSetDictionary::body( - const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, - uint32_t DictionaryPtr, uint32_t DictLength) { - - const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); - if (HostZStreamIt == Env.ZStreamMap.end()) { - return Unexpect(ErrCode::Value::HostFuncError); - } - - auto *MemInst = Frame.getMemoryByIndex(0); - if (MemInst == nullptr) { - return Unexpect(ErrCode::Value::HostFuncError); - } - - auto *Dictionary = MemInst->getPointer(DictionaryPtr); - - const int32_t ZRes = - SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { - return inflateSetDictionary(HostZStreamIt->second.get(), Dictionary, - DictLength); - }); - - return ZRes; -} - -Expect WasmEdgeZlibInflateSetDictionary::body( +Expect WasmEdgeZlibInflateGetDictionary::body( const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, uint32_t DictionaryPtr, uint32_t DictLengthPtr) { From c607f08608ae34aa0bea1c967883555ec315b415 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Thu, 24 Aug 2023 22:46:16 +0530 Subject: [PATCH 55/98] Remove unused parameter 'Frame' from WasmEdgeZlibZlibCompilerFlags & WasmEdgeZlibCompressBound. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 117b1a8de9b2..24cfe9083436 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -555,7 +555,7 @@ WasmEdgeZlibInflateBackEnd::body(const Runtime::CallingFrame &Frame, } Expect -WasmEdgeZlibZlibCompilerFlags::body(const Runtime::CallingFrame &Frame) { +WasmEdgeZlibZlibCompilerFlags::body(const Runtime::CallingFrame &) { const int32_t ZRes = zlibCompileFlags(); return ZRes; @@ -607,9 +607,8 @@ Expect WasmEdgeZlibCompress2::body(const Runtime::CallingFrame &Frame, return ZRes; } -Expect -WasmEdgeZlibCompressBound::body(const Runtime::CallingFrame &Frame, - uint32_t SourceLen) { +Expect WasmEdgeZlibCompressBound::body(const Runtime::CallingFrame &, + uint32_t SourceLen) { const int32_t ZRes = compressBound(SourceLen); return ZRes; From bea8b35d152fcbd8af573f3a8a9f597ec6b5c574 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Thu, 24 Aug 2023 23:19:44 +0530 Subject: [PATCH 56/98] Correct few pointer value usage. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 36 +++++++++++++++--------------- 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 24cfe9083436..eb2e69c2fa66 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -576,10 +576,10 @@ Expect WasmEdgeZlibCompress::body(const Runtime::CallingFrame &Frame, auto *DestLen = MemInst->getPointer(DestLenPtr); auto *Source = MemInst->getPointer(SourcePtr); - unsigned long *HostDestLen; - *HostDestLen = *DestLen; - const int32_t ZRes = compress(Dest, HostDestLen, Source, SourceLen); - *DestLen = *HostDestLen; + unsigned long HostDestLen; + HostDestLen = *DestLen; + const int32_t ZRes = compress(Dest, &HostDestLen, Source, SourceLen); + *DestLen = HostDestLen; return ZRes; } @@ -599,10 +599,10 @@ Expect WasmEdgeZlibCompress2::body(const Runtime::CallingFrame &Frame, auto *DestLen = MemInst->getPointer(DestLenPtr); auto *Source = MemInst->getPointer(SourcePtr); - unsigned long *HostDestLen; - *HostDestLen = *DestLen; - const int32_t ZRes = compress2(Dest, HostDestLen, Source, SourceLen, Level); - *DestLen = *HostDestLen; + unsigned long HostDestLen; + HostDestLen = *DestLen; + const int32_t ZRes = compress2(Dest, &HostDestLen, Source, SourceLen, Level); + *DestLen = HostDestLen; return ZRes; } @@ -629,10 +629,10 @@ Expect WasmEdgeZlibUncompress::body(const Runtime::CallingFrame &Frame, auto *DestLen = MemInst->getPointer(DestLenPtr); auto *Source = MemInst->getPointer(SourcePtr); - unsigned long *HostDestLen; - *HostDestLen = *DestLen; - const int32_t ZRes = uncompress(Dest, HostDestLen, Source, SourceLen); - *DestLen = *HostDestLen; + unsigned long HostDestLen; + HostDestLen = *DestLen; + const int32_t ZRes = uncompress(Dest, &HostDestLen, Source, SourceLen); + *DestLen = HostDestLen; return ZRes; } @@ -652,12 +652,12 @@ WasmEdgeZlibUncompress2::body(const Runtime::CallingFrame &Frame, auto *Source = MemInst->getPointer(SourcePtr); auto *SourceLen = MemInst->getPointer(SourceLenPtr); - unsigned long *HostDestLen, *HostSourceLen; - *HostDestLen = *DestLen; - *HostSourceLen = *SourceLen; - const int32_t ZRes = uncompress2(Dest, HostDestLen, Source, HostSourceLen); - *DestLen = *HostDestLen; - *SourceLen = *HostSourceLen; + unsigned long HostDestLen, HostSourceLen; + HostDestLen = *DestLen; + HostSourceLen = *SourceLen; + const int32_t ZRes = uncompress2(Dest, &HostDestLen, Source, &HostSourceLen); + *DestLen = HostDestLen; + *SourceLen = HostSourceLen; return ZRes; } From 7ee7a324269d8cee42601c5c5e11432678c29487 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Fri, 25 Aug 2023 01:33:39 +0530 Subject: [PATCH 57/98] Added GZFile support Env & implemented WasmEdgeZlibGZDOpen. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibenv.h | 1 + plugins/wasmedge_zlib/zlibfunc.cpp | 21 +++++++++++++++++++++ plugins/wasmedge_zlib/zlibfunc.h | 16 ++++++++++++++++ 3 files changed, 38 insertions(+) diff --git a/plugins/wasmedge_zlib/zlibenv.h b/plugins/wasmedge_zlib/zlibenv.h index a0baa455c04e..e869c6acd7d9 100644 --- a/plugins/wasmedge_zlib/zlibenv.h +++ b/plugins/wasmedge_zlib/zlibenv.h @@ -82,6 +82,7 @@ namespace Host { class WasmEdgeZlibEnvironment { public: std::unordered_map> ZStreamMap; + std::map, std::greater> GZFileMap; /// Initial Configurations static Plugin::PluginRegister Register; diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index eb2e69c2fa66..a2ff2231112d 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -14,6 +14,8 @@ constexpr bool CheckSize(int32_t StreamSize) { return (StreamSize == static_cast(sizeof(WasmZStream))); } +static constexpr uint32_t WasmGZFileStart = sizeof(gzFile); + template auto SyncRun(z_stream *HostZStream, uint32_t ZStreamPtr, const Runtime::CallingFrame &Frame, T Callback) { @@ -726,5 +728,24 @@ Expect WasmEdgeZlibCRC32_z::body(const Runtime::CallingFrame &Frame, return ZRes; } +Expect WasmEdgeZlibGZDOpen::body(const Runtime::CallingFrame &Frame, + int32_t FD, uint32_t ModePtr) { + + auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto *Mode = MemInst->getPointer(ModePtr); + + gzFile ZRes = gzdopen(FD, Mode); + + const auto NewWasmGZFile = WasmGZFileStart + Env.GZFileMap.size(); + Env.GZFileMap.emplace(std::pair>{ + NewWasmGZFile, std::make_unique(ZRes)}); + + return NewWasmGZFile; +} + } // namespace Host } // namespace WasmEdge diff --git a/plugins/wasmedge_zlib/zlibfunc.h b/plugins/wasmedge_zlib/zlibfunc.h index 543ebeb5ce08..764ebbf19934 100644 --- a/plugins/wasmedge_zlib/zlibfunc.h +++ b/plugins/wasmedge_zlib/zlibfunc.h @@ -295,5 +295,21 @@ class WasmEdgeZlibCRC32_z : public WasmEdgeZlib { uint32_t BufPtr, uint32_t Len); }; +class WasmEdgeZlibGZDOpen : public WasmEdgeZlib { +public: + WasmEdgeZlibGZDOpen(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, int32_t FD, + uint32_t ModePtr); +}; + +class WasmEdgeZlibGZBuffer : public WasmEdgeZlib { +public: + WasmEdgeZlibGZBuffer(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile, + uint32_t Size); +}; + } // namespace Host } // namespace WasmEdge From b54d1269ff185632a99d8c467f49a3b614899b45 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Fri, 25 Aug 2023 02:21:52 +0530 Subject: [PATCH 58/98] Implemented gzbuffer, gzsetparams & gzread. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibenv.h | 5 ++- plugins/wasmedge_zlib/zlibfunc.cpp | 51 +++++++++++++++++++++++++++++- plugins/wasmedge_zlib/zlibfunc.h | 16 ++++++++++ 3 files changed, 70 insertions(+), 2 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibenv.h b/plugins/wasmedge_zlib/zlibenv.h index e869c6acd7d9..cb9b65e3358a 100644 --- a/plugins/wasmedge_zlib/zlibenv.h +++ b/plugins/wasmedge_zlib/zlibenv.h @@ -81,8 +81,11 @@ namespace Host { class WasmEdgeZlibEnvironment { public: + using GZFile_s = std::remove_pointer_t; + std::unordered_map> ZStreamMap; - std::map, std::greater> GZFileMap; + std::map, std::greater> + GZFileMap; /// Initial Configurations static Plugin::PluginRegister Register; diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index a2ff2231112d..943eb0eb9314 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -738,7 +738,7 @@ Expect WasmEdgeZlibGZDOpen::body(const Runtime::CallingFrame &Frame, auto *Mode = MemInst->getPointer(ModePtr); - gzFile ZRes = gzdopen(FD, Mode); + auto ZRes = gzdopen(FD, Mode); const auto NewWasmGZFile = WasmGZFileStart + Env.GZFileMap.size(); Env.GZFileMap.emplace(std::pair>{ @@ -747,5 +747,54 @@ Expect WasmEdgeZlibGZDOpen::body(const Runtime::CallingFrame &Frame, return NewWasmGZFile; } +Expect WasmEdgeZlibGZBuffer::body(const Runtime::CallingFrame &Frame, + uint32_t GZFile, uint32_t Size) { + + const auto GZFileIt = Env.GZFileMap.find(GZFile); + if (GZFileIt == Env.GZFileMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto ZRes = gzbuffer(GZFileIt->second.get(), Size); + + return ZRes; +} + +Expect +WasmEdgeZlibGZSetParams::body(const Runtime::CallingFrame &Frame, + uint32_t GZFile, int32_t Level, + int32_t Strategy) { + + const auto GZFileIt = Env.GZFileMap.find(GZFile); + if (GZFileIt == Env.GZFileMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto ZRes = gzsetparams(GZFileIt->second.get(), Level, Strategy); + + return ZRes; +} + +Expect WasmEdgeZlibGZRead::body(const Runtime::CallingFrame &Frame, + uint32_t GZFile, uint32_t BufPtr, + uint32_t Len) { + + const auto GZFileIt = Env.GZFileMap.find(GZFile); + if (GZFileIt == Env.GZFileMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto *Buf = MemInst->getPointer(BufPtr); + + auto ZRes = gzread(GZFileIt->second.get(), Buf, Len); + + return ZRes; +} + } // namespace Host } // namespace WasmEdge diff --git a/plugins/wasmedge_zlib/zlibfunc.h b/plugins/wasmedge_zlib/zlibfunc.h index 764ebbf19934..cb65493831e4 100644 --- a/plugins/wasmedge_zlib/zlibfunc.h +++ b/plugins/wasmedge_zlib/zlibfunc.h @@ -311,5 +311,21 @@ class WasmEdgeZlibGZBuffer : public WasmEdgeZlib { uint32_t Size); }; +class WasmEdgeZlibGZSetParams : public WasmEdgeZlib { +public: + WasmEdgeZlibGZSetParams(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile, + int32_t Level, int32_t Strategy); +}; + +class WasmEdgeZlibGZRead : public WasmEdgeZlib { +public: + WasmEdgeZlibGZRead(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile, + uint32_t BufPtr, uint32_t Len); +}; + } // namespace Host } // namespace WasmEdge From 5025c3d961fea830bfadfb337f014ccffe213ed5 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Fri, 25 Aug 2023 02:41:08 +0530 Subject: [PATCH 59/98] Added gzfread, gzwrite & gzfwrite. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 63 ++++++++++++++++++++++++++++++ plugins/wasmedge_zlib/zlibfunc.h | 24 ++++++++++++ 2 files changed, 87 insertions(+) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 943eb0eb9314..e7a280b2bb22 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -796,5 +796,68 @@ Expect WasmEdgeZlibGZRead::body(const Runtime::CallingFrame &Frame, return ZRes; } +Expect WasmEdgeZlibGZFread::body(const Runtime::CallingFrame &Frame, + uint32_t BufPtr, uint32_t Size, + uint32_t NItems, uint32_t GZFile) { + + const auto GZFileIt = Env.GZFileMap.find(GZFile); + if (GZFileIt == Env.GZFileMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto *Buf = MemInst->getPointer(BufPtr); + + auto ZRes = gzfread(Buf, Size, NItems, GZFileIt->second.get()); + + return ZRes; +} + +Expect WasmEdgeZlibGZWrite::body(const Runtime::CallingFrame &Frame, + uint32_t GZFile, uint32_t BufPtr, + uint32_t Len) { + + const auto GZFileIt = Env.GZFileMap.find(GZFile); + if (GZFileIt == Env.GZFileMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto *Buf = MemInst->getPointer(BufPtr); + + auto ZRes = gzwrite(GZFileIt->second.get(), Buf, Len); + + return ZRes; +} + +Expect WasmEdgeZlibGZFwrite::body(const Runtime::CallingFrame &Frame, + uint32_t BufPtr, uint32_t Size, + uint32_t NItems, uint32_t GZFile) { + + const auto GZFileIt = Env.GZFileMap.find(GZFile); + if (GZFileIt == Env.GZFileMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto *Buf = MemInst->getPointer(BufPtr); + + auto ZRes = gzfwrite(Buf, Size, NItems, GZFileIt->second.get()); + + return ZRes; +} + } // namespace Host } // namespace WasmEdge diff --git a/plugins/wasmedge_zlib/zlibfunc.h b/plugins/wasmedge_zlib/zlibfunc.h index cb65493831e4..ad371ed03aaf 100644 --- a/plugins/wasmedge_zlib/zlibfunc.h +++ b/plugins/wasmedge_zlib/zlibfunc.h @@ -327,5 +327,29 @@ class WasmEdgeZlibGZRead : public WasmEdgeZlib { uint32_t BufPtr, uint32_t Len); }; +class WasmEdgeZlibGZFread : public WasmEdgeZlib { +public: + WasmEdgeZlibGZFread(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t BufPtr, + uint32_t Size, uint32_t NItems, uint32_t GZFile); +}; + +class WasmEdgeZlibGZWrite : public WasmEdgeZlib { +public: + WasmEdgeZlibGZWrite(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile, + uint32_t BufPtr, uint32_t Len); +}; + +class WasmEdgeZlibGZFwrite : public WasmEdgeZlib { +public: + WasmEdgeZlibGZFwrite(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t BufPtr, + uint32_t Size, uint32_t NItems, uint32_t GZFile); +}; + } // namespace Host } // namespace WasmEdge From 08725d480c8443d42c9bb371fbcb33c50b8d24c8 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Fri, 25 Aug 2023 03:32:04 +0530 Subject: [PATCH 60/98] Added gzputs, gzgets, gzputc, gzgetc. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 33 +++++++++++++++++++++++++ plugins/wasmedge_zlib/zlibfunc.h | 39 ++++++++++++++++++++++++++++++ 2 files changed, 72 insertions(+) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index e7a280b2bb22..450f69281818 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -859,5 +859,38 @@ Expect WasmEdgeZlibGZFwrite::body(const Runtime::CallingFrame &Frame, return ZRes; } +Expect WasmEdgeZlibGZPuts::body(const Runtime::CallingFrame &Frame, + uint32_t GZFile, uint32_t StringPtr) { + + const auto GZFileIt = Env.GZFileMap.find(GZFile); + if (GZFileIt == Env.GZFileMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto *String = MemInst->getPointer(StringPtr); + + auto ZRes = gzputs(GZFileIt->second.get(), String); + + return ZRes; +} + +Expect WasmEdgeZlibGZPutc::body(const Runtime::CallingFrame &Frame, + uint32_t GZFile, int32_t C) { + + const auto GZFileIt = Env.GZFileMap.find(GZFile); + if (GZFileIt == Env.GZFileMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto ZRes = gzgetc(GZFileIt->second.get()); + + return ZRes; +} + } // namespace Host } // namespace WasmEdge diff --git a/plugins/wasmedge_zlib/zlibfunc.h b/plugins/wasmedge_zlib/zlibfunc.h index ad371ed03aaf..b63fd44872d9 100644 --- a/plugins/wasmedge_zlib/zlibfunc.h +++ b/plugins/wasmedge_zlib/zlibfunc.h @@ -351,5 +351,44 @@ class WasmEdgeZlibGZFwrite : public WasmEdgeZlib { uint32_t Size, uint32_t NItems, uint32_t GZFile); }; +/* class WasmEdgeZlibGZPrintf : public WasmEdgeZlib { +public: + WasmEdgeZlibGZPrintf(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t BufPtr, + uint32_t Size, uint32_t NItems, uint32_t GZFile); +}; */ + +class WasmEdgeZlibGZPuts : public WasmEdgeZlib { +public: + WasmEdgeZlibGZPuts(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile, + uint32_t StringPtr); +}; + +class WasmEdgeZlibGZGets : public WasmEdgeZlib { +public: + WasmEdgeZlibGZGets(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile, + uint32_t BufPtr, int32_t Len); +}; + +class WasmEdgeZlibGZPutc : public WasmEdgeZlib { +public: + WasmEdgeZlibGZPutc(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile, + int32_t C); +}; + +class WasmEdgeZlibGZGetc : public WasmEdgeZlib { +public: + WasmEdgeZlibGZGetc(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile); +}; + } // namespace Host } // namespace WasmEdge From 9da46e01fe3f8be30b536499de407a473e43ef7a Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Fri, 25 Aug 2023 03:43:26 +0530 Subject: [PATCH 61/98] Added gzflush & gzrewind Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 26 ++++++++++++++++++++++++++ plugins/wasmedge_zlib/zlibfunc.h | 23 +++++++++++++++++++++++ 2 files changed, 49 insertions(+) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 450f69281818..e158c7220aa9 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -892,5 +892,31 @@ Expect WasmEdgeZlibGZPutc::body(const Runtime::CallingFrame &Frame, return ZRes; } +Expect WasmEdgeZlibGZFlush::body(const Runtime::CallingFrame &Frame, + uint32_t GZFile, int32_t Flush) { + + const auto GZFileIt = Env.GZFileMap.find(GZFile); + if (GZFileIt == Env.GZFileMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto ZRes = gzflush(GZFileIt->second.get(), Flush); + + return ZRes; +} + +Expect WasmEdgeZlibGZRewind::body(const Runtime::CallingFrame &Frame, + uint32_t GZFile) { + + const auto GZFileIt = Env.GZFileMap.find(GZFile); + if (GZFileIt == Env.GZFileMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto ZRes = gzrewind(GZFileIt->second.get()); + + return ZRes; +} + } // namespace Host } // namespace WasmEdge diff --git a/plugins/wasmedge_zlib/zlibfunc.h b/plugins/wasmedge_zlib/zlibfunc.h index b63fd44872d9..e8e79a2394f6 100644 --- a/plugins/wasmedge_zlib/zlibfunc.h +++ b/plugins/wasmedge_zlib/zlibfunc.h @@ -390,5 +390,28 @@ class WasmEdgeZlibGZGetc : public WasmEdgeZlib { Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile); }; +class WasmEdgeZlibGZUngetc : public WasmEdgeZlib { +public: + WasmEdgeZlibGZUngetc(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, int32_t C, + uint32_t GZFile); +}; + +class WasmEdgeZlibGZFlush : public WasmEdgeZlib { +public: + WasmEdgeZlibGZFlush(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile, + int32_t Flush); +}; + +class WasmEdgeZlibGZRewind : public WasmEdgeZlib { +public: + WasmEdgeZlibGZRewind(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile); +}; + } // namespace Host } // namespace WasmEdge From 44689d86bf46e429ad6d22683c3ea5fa582598bf Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Fri, 25 Aug 2023 03:45:05 +0530 Subject: [PATCH 62/98] Remove unused parameter 'Frame'. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index e158c7220aa9..87f5e18e087b 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -747,7 +747,7 @@ Expect WasmEdgeZlibGZDOpen::body(const Runtime::CallingFrame &Frame, return NewWasmGZFile; } -Expect WasmEdgeZlibGZBuffer::body(const Runtime::CallingFrame &Frame, +Expect WasmEdgeZlibGZBuffer::body(const Runtime::CallingFrame &, uint32_t GZFile, uint32_t Size) { const auto GZFileIt = Env.GZFileMap.find(GZFile); @@ -760,10 +760,9 @@ Expect WasmEdgeZlibGZBuffer::body(const Runtime::CallingFrame &Frame, return ZRes; } -Expect -WasmEdgeZlibGZSetParams::body(const Runtime::CallingFrame &Frame, - uint32_t GZFile, int32_t Level, - int32_t Strategy) { +Expect WasmEdgeZlibGZSetParams::body(const Runtime::CallingFrame &, + uint32_t GZFile, int32_t Level, + int32_t Strategy) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { @@ -879,7 +878,7 @@ Expect WasmEdgeZlibGZPuts::body(const Runtime::CallingFrame &Frame, return ZRes; } -Expect WasmEdgeZlibGZPutc::body(const Runtime::CallingFrame &Frame, +Expect WasmEdgeZlibGZPutc::body(const Runtime::CallingFrame &, uint32_t GZFile, int32_t C) { const auto GZFileIt = Env.GZFileMap.find(GZFile); @@ -892,7 +891,7 @@ Expect WasmEdgeZlibGZPutc::body(const Runtime::CallingFrame &Frame, return ZRes; } -Expect WasmEdgeZlibGZFlush::body(const Runtime::CallingFrame &Frame, +Expect WasmEdgeZlibGZFlush::body(const Runtime::CallingFrame &, uint32_t GZFile, int32_t Flush) { const auto GZFileIt = Env.GZFileMap.find(GZFile); @@ -905,7 +904,7 @@ Expect WasmEdgeZlibGZFlush::body(const Runtime::CallingFrame &Frame, return ZRes; } -Expect WasmEdgeZlibGZRewind::body(const Runtime::CallingFrame &Frame, +Expect WasmEdgeZlibGZRewind::body(const Runtime::CallingFrame &, uint32_t GZFile) { const auto GZFileIt = Env.GZFileMap.find(GZFile); From ae9f871b429bf8004f1a8b71df785bf0827d8d4b Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Fri, 25 Aug 2023 03:54:58 +0530 Subject: [PATCH 63/98] Added gzeof, gzdirect, gzclose, gzclose_r, gzclose_w. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 71 ++++++++++++++++++++++++++++++ plugins/wasmedge_zlib/zlibfunc.h | 34 ++++++++++++++ 2 files changed, 105 insertions(+) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 87f5e18e087b..61496a981d18 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -917,5 +917,76 @@ Expect WasmEdgeZlibGZRewind::body(const Runtime::CallingFrame &, return ZRes; } +Expect WasmEdgeZlibGZEof::body(const Runtime::CallingFrame &, + uint32_t GZFile) { + + const auto GZFileIt = Env.GZFileMap.find(GZFile); + if (GZFileIt == Env.GZFileMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto ZRes = gzeof(GZFileIt->second.get()); + + return ZRes; +} + +Expect WasmEdgeZlibGZDirect::body(const Runtime::CallingFrame &, + uint32_t GZFile) { + + const auto GZFileIt = Env.GZFileMap.find(GZFile); + if (GZFileIt == Env.GZFileMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto ZRes = gzdirect(GZFileIt->second.get()); + + return ZRes; +} + +Expect WasmEdgeZlibGZDirect::body(const Runtime::CallingFrame &, + uint32_t GZFile) { + + const auto GZFileIt = Env.GZFileMap.find(GZFile); + if (GZFileIt == Env.GZFileMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto ZRes = gzclose(GZFileIt->second.get()); + + Env.GZFileMap.erase(GZFileIt); + + return ZRes; +} + +Expect WasmEdgeZlibGZClose_r::body(const Runtime::CallingFrame &, + uint32_t GZFile) { + + const auto GZFileIt = Env.GZFileMap.find(GZFile); + if (GZFileIt == Env.GZFileMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto ZRes = gzclose_r(GZFileIt->second.get()); + + Env.GZFileMap.erase(GZFileIt); + + return ZRes; +} + +Expect WasmEdgeZlibGZClose_w::body(const Runtime::CallingFrame &, + uint32_t GZFile) { + + const auto GZFileIt = Env.GZFileMap.find(GZFile); + if (GZFileIt == Env.GZFileMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto ZRes = gzclose_w(GZFileIt->second.get()); + + Env.GZFileMap.erase(GZFileIt); + + return ZRes; +} + } // namespace Host } // namespace WasmEdge diff --git a/plugins/wasmedge_zlib/zlibfunc.h b/plugins/wasmedge_zlib/zlibfunc.h index e8e79a2394f6..79b79a41bfff 100644 --- a/plugins/wasmedge_zlib/zlibfunc.h +++ b/plugins/wasmedge_zlib/zlibfunc.h @@ -413,5 +413,39 @@ class WasmEdgeZlibGZRewind : public WasmEdgeZlib { Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile); }; +class WasmEdgeZlibGZEof : public WasmEdgeZlib { +public: + WasmEdgeZlibGZEof(WasmEdgeZlibEnvironment &HostEnv) : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile); +}; + +class WasmEdgeZlibGZDirect : public WasmEdgeZlib { +public: + WasmEdgeZlibGZDirect(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile); +}; + +class WasmEdgeZlibGZClose : public WasmEdgeZlib { +public: + WasmEdgeZlibGZClose(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile); +}; + +class WasmEdgeZlibGZClose_r : public WasmEdgeZlib { +public: + WasmEdgeZlibGZClose_r(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile); +}; + +class WasmEdgeZlibGZClose_w : public WasmEdgeZlib { +public: + WasmEdgeZlibGZClose_w(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile); +}; + } // namespace Host } // namespace WasmEdge From 429bda7dead85360841f03dbf8598bce4f3bc780 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Fri, 25 Aug 2023 04:04:31 +0530 Subject: [PATCH 64/98] Added gzclearerr. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 11 +++++++++++ plugins/wasmedge_zlib/zlibfunc.h | 14 ++++++++++++++ 2 files changed, 25 insertions(+) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 61496a981d18..6a7218531009 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -988,5 +988,16 @@ Expect WasmEdgeZlibGZClose_w::body(const Runtime::CallingFrame &, return ZRes; } +Expect WasmEdgeZlibGZClearerr::body(const Runtime::CallingFrame &, + uint32_t GZFile) { + + const auto GZFileIt = Env.GZFileMap.find(GZFile); + if (GZFileIt == Env.GZFileMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + gzclearerr(GZFileIt->second.get()); +} + } // namespace Host } // namespace WasmEdge diff --git a/plugins/wasmedge_zlib/zlibfunc.h b/plugins/wasmedge_zlib/zlibfunc.h index 79b79a41bfff..67dafbb3729f 100644 --- a/plugins/wasmedge_zlib/zlibfunc.h +++ b/plugins/wasmedge_zlib/zlibfunc.h @@ -447,5 +447,19 @@ class WasmEdgeZlibGZClose_w : public WasmEdgeZlib { Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile); }; +/* class WasmEdgeZlibGZError : public WasmEdgeZlib { +public: + WasmEdgeZlibGZError(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile); +}; */ + +class WasmEdgeZlibGZClearerr : public WasmEdgeZlib { +public: + WasmEdgeZlibGZClearerr(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile); +}; + } // namespace Host } // namespace WasmEdge From 5e3f68649b97f4f67d16d4871a2eade552c86217 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Fri, 25 Aug 2023 04:28:42 +0530 Subject: [PATCH 65/98] Change void* to unsigned char* Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 6a7218531009..8fee073c6bc0 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -788,7 +788,7 @@ Expect WasmEdgeZlibGZRead::body(const Runtime::CallingFrame &Frame, return Unexpect(ErrCode::Value::HostFuncError); } - auto *Buf = MemInst->getPointer(BufPtr); + auto *Buf = MemInst->getPointer(BufPtr); auto ZRes = gzread(GZFileIt->second.get(), Buf, Len); @@ -809,7 +809,7 @@ Expect WasmEdgeZlibGZFread::body(const Runtime::CallingFrame &Frame, return Unexpect(ErrCode::Value::HostFuncError); } - auto *Buf = MemInst->getPointer(BufPtr); + auto *Buf = MemInst->getPointer(BufPtr); auto ZRes = gzfread(Buf, Size, NItems, GZFileIt->second.get()); @@ -830,7 +830,7 @@ Expect WasmEdgeZlibGZWrite::body(const Runtime::CallingFrame &Frame, return Unexpect(ErrCode::Value::HostFuncError); } - auto *Buf = MemInst->getPointer(BufPtr); + auto *Buf = MemInst->getPointer(BufPtr); auto ZRes = gzwrite(GZFileIt->second.get(), Buf, Len); @@ -851,7 +851,7 @@ Expect WasmEdgeZlibGZFwrite::body(const Runtime::CallingFrame &Frame, return Unexpect(ErrCode::Value::HostFuncError); } - auto *Buf = MemInst->getPointer(BufPtr); + auto *Buf = MemInst->getPointer(BufPtr); auto ZRes = gzfwrite(Buf, Size, NItems, GZFileIt->second.get()); From c18a1040a8636cec084c7b7b8af30175332eee2b Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Sat, 26 Aug 2023 02:38:39 +0530 Subject: [PATCH 66/98] Added gzgetc & gzungetc. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 26 ++++++++++++++++++++++++++ plugins/wasmedge_zlib/zlibfunc.h | 4 ++-- 2 files changed, 28 insertions(+), 2 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 8fee073c6bc0..00eed66e0056 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -886,11 +886,37 @@ Expect WasmEdgeZlibGZPutc::body(const Runtime::CallingFrame &, return Unexpect(ErrCode::Value::HostFuncError); } + auto ZRes = gzputc(GZFileIt->second.get(), C); + + return ZRes; +} + +Expect WasmEdgeZlibGZGetc::body(const Runtime::CallingFrame &, + uint32_t GZFile) { + + const auto GZFileIt = Env.GZFileMap.find(GZFile); + if (GZFileIt == Env.GZFileMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + auto ZRes = gzgetc(GZFileIt->second.get()); return ZRes; } +Expect WasmEdgeZlibGZUngetc::body(const Runtime::CallingFrame &, + int32_t C, uint32_t GZFile) { + + const auto GZFileIt = Env.GZFileMap.find(GZFile); + if (GZFileIt == Env.GZFileMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto ZRes = gzungetc(C, GZFileIt->second.get()); + + return ZRes; +} + Expect WasmEdgeZlibGZFlush::body(const Runtime::CallingFrame &, uint32_t GZFile, int32_t Flush) { diff --git a/plugins/wasmedge_zlib/zlibfunc.h b/plugins/wasmedge_zlib/zlibfunc.h index 67dafbb3729f..cd59570cfbd6 100644 --- a/plugins/wasmedge_zlib/zlibfunc.h +++ b/plugins/wasmedge_zlib/zlibfunc.h @@ -367,13 +367,13 @@ class WasmEdgeZlibGZPuts : public WasmEdgeZlib { uint32_t StringPtr); }; -class WasmEdgeZlibGZGets : public WasmEdgeZlib { +/* class WasmEdgeZlibGZGets : public WasmEdgeZlib { public: WasmEdgeZlibGZGets(WasmEdgeZlibEnvironment &HostEnv) : WasmEdgeZlib(HostEnv) {} Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile, uint32_t BufPtr, int32_t Len); -}; +}; */ class WasmEdgeZlibGZPutc : public WasmEdgeZlib { public: From ab3d3e0432035c37840ae1dfd9b18f8b09c633b8 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Sat, 26 Aug 2023 02:39:45 +0530 Subject: [PATCH 67/98] Fix name Spell mistake. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 00eed66e0056..d5d21a59b4fd 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -969,8 +969,8 @@ Expect WasmEdgeZlibGZDirect::body(const Runtime::CallingFrame &, return ZRes; } -Expect WasmEdgeZlibGZDirect::body(const Runtime::CallingFrame &, - uint32_t GZFile) { +Expect WasmEdgeZlibGZClose::body(const Runtime::CallingFrame &, + uint32_t GZFile) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { From 643e32d8860f1e96be04465f0415a1d551c5f222 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Wed, 30 Aug 2023 20:21:55 +0530 Subject: [PATCH 68/98] Fixed no-return on a Expect. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index d5d21a59b4fd..7c6079a22b2d 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -1023,6 +1023,8 @@ Expect WasmEdgeZlibGZClearerr::body(const Runtime::CallingFrame &, } gzclearerr(GZFileIt->second.get()); + + return Expect{}; } } // namespace Host From 21a6c6a922dce874134868c1be0c3f610ed2c1e0 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Wed, 30 Aug 2023 22:20:25 +0530 Subject: [PATCH 69/98] Fix move semantics related to unique_ptr. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 7c6079a22b2d..f0e9cdae968d 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -741,10 +741,13 @@ Expect WasmEdgeZlibGZDOpen::body(const Runtime::CallingFrame &Frame, auto ZRes = gzdopen(FD, Mode); const auto NewWasmGZFile = WasmGZFileStart + Env.GZFileMap.size(); - Env.GZFileMap.emplace(std::pair>{ - NewWasmGZFile, std::make_unique(ZRes)}); + auto El = + std::pair>( + NewWasmGZFile, ZRes); - return NewWasmGZFile; + Env.GZFileMap.emplace(std::move(El)); + + return 0; } Expect WasmEdgeZlibGZBuffer::body(const Runtime::CallingFrame &, From c83cb6ee29079f598d95c323c2791b27e51143f6 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Thu, 31 Aug 2023 04:21:17 +0530 Subject: [PATCH 70/98] Added deflateInit2 & inflateInit2 & inflateBackInit2 & Refactor Part 1. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 223 ++++++++++++++++++++++------- plugins/wasmedge_zlib/zlibfunc.h | 81 ++++++++--- 2 files changed, 232 insertions(+), 72 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index f0e9cdae968d..1ebb7dfaa6c1 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -20,6 +20,10 @@ template auto SyncRun(z_stream *HostZStream, uint32_t ZStreamPtr, const Runtime::CallingFrame &Frame, T Callback) { auto *MemInst = Frame.getMemoryByIndex(0); + /* if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } */ + WasmZStream *ModuleZStream = MemInst->getPointer(ZStreamPtr); HostZStream->next_in = @@ -65,29 +69,17 @@ auto SyncRun(z_stream *HostZStream, uint32_t ZStreamPtr, } Expect -WasmEdgeZlibDeflateInit_::body(const Runtime::CallingFrame &Frame, - uint32_t ZStreamPtr, int32_t Level, - uint32_t VersionPtr, int32_t StreamSize) { - - auto *MemInst = Frame.getMemoryByIndex(0); - if (MemInst == nullptr) { - return Unexpect(ErrCode::Value::HostFuncError); - } - - const auto *WasmZlibVersion = MemInst->getPointer(VersionPtr); - if (!CheckSize(StreamSize)) - return static_cast(Z_VERSION_ERROR); +WasmEdgeZlibDeflateInit::body(const Runtime::CallingFrame &Frame, + uint32_t ZStreamPtr, int32_t Level) { auto HostZStream = std::make_unique(); - HostZStream.get()->zalloc = Z_NULL; HostZStream.get()->zfree = Z_NULL; HostZStream.get()->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { - return deflateInit_(HostZStream.get(), Level, WasmZlibVersion, - sizeof(z_stream)); + return deflateInit(HostZStream.get(), Level); }); if (ZRes == Z_OK) @@ -96,39 +88,23 @@ WasmEdgeZlibDeflateInit_::body(const Runtime::CallingFrame &Frame, return ZRes; } -Expect -WasmEdgeZlibInflateInit_::body(const Runtime::CallingFrame &Frame, - uint32_t ZStreamPtr, uint32_t VersionPtr, - int32_t StreamSize) { +Expect WasmEdgeZlibDeflate::WasmEdgeZlibDeflate::body( + const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t Flush) { - auto *MemInst = Frame.getMemoryByIndex(0); - if (MemInst == nullptr) { + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); } - const auto *WasmZlibVersion = MemInst->getPointer(VersionPtr); - if (!CheckSize(StreamSize)) - return static_cast(Z_VERSION_ERROR); - - auto HostZStream = std::make_unique(); - - HostZStream.get()->zalloc = Z_NULL; - HostZStream.get()->zfree = Z_NULL; - HostZStream.get()->opaque = - Z_NULL; // ignore opaque since zmalloc and zfree was ignored - - const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { - return inflateInit_(HostZStream.get(), WasmZlibVersion, sizeof(z_stream)); - }); - - if (ZRes == Z_OK) - Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); + const int32_t ZRes = + SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, + [&]() { return deflate(HostZStreamIt->second.get(), Flush); }); return ZRes; } -Expect WasmEdgeZlibDeflate::WasmEdgeZlibDeflate::body( - const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t Flush) { +Expect WasmEdgeZlibDeflateEnd::body(const Runtime::CallingFrame &Frame, + uint32_t ZStreamPtr) { const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); if (HostZStreamIt == Env.ZStreamMap.end()) { @@ -137,7 +113,30 @@ Expect WasmEdgeZlibDeflate::WasmEdgeZlibDeflate::body( const int32_t ZRes = SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, - [&]() { return deflate(HostZStreamIt->second.get(), Flush); }); + [&]() { return deflateEnd(HostZStreamIt->second.get()); }); + + if (ZRes == Z_OK) + Env.ZStreamMap.erase(ZStreamPtr); + + return ZRes; +} + +Expect +WasmEdgeZlibInflateInit::body(const Runtime::CallingFrame &Frame, + uint32_t ZStreamPtr) { + + auto HostZStream = std::make_unique(); + HostZStream.get()->zalloc = Z_NULL; + HostZStream.get()->zfree = Z_NULL; + HostZStream.get()->opaque = + Z_NULL; // ignore opaque since zmalloc and zfree was ignored + + const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { + return inflateInit(HostZStream.get()); + }); + + if (ZRes == Z_OK) + Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); return ZRes; } @@ -157,8 +156,9 @@ Expect WasmEdgeZlibInflate::body(const Runtime::CallingFrame &Frame, return ZRes; } -Expect WasmEdgeZlibDeflateEnd::body(const Runtime::CallingFrame &Frame, +Expect WasmEdgeZlibInflateEnd::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr) { + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); if (HostZStreamIt == Env.ZStreamMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); @@ -166,25 +166,30 @@ Expect WasmEdgeZlibDeflateEnd::body(const Runtime::CallingFrame &Frame, const int32_t ZRes = SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, - [&]() { return deflateEnd(HostZStreamIt->second.get()); }); + [&]() { return inflateEnd(HostZStreamIt->second.get()); }); Env.ZStreamMap.erase(ZStreamPtr); return ZRes; } -Expect WasmEdgeZlibInflateEnd::body(const Runtime::CallingFrame &Frame, - uint32_t ZStreamPtr) { - const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); - if (HostZStreamIt == Env.ZStreamMap.end()) { - return Unexpect(ErrCode::Value::HostFuncError); - } +Expect WasmEdgeZlibDeflateInit2::body( + const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t Level, + int32_t Method, int32_t WindowBits, int32_t MemLevel, int32_t Strategy) { - const int32_t ZRes = - SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, - [&]() { return inflateEnd(HostZStreamIt->second.get()); }); + auto HostZStream = std::make_unique(); + HostZStream.get()->zalloc = Z_NULL; + HostZStream.get()->zfree = Z_NULL; + HostZStream.get()->opaque = + Z_NULL; // ignore opaque since zmalloc and zfree was ignored - Env.ZStreamMap.erase(ZStreamPtr); + const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { + return deflateInit2(HostZStream.get(), Level, Method, WindowBits, MemLevel, + Strategy); + }); + + if (ZRes == Z_OK) + Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); return ZRes; } @@ -382,6 +387,26 @@ WasmEdgeZlibDeflatePrime::body(const Runtime::CallingFrame &Frame, return ZRes; } +Expect +WasmEdgeZlibInflateInit2::body(const Runtime::CallingFrame &Frame, + uint32_t ZStreamPtr, int32_t WindowBits) { + + auto HostZStream = std::make_unique(); + HostZStream.get()->zalloc = Z_NULL; + HostZStream.get()->zfree = Z_NULL; + HostZStream.get()->opaque = + Z_NULL; // ignore opaque since zmalloc and zfree was ignored + + const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { + return inflateInit2(HostZStream.get(), WindowBits); + }); + + if (ZRes == Z_OK) + Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); + + return ZRes; +} + Expect WasmEdgeZlibInflateSetDictionary::body( const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, uint32_t DictionaryPtr, uint32_t DictLength) { @@ -539,6 +564,34 @@ WasmEdgeZlibInflateMark::body(const Runtime::CallingFrame &Frame, return ZRes; } +Expect +WasmEdgeZlibInflateBackInit::body(const Runtime::CallingFrame &Frame, + uint32_t ZStreamPtr, int32_t WindowBits, + uint32_t WindowPtr) { + + auto HostZStream = std::make_unique(); + HostZStream.get()->zalloc = Z_NULL; + HostZStream.get()->zfree = Z_NULL; + HostZStream.get()->opaque = + Z_NULL; // ignore opaque since zmalloc and zfree was ignored + + auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto *Window = MemInst->getPointer(WindowPtr); + + const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { + return inflateBackInit(HostZStream.get(), WindowBits, Window); + }); + + if (ZRes == Z_OK) + Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); + + return ZRes; +} + Expect WasmEdgeZlibInflateBackEnd::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr) { @@ -558,8 +611,8 @@ WasmEdgeZlibInflateBackEnd::body(const Runtime::CallingFrame &Frame, Expect WasmEdgeZlibZlibCompilerFlags::body(const Runtime::CallingFrame &) { - const int32_t ZRes = zlibCompileFlags(); + const int32_t ZRes = zlibCompileFlags(); return ZRes; } @@ -1030,5 +1083,67 @@ Expect WasmEdgeZlibGZClearerr::body(const Runtime::CallingFrame &, return Expect{}; } +Expect +WasmEdgeZlibDeflateInit_::body(const Runtime::CallingFrame &Frame, + uint32_t ZStreamPtr, int32_t Level, + uint32_t VersionPtr, int32_t StreamSize) { + auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + const auto *WasmZlibVersion = MemInst->getPointer(VersionPtr); + if (!CheckSize(StreamSize)) + return static_cast(Z_VERSION_ERROR); + + auto HostZStream = std::make_unique(); + + HostZStream.get()->zalloc = Z_NULL; + HostZStream.get()->zfree = Z_NULL; + HostZStream.get()->opaque = + Z_NULL; // ignore opaque since zmalloc and zfree was ignored + + const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { + return deflateInit_(HostZStream.get(), Level, WasmZlibVersion, + sizeof(z_stream)); + }); + + if (ZRes == Z_OK) + Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); + + return ZRes; +} + +Expect +WasmEdgeZlibInflateInit_::body(const Runtime::CallingFrame &Frame, + uint32_t ZStreamPtr, uint32_t VersionPtr, + int32_t StreamSize) { + + auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + const auto *WasmZlibVersion = MemInst->getPointer(VersionPtr); + if (!CheckSize(StreamSize)) + return static_cast(Z_VERSION_ERROR); + + auto HostZStream = std::make_unique(); + + HostZStream.get()->zalloc = Z_NULL; + HostZStream.get()->zfree = Z_NULL; + HostZStream.get()->opaque = + Z_NULL; // ignore opaque since zmalloc and zfree was ignored + + const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { + return inflateInit_(HostZStream.get(), WasmZlibVersion, sizeof(z_stream)); + }); + + if (ZRes == Z_OK) + Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); + + return ZRes; +} + } // namespace Host } // namespace WasmEdge diff --git a/plugins/wasmedge_zlib/zlibfunc.h b/plugins/wasmedge_zlib/zlibfunc.h index cd59570cfbd6..1f6609f2abf3 100644 --- a/plugins/wasmedge_zlib/zlibfunc.h +++ b/plugins/wasmedge_zlib/zlibfunc.h @@ -8,20 +8,18 @@ namespace WasmEdge { namespace Host { -class WasmEdgeZlibDeflateInit_ : public WasmEdgeZlib { -public: - WasmEdgeZlibDeflateInit_(WasmEdgeZlibEnvironment &HostEnv) - : WasmEdgeZlib(HostEnv) {} - Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, - int32_t Level, uint32_t VersionPtr, int32_t StreamSize); -}; +/* class WasmEdgeZlibZlibVersion : public WasmEdgeZlib +{ public: WasmEdgeZlibZlibVersion(WasmEdgeZlibEnvironment &HostEnv) : +WasmEdgeZlib(HostEnv) {} Expect body(const Runtime::CallingFrame +&Frame); +}; */ -class WasmEdgeZlibInflateInit_ : public WasmEdgeZlib { +class WasmEdgeZlibDeflateInit : public WasmEdgeZlib { public: - WasmEdgeZlibInflateInit_(WasmEdgeZlibEnvironment &HostEnv) + WasmEdgeZlibDeflateInit(WasmEdgeZlibEnvironment &HostEnv) : WasmEdgeZlib(HostEnv) {} Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, - uint32_t VersionPtr, int32_t StreamSize); + int32_t Level); }; class WasmEdgeZlibDeflate : public WasmEdgeZlib { @@ -32,6 +30,20 @@ class WasmEdgeZlibDeflate : public WasmEdgeZlib { int32_t Flush); }; +class WasmEdgeZlibDeflateEnd : public WasmEdgeZlib { +public: + WasmEdgeZlibDeflateEnd(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr); +}; + +class WasmEdgeZlibInflateInit : public WasmEdgeZlib { +public: + WasmEdgeZlibInflateInit(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr); +}; + class WasmEdgeZlibInflate : public WasmEdgeZlib { public: WasmEdgeZlibInflate(WasmEdgeZlibEnvironment &HostEnv) @@ -40,18 +52,20 @@ class WasmEdgeZlibInflate : public WasmEdgeZlib { int32_t Flush); }; -class WasmEdgeZlibDeflateEnd : public WasmEdgeZlib { +class WasmEdgeZlibInflateEnd : public WasmEdgeZlib { public: - WasmEdgeZlibDeflateEnd(WasmEdgeZlibEnvironment &HostEnv) + WasmEdgeZlibInflateEnd(WasmEdgeZlibEnvironment &HostEnv) : WasmEdgeZlib(HostEnv) {} Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr); }; -class WasmEdgeZlibInflateEnd : public WasmEdgeZlib { +class WasmEdgeZlibDeflateInit2 : public WasmEdgeZlib { public: - WasmEdgeZlibInflateEnd(WasmEdgeZlibEnvironment &HostEnv) + WasmEdgeZlibDeflateInit2(WasmEdgeZlibEnvironment &HostEnv) : WasmEdgeZlib(HostEnv) {} - Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr); + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + int32_t Level, int32_t Method, int32_t WindowBits, + int32_t MemLevel, int32_t Strategy); }; class WasmEdgeZlibDeflateSetDictionary @@ -132,6 +146,14 @@ class WasmEdgeZlibDeflatePrime : public WasmEdgeZlib { int32_t Bits, int32_t Value); }; +class WasmEdgeZlibInflateInit2 : public WasmEdgeZlib { +public: + WasmEdgeZlibInflateInit2(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + int32_t WindowBits); +}; + class WasmEdgeZlibInflateSetDictionary : public WasmEdgeZlib { public: @@ -196,14 +218,21 @@ class WasmEdgeZlibInflateMark : public WasmEdgeZlib { Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr); }; -class WasmEdgeZlibInflateBack : public WasmEdgeZlib { +class WasmEdgeZlibInflateBackInit + : public WasmEdgeZlib { public: - WasmEdgeZlibInflateBack(WasmEdgeZlibEnvironment &HostEnv) + WasmEdgeZlibInflateBackInit(WasmEdgeZlibEnvironment &HostEnv) : WasmEdgeZlib(HostEnv) {} Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, - int32_t Bits, int32_t Value); + int32_t WindowBits, uint32_t WindowPtr); }; +/* class WasmEdgeZlibInflateBack : public WasmEdgeZlib +{ public: WasmEdgeZlibInflateBack(WasmEdgeZlibEnvironment &HostEnv) : +WasmEdgeZlib(HostEnv) {} Expect body(const Runtime::CallingFrame +&Frame, uint32_t ZStreamPtr, int32_t Bits, int32_t Value); +}; */ + class WasmEdgeZlibInflateBackEnd : public WasmEdgeZlib { public: @@ -461,5 +490,21 @@ class WasmEdgeZlibGZClearerr : public WasmEdgeZlib { Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile); }; +class WasmEdgeZlibDeflateInit_ : public WasmEdgeZlib { +public: + WasmEdgeZlibDeflateInit_(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + int32_t Level, uint32_t VersionPtr, int32_t StreamSize); +}; + +class WasmEdgeZlibInflateInit_ : public WasmEdgeZlib { +public: + WasmEdgeZlibInflateInit_(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + uint32_t VersionPtr, int32_t StreamSize); +}; + } // namespace Host } // namespace WasmEdge From 87b26fa532228440302a5bb35655a907c013ca32 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Thu, 31 Aug 2023 04:48:03 +0530 Subject: [PATCH 71/98] Added gzopen | gzseek | gztell | gzoffset | adler32_combine | crc32_combine & Refactor Part 2 Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 182 ++++++++++++++++++++--------- plugins/wasmedge_zlib/zlibfunc.h | 104 ++++++++++++----- 2 files changed, 207 insertions(+), 79 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 1ebb7dfaa6c1..4985c057df5a 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -717,68 +717,27 @@ WasmEdgeZlibUncompress2::body(const Runtime::CallingFrame &Frame, return ZRes; } -Expect WasmEdgeZlibAdler32::body(const Runtime::CallingFrame &Frame, - uint32_t Adler, uint32_t BufPtr, - uint32_t Len) { +Expect WasmEdgeZlibGZOpen::body(const Runtime::CallingFrame &Frame, + uint32_t PathPtr, uint32_t ModePtr) { auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { return Unexpect(ErrCode::Value::HostFuncError); } - auto *Buf = MemInst->getPointer(BufPtr); - - const int32_t ZRes = adler32(Adler, Buf, Len); - - return ZRes; -} - -Expect WasmEdgeZlibAdler32_z::body(const Runtime::CallingFrame &Frame, - uint32_t Adler, uint32_t BufPtr, - uint32_t Len) { - - auto *MemInst = Frame.getMemoryByIndex(0); - if (MemInst == nullptr) { - return Unexpect(ErrCode::Value::HostFuncError); - } - - auto *Buf = MemInst->getPointer(BufPtr); - - const int32_t ZRes = adler32_z(Adler, Buf, Len); - - return ZRes; -} - -Expect WasmEdgeZlibCRC32::body(const Runtime::CallingFrame &Frame, - uint32_t CRC, uint32_t BufPtr, - uint32_t Len) { - - auto *MemInst = Frame.getMemoryByIndex(0); - if (MemInst == nullptr) { - return Unexpect(ErrCode::Value::HostFuncError); - } - - auto *Buf = MemInst->getPointer(BufPtr); - - const int32_t ZRes = crc32(CRC, Buf, Len); - - return ZRes; -} - -Expect WasmEdgeZlibCRC32_z::body(const Runtime::CallingFrame &Frame, - uint32_t CRC, uint32_t BufPtr, - uint32_t Len) { + auto *Path = MemInst->getPointer(PathPtr); + auto *Mode = MemInst->getPointer(ModePtr); - auto *MemInst = Frame.getMemoryByIndex(0); - if (MemInst == nullptr) { - return Unexpect(ErrCode::Value::HostFuncError); - } + auto ZRes = gzopen(Path, Mode); - auto *Buf = MemInst->getPointer(BufPtr); + const auto NewWasmGZFile = WasmGZFileStart + Env.GZFileMap.size(); + auto El = + std::pair>( + NewWasmGZFile, ZRes); - const int32_t ZRes = crc32_z(CRC, Buf, Len); + Env.GZFileMap.emplace(std::move(El)); - return ZRes; + return 0; } Expect WasmEdgeZlibGZDOpen::body(const Runtime::CallingFrame &Frame, @@ -986,6 +945,20 @@ Expect WasmEdgeZlibGZFlush::body(const Runtime::CallingFrame &, return ZRes; } +Expect WasmEdgeZlibGZSeek::body(const Runtime::CallingFrame &, + uint32_t GZFile, int32_t Offset, + int32_t Whence) { + + const auto GZFileIt = Env.GZFileMap.find(GZFile); + if (GZFileIt == Env.GZFileMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto ZRes = gzseek(GZFileIt->second.get(), Offset, Whence); + + return ZRes; +} + Expect WasmEdgeZlibGZRewind::body(const Runtime::CallingFrame &, uint32_t GZFile) { @@ -999,6 +972,32 @@ Expect WasmEdgeZlibGZRewind::body(const Runtime::CallingFrame &, return ZRes; } +Expect WasmEdgeZlibGZTell::body(const Runtime::CallingFrame &, + uint32_t GZFile) { + + const auto GZFileIt = Env.GZFileMap.find(GZFile); + if (GZFileIt == Env.GZFileMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto ZRes = gztell(GZFileIt->second.get()); + + return ZRes; +} + +Expect WasmEdgeZlibGZOffset::body(const Runtime::CallingFrame &, + uint32_t GZFile) { + + const auto GZFileIt = Env.GZFileMap.find(GZFile); + if (GZFileIt == Env.GZFileMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto ZRes = gzoffset(GZFileIt->second.get()); + + return ZRes; +} + Expect WasmEdgeZlibGZEof::body(const Runtime::CallingFrame &, uint32_t GZFile) { @@ -1083,6 +1082,85 @@ Expect WasmEdgeZlibGZClearerr::body(const Runtime::CallingFrame &, return Expect{}; } +Expect WasmEdgeZlibAdler32::body(const Runtime::CallingFrame &Frame, + uint32_t Adler, uint32_t BufPtr, + uint32_t Len) { + + auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto *Buf = MemInst->getPointer(BufPtr); + + const int32_t ZRes = adler32(Adler, Buf, Len); + return ZRes; +} + +Expect WasmEdgeZlibAdler32_z::body(const Runtime::CallingFrame &Frame, + uint32_t Adler, uint32_t BufPtr, + uint32_t Len) { + + auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto *Buf = MemInst->getPointer(BufPtr); + + const int32_t ZRes = adler32_z(Adler, Buf, Len); + return ZRes; +} + +Expect +WasmEdgeZlibAdler32Combine::body(const Runtime::CallingFrame &Frame, + uint32_t Adler1, uint32_t Adler2, + int32_t Len2) { + + const int32_t ZRes = adler32_combine(Adler1, Adler2, Len2); + return ZRes; +} + +Expect WasmEdgeZlibCRC32::body(const Runtime::CallingFrame &Frame, + uint32_t CRC, uint32_t BufPtr, + uint32_t Len) { + + auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto *Buf = MemInst->getPointer(BufPtr); + + const int32_t ZRes = crc32(CRC, Buf, Len); + + return ZRes; +} + +Expect WasmEdgeZlibCRC32_z::body(const Runtime::CallingFrame &Frame, + uint32_t CRC, uint32_t BufPtr, + uint32_t Len) { + + auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto *Buf = MemInst->getPointer(BufPtr); + + const int32_t ZRes = crc32_z(CRC, Buf, Len); + + return ZRes; +} + +Expect +WasmEdgeZlibCRC32Combine::body(const Runtime::CallingFrame &Frame, + uint32_t CRC1, uint32_t CRC2, int32_t Len2) { + + const int32_t ZRes = crc32_combine(CRC1, CRC2, Len2); + return ZRes; +} + Expect WasmEdgeZlibDeflateInit_::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t Level, diff --git a/plugins/wasmedge_zlib/zlibfunc.h b/plugins/wasmedge_zlib/zlibfunc.h index 1f6609f2abf3..c0049c63b4f8 100644 --- a/plugins/wasmedge_zlib/zlibfunc.h +++ b/plugins/wasmedge_zlib/zlibfunc.h @@ -293,35 +293,12 @@ class WasmEdgeZlibUncompress2 : public WasmEdgeZlib { uint32_t SourceLenPtr); }; -class WasmEdgeZlibAdler32 : public WasmEdgeZlib { +class WasmEdgeZlibGZOpen : public WasmEdgeZlib { public: - WasmEdgeZlibAdler32(WasmEdgeZlibEnvironment &HostEnv) + WasmEdgeZlibGZOpen(WasmEdgeZlibEnvironment &HostEnv) : WasmEdgeZlib(HostEnv) {} - Expect body(const Runtime::CallingFrame &Frame, uint32_t Adler, - uint32_t BufPtr, uint32_t Len); -}; - -class WasmEdgeZlibAdler32_z : public WasmEdgeZlib { -public: - WasmEdgeZlibAdler32_z(WasmEdgeZlibEnvironment &HostEnv) - : WasmEdgeZlib(HostEnv) {} - Expect body(const Runtime::CallingFrame &Frame, uint32_t Adler, - uint32_t BufPtr, uint32_t Len); -}; - -class WasmEdgeZlibCRC32 : public WasmEdgeZlib { -public: - WasmEdgeZlibCRC32(WasmEdgeZlibEnvironment &HostEnv) : WasmEdgeZlib(HostEnv) {} - Expect body(const Runtime::CallingFrame &Frame, uint32_t CRC, - uint32_t BufPtr, uint32_t Len); -}; - -class WasmEdgeZlibCRC32_z : public WasmEdgeZlib { -public: - WasmEdgeZlibCRC32_z(WasmEdgeZlibEnvironment &HostEnv) - : WasmEdgeZlib(HostEnv) {} - Expect body(const Runtime::CallingFrame &Frame, uint32_t CRC, - uint32_t BufPtr, uint32_t Len); + Expect body(const Runtime::CallingFrame &Frame, uint32_t PathPtr, + uint32_t ModePtr); }; class WasmEdgeZlibGZDOpen : public WasmEdgeZlib { @@ -435,6 +412,15 @@ class WasmEdgeZlibGZFlush : public WasmEdgeZlib { int32_t Flush); }; +// z_off_t --> long +class WasmEdgeZlibGZSeek : public WasmEdgeZlib { +public: + WasmEdgeZlibGZSeek(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile, + int32_t Offset, int32_t Whence); +}; + class WasmEdgeZlibGZRewind : public WasmEdgeZlib { public: WasmEdgeZlibGZRewind(WasmEdgeZlibEnvironment &HostEnv) @@ -442,6 +428,20 @@ class WasmEdgeZlibGZRewind : public WasmEdgeZlib { Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile); }; +class WasmEdgeZlibGZTell : public WasmEdgeZlib { +public: + WasmEdgeZlibGZTell(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile); +}; + +class WasmEdgeZlibGZOffset : public WasmEdgeZlib { +public: + WasmEdgeZlibGZOffset(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile); +}; + class WasmEdgeZlibGZEof : public WasmEdgeZlib { public: WasmEdgeZlibGZEof(WasmEdgeZlibEnvironment &HostEnv) : WasmEdgeZlib(HostEnv) {} @@ -490,6 +490,56 @@ class WasmEdgeZlibGZClearerr : public WasmEdgeZlib { Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile); }; +class WasmEdgeZlibAdler32 : public WasmEdgeZlib { +public: + WasmEdgeZlibAdler32(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t Adler, + uint32_t BufPtr, uint32_t Len); +}; + +class WasmEdgeZlibAdler32_z : public WasmEdgeZlib { +public: + WasmEdgeZlibAdler32_z(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t Adler, + uint32_t BufPtr, uint32_t Len); +}; + +// z_off_t --> long +class WasmEdgeZlibAdler32Combine + : public WasmEdgeZlib { +public: + WasmEdgeZlibAdler32Combine(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t Adler1, + uint32_t Adler2, int32_t Len2); +}; + +class WasmEdgeZlibCRC32 : public WasmEdgeZlib { +public: + WasmEdgeZlibCRC32(WasmEdgeZlibEnvironment &HostEnv) : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t CRC, + uint32_t BufPtr, uint32_t Len); +}; + +class WasmEdgeZlibCRC32_z : public WasmEdgeZlib { +public: + WasmEdgeZlibCRC32_z(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t CRC, + uint32_t BufPtr, uint32_t Len); +}; + +// z_off_t --> long +class WasmEdgeZlibCRC32Combine : public WasmEdgeZlib { +public: + WasmEdgeZlibCRC32Combine(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t CRC1, + uint32_t CRC2, int32_t Len2); +}; + class WasmEdgeZlibDeflateInit_ : public WasmEdgeZlib { public: WasmEdgeZlibDeflateInit_(WasmEdgeZlibEnvironment &HostEnv) From 13cff39912b6a2a15757dab0e1120cedf5d0e929 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Thu, 31 Aug 2023 05:18:31 +0530 Subject: [PATCH 72/98] Added deflateInit2_ | inflateInit2_ | inflateBackInit_. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 148 ++++++++++++++++++++++++----- plugins/wasmedge_zlib/zlibfunc.h | 31 ++++++ 2 files changed, 153 insertions(+), 26 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 4985c057df5a..6c21276a206d 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -73,9 +73,9 @@ WasmEdgeZlibDeflateInit::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t Level) { auto HostZStream = std::make_unique(); - HostZStream.get()->zalloc = Z_NULL; - HostZStream.get()->zfree = Z_NULL; - HostZStream.get()->opaque = + HostZStream->zalloc = Z_NULL; + HostZStream->zfree = Z_NULL; + HostZStream->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { @@ -126,9 +126,9 @@ WasmEdgeZlibInflateInit::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr) { auto HostZStream = std::make_unique(); - HostZStream.get()->zalloc = Z_NULL; - HostZStream.get()->zfree = Z_NULL; - HostZStream.get()->opaque = + HostZStream->zalloc = Z_NULL; + HostZStream->zfree = Z_NULL; + HostZStream->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { @@ -178,9 +178,9 @@ Expect WasmEdgeZlibDeflateInit2::body( int32_t Method, int32_t WindowBits, int32_t MemLevel, int32_t Strategy) { auto HostZStream = std::make_unique(); - HostZStream.get()->zalloc = Z_NULL; - HostZStream.get()->zfree = Z_NULL; - HostZStream.get()->opaque = + HostZStream->zalloc = Z_NULL; + HostZStream->zfree = Z_NULL; + HostZStream->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { @@ -392,9 +392,9 @@ WasmEdgeZlibInflateInit2::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t WindowBits) { auto HostZStream = std::make_unique(); - HostZStream.get()->zalloc = Z_NULL; - HostZStream.get()->zfree = Z_NULL; - HostZStream.get()->opaque = + HostZStream->zalloc = Z_NULL; + HostZStream->zfree = Z_NULL; + HostZStream->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { @@ -570,9 +570,9 @@ WasmEdgeZlibInflateBackInit::body(const Runtime::CallingFrame &Frame, uint32_t WindowPtr) { auto HostZStream = std::make_unique(); - HostZStream.get()->zalloc = Z_NULL; - HostZStream.get()->zfree = Z_NULL; - HostZStream.get()->opaque = + HostZStream->zalloc = Z_NULL; + HostZStream->zfree = Z_NULL; + HostZStream->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored auto *MemInst = Frame.getMemoryByIndex(0); @@ -1165,21 +1165,23 @@ Expect WasmEdgeZlibDeflateInit_::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t Level, uint32_t VersionPtr, int32_t StreamSize) { + + if (!CheckSize(StreamSize)) + return static_cast(Z_VERSION_ERROR); + auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { return Unexpect(ErrCode::Value::HostFuncError); } const auto *WasmZlibVersion = MemInst->getPointer(VersionPtr); - if (!CheckSize(StreamSize)) - return static_cast(Z_VERSION_ERROR); - auto HostZStream = std::make_unique(); - HostZStream.get()->zalloc = Z_NULL; - HostZStream.get()->zfree = Z_NULL; - HostZStream.get()->opaque = - Z_NULL; // ignore opaque since zmalloc and zfree was ignored + // ignore wasm custom allocators + HostZStream->zalloc = Z_NULL; + HostZStream->zfree = Z_NULL; + // ignore opaque since zmalloc and zfree was ignored + HostZStream->opaque = Z_NULL; const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { return deflateInit_(HostZStream.get(), Level, WasmZlibVersion, @@ -1197,24 +1199,118 @@ WasmEdgeZlibInflateInit_::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, uint32_t VersionPtr, int32_t StreamSize) { + if (!CheckSize(StreamSize)) + return static_cast(Z_VERSION_ERROR); + auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { return Unexpect(ErrCode::Value::HostFuncError); } const auto *WasmZlibVersion = MemInst->getPointer(VersionPtr); + auto HostZStream = std::make_unique(); + + // ignore wasm custom allocators + HostZStream->zalloc = Z_NULL; + HostZStream->zfree = Z_NULL; + // ignore opaque since zmalloc and zfree was ignored + HostZStream->opaque = Z_NULL; + + const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { + return inflateInit_(HostZStream.get(), WasmZlibVersion, sizeof(z_stream)); + }); + + if (ZRes == Z_OK) + Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); + + return ZRes; +} + +Expect WasmEdgeZlibDeflateInit2_::body( + const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t Level, + int32_t Method, int32_t WindowBits, int32_t MemLevel, int32_t Strategy, + uint32_t VersionPtr, int32_t StreamSize) { + + if (!CheckSize(StreamSize)) + return static_cast(Z_VERSION_ERROR); + + auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + const auto *WasmZlibVersion = MemInst->getPointer(VersionPtr); + auto HostZStream = std::make_unique(); + HostZStream->zalloc = Z_NULL; + HostZStream->zfree = Z_NULL; + HostZStream->opaque = + Z_NULL; // ignore opaque since zmalloc and zfree was ignored + + const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { + return deflateInit2_(HostZStream.get(), Level, Method, WindowBits, MemLevel, + Strategy, WasmZlibVersion, sizeof(z_stream)); + }); + + if (ZRes == Z_OK) + Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); + + return ZRes; +} + +Expect +WasmEdgeZlibInflateInit2_::body(const Runtime::CallingFrame &Frame, + uint32_t ZStreamPtr, int32_t WindowBits, + uint32_t VersionPtr, int32_t StreamSize) { + if (!CheckSize(StreamSize)) return static_cast(Z_VERSION_ERROR); + auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + const auto *WasmZlibVersion = MemInst->getPointer(VersionPtr); auto HostZStream = std::make_unique(); + HostZStream->zalloc = Z_NULL; + HostZStream->zfree = Z_NULL; + HostZStream->opaque = + Z_NULL; // ignore opaque since zmalloc and zfree was ignored + + const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { + return inflateInit2_(HostZStream.get(), WindowBits, WasmZlibVersion, + sizeof(z_stream)); + }); - HostZStream.get()->zalloc = Z_NULL; - HostZStream.get()->zfree = Z_NULL; - HostZStream.get()->opaque = + if (ZRes == Z_OK) + Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); + + return ZRes; +} + +Expect WasmEdgeZlibInflateBackInit_::body( + const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t WindowBits, + uint32_t WindowPtr, uint32_t VersionPtr, int32_t StreamSize) { + + if (!CheckSize(StreamSize)) + return static_cast(Z_VERSION_ERROR); + + auto *MemInst = Frame.getMemoryByIndex(0); + if (MemInst == nullptr) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + const auto *WasmZlibVersion = MemInst->getPointer(VersionPtr); + auto *Window = MemInst->getPointer(WindowPtr); + auto HostZStream = std::make_unique(); + HostZStream->zalloc = Z_NULL; + HostZStream->zfree = Z_NULL; + HostZStream->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { - return inflateInit_(HostZStream.get(), WasmZlibVersion, sizeof(z_stream)); + return inflateBackInit_(HostZStream.get(), WindowBits, Window, + WasmZlibVersion, sizeof(z_stream)); }); if (ZRes == Z_OK) diff --git a/plugins/wasmedge_zlib/zlibfunc.h b/plugins/wasmedge_zlib/zlibfunc.h index c0049c63b4f8..ecefd9f34ebc 100644 --- a/plugins/wasmedge_zlib/zlibfunc.h +++ b/plugins/wasmedge_zlib/zlibfunc.h @@ -556,5 +556,36 @@ class WasmEdgeZlibInflateInit_ : public WasmEdgeZlib { uint32_t VersionPtr, int32_t StreamSize); }; +class WasmEdgeZlibDeflateInit2_ + : public WasmEdgeZlib { +public: + WasmEdgeZlibDeflateInit2_(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + int32_t Level, int32_t Method, int32_t WindowBits, + int32_t MemLevel, int32_t Strategy, uint32_t VersionPtr, + int32_t StreamSize); +}; + +class WasmEdgeZlibInflateInit2_ + : public WasmEdgeZlib { +public: + WasmEdgeZlibInflateInit2_(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + int32_t WindowBits, uint32_t VersionPtr, + int32_t StreamSize); +}; + +class WasmEdgeZlibInflateBackInit_ + : public WasmEdgeZlib { +public: + WasmEdgeZlibInflateBackInit_(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + int32_t WindowBits, uint32_t WindowPtr, + uint32_t VersionPtr, int32_t StreamSize); +}; + } // namespace Host } // namespace WasmEdge From e72b1a22bdb353a671bf8dc3901253f14ebd418a Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Thu, 31 Aug 2023 05:30:10 +0530 Subject: [PATCH 73/98] Added gzgetc_ Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 13 +++++++++++++ plugins/wasmedge_zlib/zlibfunc.h | 7 +++++++ 2 files changed, 20 insertions(+) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 6c21276a206d..7182a951d8cd 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -1319,5 +1319,18 @@ Expect WasmEdgeZlibInflateBackInit_::body( return ZRes; } +Expect WasmEdgeZlibGZGetc_::body(const Runtime::CallingFrame &, + uint32_t GZFile) { + + const auto GZFileIt = Env.GZFileMap.find(GZFile); + if (GZFileIt == Env.GZFileMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto ZRes = gzgetc_(GZFileIt->second.get()); + + return ZRes; +} + } // namespace Host } // namespace WasmEdge diff --git a/plugins/wasmedge_zlib/zlibfunc.h b/plugins/wasmedge_zlib/zlibfunc.h index ecefd9f34ebc..0e8dc1cb0ab5 100644 --- a/plugins/wasmedge_zlib/zlibfunc.h +++ b/plugins/wasmedge_zlib/zlibfunc.h @@ -587,5 +587,12 @@ class WasmEdgeZlibInflateBackInit_ uint32_t VersionPtr, int32_t StreamSize); }; +class WasmEdgeZlibGZGetc_ : public WasmEdgeZlib { +public: + WasmEdgeZlibGZGetc_(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile); +}; + } // namespace Host } // namespace WasmEdge From f295530caffde8ceb7a70b774a87f35afce191c3 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Thu, 31 Aug 2023 06:33:00 +0530 Subject: [PATCH 74/98] Added inflateSyncPoint | inflateUndermine | inflateValidate | inflateCodesUsed | inflateResetKeep | deflateResetKeep. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 81 ++++++++++++++++++++++++++++-- plugins/wasmedge_zlib/zlibfunc.h | 63 +++++++++++++++++++++++ 2 files changed, 139 insertions(+), 5 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 7182a951d8cd..e712dbfb5292 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -1319,15 +1319,86 @@ Expect WasmEdgeZlibInflateBackInit_::body( return ZRes; } -Expect WasmEdgeZlibGZGetc_::body(const Runtime::CallingFrame &, - uint32_t GZFile) { +Expect +WasmEdgeZlibInflateSyncPoint::body(const Runtime::CallingFrame &, + uint32_t ZStreamPtr) { - const auto GZFileIt = Env.GZFileMap.find(GZFile); - if (GZFileIt == Env.GZFileMap.end()) { + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto ZRes = inflateSyncPoint(HostZStreamIt->second.get()); + + return ZRes; +} + +Expect +WasmEdgeZlibInflateUndermine::body(const Runtime::CallingFrame &, + uint32_t ZStreamPtr, int32_t Subvert) { + + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto ZRes = inflateUndermine(HostZStreamIt->second.get(), Subvert); + + return ZRes; +} + +Expect WasmEdgeZlibInflateValidate::body(const Runtime::CallingFrame &, + uint32_t ZStreamPtr, + int32_t Check) { + + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto ZRes = inflateValidate(HostZStreamIt->second.get(), Check); + + return ZRes; +} + +Expect +WasmEdgeZlibInflateCodesUsed::body(const Runtime::CallingFrame &, + uint32_t ZStreamPtr) { + + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto ZRes = inflateCodesUsed(HostZStreamIt->second.get()); + + return ZRes; +} + +Expect +WasmEdgeZlibInflateResetKeep::body(const Runtime::CallingFrame &, + uint32_t ZStreamPtr) { + + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto ZRes = inflateResetKeep(HostZStreamIt->second.get()); + + return ZRes; +} + +Expect +WasmEdgeZlibDeflateResetKeep::body(const Runtime::CallingFrame &, + uint32_t ZStreamPtr) { + + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); } - auto ZRes = gzgetc_(GZFileIt->second.get()); + auto ZRes = deflateResetKeep(HostZStreamIt->second.get()); return ZRes; } diff --git a/plugins/wasmedge_zlib/zlibfunc.h b/plugins/wasmedge_zlib/zlibfunc.h index 0e8dc1cb0ab5..db5454562fda 100644 --- a/plugins/wasmedge_zlib/zlibfunc.h +++ b/plugins/wasmedge_zlib/zlibfunc.h @@ -594,5 +594,68 @@ class WasmEdgeZlibGZGetc_ : public WasmEdgeZlib { Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile); }; +/* class WasmEdgeZlibZError : public WasmEdgeZlib { +public: + WasmEdgeZlibZError(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, int32_t Err); +}; */ + +class WasmEdgeZlibInflateSyncPoint + : public WasmEdgeZlib { +public: + WasmEdgeZlibInflateSyncPoint(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr); +}; + +/* class WasmEdgeZlibGetCRCTable : public WasmEdgeZlib +{ public: WasmEdgeZlibGetCRCTable(WasmEdgeZlibEnvironment &HostEnv) : +WasmEdgeZlib(HostEnv) {} Expect body(const Runtime::CallingFrame +&Frame); +}; */ + +class WasmEdgeZlibInflateUndermine + : public WasmEdgeZlib { +public: + WasmEdgeZlibInflateUndermine(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + int32_t Subvert); +}; + +class WasmEdgeZlibInflateValidate + : public WasmEdgeZlib { +public: + WasmEdgeZlibInflateValidate(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + int32_t Check); +}; + +class WasmEdgeZlibInflateCodesUsed + : public WasmEdgeZlib { +public: + WasmEdgeZlibInflateCodesUsed(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr); +}; + +class WasmEdgeZlibInflateResetKeep + : public WasmEdgeZlib { +public: + WasmEdgeZlibInflateResetKeep(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr); +}; + +class WasmEdgeZlibDeflateResetKeep + : public WasmEdgeZlib { +public: + WasmEdgeZlibDeflateResetKeep(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr); +}; + } // namespace Host } // namespace WasmEdge From d9e30b99376779fc7c80673ce1d26a1ec06ca17b Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Thu, 31 Aug 2023 06:35:39 +0530 Subject: [PATCH 75/98] Added draft WasmEdgeZlibGZVPrintf. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.h | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/plugins/wasmedge_zlib/zlibfunc.h b/plugins/wasmedge_zlib/zlibfunc.h index db5454562fda..5351054e921f 100644 --- a/plugins/wasmedge_zlib/zlibfunc.h +++ b/plugins/wasmedge_zlib/zlibfunc.h @@ -657,5 +657,13 @@ class WasmEdgeZlibDeflateResetKeep Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr); }; +/* class WasmEdgeZlibGZVPrintf : public WasmEdgeZlib { +public: + WasmEdgeZlibGZVPrintf(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFilePtr, + uint32_t FormatPtr); +}; */ + } // namespace Host } // namespace WasmEdge From 50a1032285550d3a515d4e5957a83f5b760720c3 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Thu, 31 Aug 2023 06:59:30 +0530 Subject: [PATCH 76/98] Removed unused Frame parameter. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index e712dbfb5292..da82428c6c67 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -1112,10 +1112,10 @@ Expect WasmEdgeZlibAdler32_z::body(const Runtime::CallingFrame &Frame, return ZRes; } -Expect -WasmEdgeZlibAdler32Combine::body(const Runtime::CallingFrame &Frame, - uint32_t Adler1, uint32_t Adler2, - int32_t Len2) { +Expect WasmEdgeZlibAdler32Combine::body(const Runtime::CallingFrame &, + uint32_t Adler1, + uint32_t Adler2, + int32_t Len2) { const int32_t ZRes = adler32_combine(Adler1, Adler2, Len2); return ZRes; @@ -1153,9 +1153,9 @@ Expect WasmEdgeZlibCRC32_z::body(const Runtime::CallingFrame &Frame, return ZRes; } -Expect -WasmEdgeZlibCRC32Combine::body(const Runtime::CallingFrame &Frame, - uint32_t CRC1, uint32_t CRC2, int32_t Len2) { +Expect WasmEdgeZlibCRC32Combine::body(const Runtime::CallingFrame &, + uint32_t CRC1, uint32_t CRC2, + int32_t Len2) { const int32_t ZRes = crc32_combine(CRC1, CRC2, Len2); return ZRes; From 1d44df29f409a3edac08fd2a8d111be64d992a93 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Tue, 5 Sep 2023 18:39:55 +0530 Subject: [PATCH 77/98] Change all remaining naming convention to LLVM style. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibenv.h | 56 ++++++++++---------- plugins/wasmedge_zlib/zlibfunc.cpp | 36 ++++++------- test/plugins/wasmedge_zlib/wasmedge_zlib.cpp | 32 +++++------ 3 files changed, 62 insertions(+), 62 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibenv.h b/plugins/wasmedge_zlib/zlibenv.h index cb9b65e3358a..f876079d08e0 100644 --- a/plugins/wasmedge_zlib/zlibenv.h +++ b/plugins/wasmedge_zlib/zlibenv.h @@ -17,40 +17,40 @@ */ struct WasmZStream { /* [Wasm Offset] next input byte */ - uint32_t next_in; + uint32_t NextIn; /* number of bytes available at next_in */ - uint32_t avail_in; + uint32_t AvailIn; /* total number of input bytes read so far */ - uint32_t total_in; + uint32_t TotalIn; /* [Wasm Offset] next output byte will go here */ - uint32_t next_out; + uint32_t NextOut; /* remaining free space at next_out */ - uint32_t avail_out; + uint32_t AvailOut; /* total number of bytes output so far */ - uint32_t total_out; + uint32_t TotalOut; /* [Wasm Offset] last error message, NULL if no error */ - uint32_t msg; + uint32_t Msg; /* [Wasm Offset] not visible by applications */ - uint32_t state; + uint32_t State; /* used to allocate the internal state */ - uint32_t zalloc; + uint32_t Zalloc; /* used to free the internal state */ - uint32_t zfree; + uint32_t Zfree; /* [Wasm Offset] private data object passed to zalloc and zfree */ - uint32_t opaque; + uint32_t Opaque; /* best guess about the data type: binary or text for deflate, or the decoding state for inflate */ - int32_t data_type; + int32_t DataType; /* Adler-32 or CRC-32 value of the uncompressed data */ - uint32_t adler; + uint32_t Adler; /* reserved for future use */ - uint32_t reserved; + uint32_t Reserved; }; static_assert(sizeof(WasmZStream) == 56, "WasmZStream should be 56 bytes"); @@ -59,20 +59,20 @@ static_assert(sizeof(WasmZStream) == 56, "WasmZStream should be 56 bytes"); for more details on the meanings of these fields. */ struct WasmGZHeader { - int32_t text; /* true if compressed data believed to be text */ - uint32_t time; /* modification time */ - int32_t xflags; /* extra flags (not used when writing a gzip file) */ - int32_t os; /* operating system */ - uint32_t extra; /* pointer to extra field or Z_NULL if none */ - uint32_t extra_len; /* extra field length (valid if extra != Z_NULL) */ - uint32_t extra_max; /* space at extra (only when reading header) */ - uint32_t name; /* pointer to zero-terminated file name or Z_NULL */ - uint32_t name_max; /* space at name (only when reading header) */ - uint32_t comment; /* pointer to zero-terminated comment or Z_NULL */ - uint32_t comm_max; /* space at comment (only when reading header) */ - int32_t hcrc; /* true if there was or will be a header crc */ - int32_t done; /* true when done reading gzip header (not used - when writing a gzip file) */ + int32_t Text; /* true if compressed data believed to be text */ + uint32_t Time; /* modification time */ + int32_t XFlags; /* extra flags (not used when writing a gzip file) */ + int32_t OS; /* operating system */ + uint32_t Extra; /* pointer to extra field or Z_NULL if none */ + uint32_t ExtraLen; /* extra field length (valid if extra != Z_NULL) */ + uint32_t ExtraMax; /* space at extra (only when reading header) */ + uint32_t Name; /* pointer to zero-terminated file name or Z_NULL */ + uint32_t NameMax; /* space at name (only when reading header) */ + uint32_t Comment; /* pointer to zero-terminated comment or Z_NULL */ + uint32_t CommMax; /* space at comment (only when reading header) */ + int32_t HCRC; /* true if there was or will be a header crc */ + int32_t Done; /* true when done reading gzip header (not used + when writing a gzip file) */ }; static_assert(sizeof(WasmGZHeader) == 52, "WasmGZHeader should be 52 bytes"); diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index da82428c6c67..afdb1279260b 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -27,43 +27,43 @@ auto SyncRun(z_stream *HostZStream, uint32_t ZStreamPtr, WasmZStream *ModuleZStream = MemInst->getPointer(ZStreamPtr); HostZStream->next_in = - MemInst->getPointer(ModuleZStream->next_in); - HostZStream->avail_in = ModuleZStream->avail_in; - HostZStream->total_in = ModuleZStream->total_in; + MemInst->getPointer(ModuleZStream->NextIn); + HostZStream->avail_in = ModuleZStream->AvailIn; + HostZStream->total_in = ModuleZStream->TotalIn; HostZStream->next_out = - MemInst->getPointer(ModuleZStream->next_out); - HostZStream->avail_out = ModuleZStream->avail_out; - HostZStream->total_out = ModuleZStream->total_out; + MemInst->getPointer(ModuleZStream->NextOut); + HostZStream->avail_out = ModuleZStream->AvailOut; + HostZStream->total_out = ModuleZStream->TotalOut; // TODO: ignore msg for now // ignore state // ignore zalloc, zfree, opaque - HostZStream->data_type = ModuleZStream->data_type; - HostZStream->adler = ModuleZStream->adler; - HostZStream->reserved = ModuleZStream->reserved; + HostZStream->data_type = ModuleZStream->DataType; + HostZStream->adler = ModuleZStream->Adler; + HostZStream->reserved = ModuleZStream->Reserved; const auto PreComputeNextIn = HostZStream->next_in; const auto PreComputeNextOut = HostZStream->next_out; const auto ZRes = Callback(); - ModuleZStream->next_in += HostZStream->next_in - PreComputeNextIn; - ModuleZStream->avail_in = HostZStream->avail_in; - ModuleZStream->total_in = HostZStream->total_in; + ModuleZStream->NextIn += HostZStream->next_in - PreComputeNextIn; + ModuleZStream->AvailIn = HostZStream->avail_in; + ModuleZStream->TotalIn = HostZStream->total_in; - ModuleZStream->next_out += HostZStream->next_out - PreComputeNextOut; - ModuleZStream->avail_out = HostZStream->avail_out; - ModuleZStream->total_out = HostZStream->total_out; + ModuleZStream->NextOut += HostZStream->next_out - PreComputeNextOut; + ModuleZStream->AvailOut = HostZStream->avail_out; + ModuleZStream->TotalOut = HostZStream->total_out; // TODO: ignore msg for now // ignore state // ignore zalloc, zfree, opaque - ModuleZStream->data_type = HostZStream->data_type; - ModuleZStream->adler = HostZStream->adler; - ModuleZStream->reserved = HostZStream->reserved; + ModuleZStream->DataType = HostZStream->data_type; + ModuleZStream->Adler = HostZStream->adler; + ModuleZStream->Reserved = HostZStream->reserved; return ZRes; } diff --git a/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp b/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp index d9e86e382b85..2b0000133dd5 100644 --- a/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp +++ b/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp @@ -154,17 +154,17 @@ TEST(WasmEdgeZlibTest, DeflateInflateCycle) { wasm_compressed_data = wasm_hp; - strm->avail_in = DATA_SIZE; - strm->next_in = wasm_data; - strm->avail_out = OUTPUT_BUFFER_SIZE; - strm->next_out = wasm_compressed_data; + strm->AvailIn = DATA_SIZE; + strm->NextIn = wasm_data; + strm->AvailOut = OUTPUT_BUFFER_SIZE; + strm->NextOut = wasm_compressed_data; // deflate Test do { - if (strm->avail_out == 0) { + if (strm->AvailOut == 0) { wasm_hp += OUTPUT_BUFFER_SIZE; - strm->avail_out = OUTPUT_BUFFER_SIZE; - strm->next_out = wasm_hp; + strm->AvailOut = OUTPUT_BUFFER_SIZE; + strm->NextOut = wasm_hp; } EXPECT_TRUE(__deflate.run(CallFrame, @@ -181,7 +181,7 @@ TEST(WasmEdgeZlibTest, DeflateInflateCycle) { CallFrame, std::initializer_list{wasm_z_stream}, RetVal)); EXPECT_EQ(RetVal[0].get(), Z_OK); - wasm_hp += OUTPUT_BUFFER_SIZE - strm->avail_out; + wasm_hp += OUTPUT_BUFFER_SIZE - strm->AvailOut; wasm_compressed_data_size = wasm_hp - wasm_compressed_data; // ----- Deflate Routine END------ @@ -214,17 +214,17 @@ TEST(WasmEdgeZlibTest, DeflateInflateCycle) { wasm_decompressed_data = wasm_hp; - strm->avail_in = wasm_compressed_data_size; - strm->next_in = wasm_compressed_data; - strm->avail_out = OUTPUT_BUFFER_SIZE; - strm->next_out = wasm_decompressed_data; + strm->AvailIn = wasm_compressed_data_size; + strm->NextIn = wasm_compressed_data; + strm->AvailOut = OUTPUT_BUFFER_SIZE; + strm->NextOut = wasm_decompressed_data; // inflate test do { - if (strm->avail_out == 0) { + if (strm->AvailOut == 0) { wasm_hp += OUTPUT_BUFFER_SIZE; - strm->avail_out = OUTPUT_BUFFER_SIZE; - strm->next_out = wasm_hp; + strm->AvailOut = OUTPUT_BUFFER_SIZE; + strm->NextOut = wasm_hp; } EXPECT_TRUE(__inflate.run(CallFrame, @@ -240,7 +240,7 @@ TEST(WasmEdgeZlibTest, DeflateInflateCycle) { CallFrame, std::initializer_list{wasm_z_stream}, RetVal)); EXPECT_EQ(RetVal[0].get(), Z_OK); - wasm_hp += OUTPUT_BUFFER_SIZE - strm->avail_out; + wasm_hp += OUTPUT_BUFFER_SIZE - strm->AvailOut; wasm_decompressed_data_size = wasm_hp - wasm_decompressed_data; // ----- Inflate Routine END------ From b7c6368b2da387de95a0f748a2861702a15fcc51 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Thu, 7 Sep 2023 07:50:01 +0530 Subject: [PATCH 78/98] Added Host Func registration & Refactor Part 3. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 13 ++++ plugins/wasmedge_zlib/zlibfunc.h | 27 +++++--- plugins/wasmedge_zlib/zlibmodule.cpp | 95 +++++++++++++++++++++++++++- 3 files changed, 122 insertions(+), 13 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index afdb1279260b..fb58f6086793 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -1319,6 +1319,19 @@ Expect WasmEdgeZlibInflateBackInit_::body( return ZRes; } +Expect WasmEdgeZlibGZGetc_::body(const Runtime::CallingFrame &, + uint32_t GZFile) { + + const auto GZFileIt = Env.GZFileMap.find(GZFile); + if (GZFileIt == Env.GZFileMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto ZRes = gzgetc_(GZFileIt->second.get()); + + return ZRes; +} + Expect WasmEdgeZlibInflateSyncPoint::body(const Runtime::CallingFrame &, uint32_t ZStreamPtr) { diff --git a/plugins/wasmedge_zlib/zlibfunc.h b/plugins/wasmedge_zlib/zlibfunc.h index 5351054e921f..a02bf09efbfd 100644 --- a/plugins/wasmedge_zlib/zlibfunc.h +++ b/plugins/wasmedge_zlib/zlibfunc.h @@ -8,11 +8,14 @@ namespace WasmEdge { namespace Host { -/* class WasmEdgeZlibZlibVersion : public WasmEdgeZlib -{ public: WasmEdgeZlibZlibVersion(WasmEdgeZlibEnvironment &HostEnv) : -WasmEdgeZlib(HostEnv) {} Expect body(const Runtime::CallingFrame -&Frame); -}; */ +/* +class WasmEdgeZlibZlibVersion : public WasmEdgeZlib { +public: + WasmEdgeZlibZlibVersion(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame); +}; +*/ class WasmEdgeZlibDeflateInit : public WasmEdgeZlib { public: @@ -227,11 +230,15 @@ class WasmEdgeZlibInflateBackInit int32_t WindowBits, uint32_t WindowPtr); }; -/* class WasmEdgeZlibInflateBack : public WasmEdgeZlib -{ public: WasmEdgeZlibInflateBack(WasmEdgeZlibEnvironment &HostEnv) : -WasmEdgeZlib(HostEnv) {} Expect body(const Runtime::CallingFrame -&Frame, uint32_t ZStreamPtr, int32_t Bits, int32_t Value); -}; */ +/* +class WasmEdgeZlibInflateBack : public WasmEdgeZlib { +public: + WasmEdgeZlibInflateBack(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + int32_t Bits, int32_t Value); +}; +*/ class WasmEdgeZlibInflateBackEnd : public WasmEdgeZlib { diff --git a/plugins/wasmedge_zlib/zlibmodule.cpp b/plugins/wasmedge_zlib/zlibmodule.cpp index 191151e300d5..b33cb524923c 100644 --- a/plugins/wasmedge_zlib/zlibmodule.cpp +++ b/plugins/wasmedge_zlib/zlibmodule.cpp @@ -9,12 +9,101 @@ namespace Host { /// Register your functions in module. WasmEdgeZlibModule::WasmEdgeZlibModule() : ModuleInstance("wasmedge_zlib") { - addHostFunc("deflateInit_", std::make_unique(Env)); - addHostFunc("inflateInit_", std::make_unique(Env)); + addHostFunc("deflateInit", std::make_unique(Env)); addHostFunc("deflate", std::make_unique(Env)); - addHostFunc("inflate", std::make_unique(Env)); addHostFunc("deflateEnd", std::make_unique(Env)); + addHostFunc("inflateInit", std::make_unique(Env)); + addHostFunc("inflate", std::make_unique(Env)); addHostFunc("inflateEnd", std::make_unique(Env)); + addHostFunc("deflateInit2", std::make_unique(Env)); + addHostFunc("deflateSetDictionary", + std::make_unique(Env)); + addHostFunc("deflateGetDictionary", + std::make_unique(Env)); + addHostFunc("deflateCopy", std::make_unique(Env)); + addHostFunc("deflateReset", std::make_unique(Env)); + addHostFunc("deflateParams", + std::make_unique(Env)); + addHostFunc("deflateTune", std::make_unique(Env)); + addHostFunc("deflateBound", std::make_unique(Env)); + addHostFunc("deflatePending", + std::make_unique(Env)); + addHostFunc("deflatePrime", std::make_unique(Env)); + addHostFunc("inflateInit2", std::make_unique(Env)); + addHostFunc("inflateSetDictionary", + std::make_unique(Env)); + addHostFunc("inflateGetDictionary", + std::make_unique(Env)); + addHostFunc("inflateSync", std::make_unique(Env)); + addHostFunc("inflateCopy", std::make_unique(Env)); + addHostFunc("inflateReset", std::make_unique(Env)); + addHostFunc("inflateReset2", + std::make_unique(Env)); + addHostFunc("inflatePrime", std::make_unique(Env)); + addHostFunc("inflateMark", std::make_unique(Env)); + addHostFunc("inflateBackInit", + std::make_unique(Env)); + addHostFunc("inflateBackEnd", + std::make_unique(Env)); + addHostFunc("zlibCompileFlags", + std::make_unique(Env)); + addHostFunc("compress", std::make_unique(Env)); + addHostFunc("compress2", std::make_unique(Env)); + addHostFunc("compressBound", + std::make_unique(Env)); + addHostFunc("uncompress", std::make_unique(Env)); + addHostFunc("uncompress2", std::make_unique(Env)); + addHostFunc("gzopen", std::make_unique(Env)); + addHostFunc("gzdopen", std::make_unique(Env)); + addHostFunc("gzbuffer", std::make_unique(Env)); + addHostFunc("gzsetparams", std::make_unique(Env)); + addHostFunc("gzread", std::make_unique(Env)); + addHostFunc("gzfread", std::make_unique(Env)); + addHostFunc("gzwrite", std::make_unique(Env)); + addHostFunc("gzfwrite", std::make_unique(Env)); + addHostFunc("gzputs", std::make_unique(Env)); + addHostFunc("gzputc", std::make_unique(Env)); + addHostFunc("gzgetc", std::make_unique(Env)); + addHostFunc("gzungetc", std::make_unique(Env)); + addHostFunc("gzflush", std::make_unique(Env)); + addHostFunc("gzseek", std::make_unique(Env)); + addHostFunc("gzrewind", std::make_unique(Env)); + addHostFunc("gztell", std::make_unique(Env)); + addHostFunc("gzoffset", std::make_unique(Env)); + addHostFunc("gzeof", std::make_unique(Env)); + addHostFunc("gzdirect", std::make_unique(Env)); + addHostFunc("gzclose", std::make_unique(Env)); + addHostFunc("gzclose_r", std::make_unique(Env)); + addHostFunc("gzclose_w", std::make_unique(Env)); + addHostFunc("gzclearerr", std::make_unique(Env)); + addHostFunc("adler32", std::make_unique(Env)); + addHostFunc("adler32_z", std::make_unique(Env)); + addHostFunc("adler32_combine", + std::make_unique(Env)); + addHostFunc("crc32", std::make_unique(Env)); + addHostFunc("crc32_z", std::make_unique(Env)); + addHostFunc("crc32_combine", std::make_unique(Env)); + addHostFunc("deflateInit_", std::make_unique(Env)); + addHostFunc("inflateInit_", std::make_unique(Env)); + addHostFunc("deflateInit2_", + std::make_unique(Env)); + addHostFunc("inflateInit2_", + std::make_unique(Env)); + addHostFunc("inflateBackInit_", + std::make_unique(Env)); + addHostFunc("gzgetc_", std::make_unique(Env)); + addHostFunc("inflateSyncPoint", + std::make_unique(Env)); + addHostFunc("inflateUndermine", + std::make_unique(Env)); + addHostFunc("inflateValidate", + std::make_unique(Env)); + addHostFunc("inflateCodesUsed", + std::make_unique(Env)); + addHostFunc("inflateResetKeep", + std::make_unique(Env)); + addHostFunc("deflateResetKeep", + std::make_unique(Env)); } } // namespace Host From 692e6ad387444cdd4082dd6f0f906551b95dd848 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Thu, 7 Sep 2023 09:01:54 +0530 Subject: [PATCH 79/98] Update function presence check to validate al 74 functions. Signed-off-by: Saikat Dey --- test/plugins/wasmedge_zlib/wasmedge_zlib.cpp | 77 +++++++++++++++++++- 1 file changed, 73 insertions(+), 4 deletions(-) diff --git a/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp b/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp index 2b0000133dd5..0db9da0e76bb 100644 --- a/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp +++ b/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp @@ -260,13 +260,82 @@ TEST(WasmEdgeZlibTest, Module) { dynamic_cast(createModule()); EXPECT_FALSE(ZlibMod == nullptr); EXPECT_TRUE(ZlibMod->getEnv().ZStreamMap.empty()); - EXPECT_EQ(ZlibMod->getFuncExportNum(), 6U); - EXPECT_NE(ZlibMod->findFuncExports("deflateInit_"), nullptr); - EXPECT_NE(ZlibMod->findFuncExports("inflateInit_"), nullptr); + EXPECT_EQ(ZlibMod->getFuncExportNum(), 74U); + + EXPECT_NE(ZlibMod->findFuncExports("deflateInit"), nullptr); EXPECT_NE(ZlibMod->findFuncExports("deflate"), nullptr); - EXPECT_NE(ZlibMod->findFuncExports("inflate"), nullptr); EXPECT_NE(ZlibMod->findFuncExports("deflateEnd"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("inflateInit"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("inflate"), nullptr); EXPECT_NE(ZlibMod->findFuncExports("inflateEnd"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("deflateInit2"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("deflateSetDictionary"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("deflateGetDictionary"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("deflateCopy"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("deflateReset"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("deflateParams"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("deflateTune"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("deflateBound"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("deflatePending"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("deflatePrime"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("inflateInit2"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("inflateSetDictionary"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("inflateGetDictionary"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("inflateSync"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("inflateCopy"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("inflateReset"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("inflateReset2"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("inflatePrime"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("inflateMark"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("inflateBackInit"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("inflateBackEnd"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("zlibCompileFlags"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("compress"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("compress2"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("compressBound"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("uncompress"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("uncompress2"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("gzopen"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("gzdopen"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("gzbuffer"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("gzsetparams"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("gzread"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("gzfread"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("gzwrite"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("gzfwrite"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("gzputs"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("gzputc"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("gzgetc"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("gzungetc"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("gzflush"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("gzseek"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("gzrewind"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("gztell"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("gzoffset"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("gzeof"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("gzdirect"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("gzclose"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("gzclose_r"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("gzclose_w"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("gzclearerr"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("adler32"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("adler32_z"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("adler32_combine"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("crc32"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("crc32_z"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("crc32_combine"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("deflateInit_"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("inflateInit_"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("deflateInit2_"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("inflateInit2_"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("inflateBackInit_"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("gzgetc_"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("inflateSyncPoint"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("inflateUndermine"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("inflateValidate"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("inflateCodesUsed"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("inflateResetKeep"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("deflateResetKeep"), nullptr); delete ZlibMod; } From 71c819220fd4f462bf3e2a23d520d162df1692d6 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Sat, 9 Sep 2023 03:24:36 +0530 Subject: [PATCH 80/98] Update release.yml to include zlib. Signed-off-by: Saikat Dey --- .github/workflows/release.yml | 39 ++++++++++++++++++++++++++--------- 1 file changed, 29 insertions(+), 10 deletions(-) diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 2b78e8110f04..d3fedc4cb514 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -85,7 +85,7 @@ jobs: version: ${{ needs.create_release.outputs.version }} release: true secrets: inherit - + build_on_alpine_static: needs: create_release uses: ./.github/workflows/reusable-build-on-alpine-static.yml @@ -198,9 +198,9 @@ jobs: runs-on: ubuntu-latest env: output_prefix: build/plugins - build_options: -DWASMEDGE_PLUGIN_WASI_CRYPTO=ON -DWASMEDGE_PLUGIN_WASI_LOGGING=ON -DWASMEDGE_PLUGIN_RUSTLS=ON -DWASMEDGE_PLUGIN_PROCESS=ON -DWASMEDGE_PLUGIN_TENSORFLOW=ON -DWASMEDGE_PLUGIN_TENSORFLOWLITE=ON -DWASMEDGE_PLUGIN_IMAGE=ON -DWASMEDGE_PLUGIN_WASM_BPF=ON -DWASMEDGE_PLUGIN_OPENCVMINI=ON - tar_names: wasi_crypto wasi_logging wasmedge_rustls wasmedge_process wasmedge_tensorflow wasmedge_tensorflowlite wasmedge_image wasm_bpf wasmedge_opencvmini - output_bins: libwasmedgePluginWasiCrypto.so libwasmedgePluginWasiLogging.so libwasmedge_rustls.so libwasmedgePluginWasmEdgeProcess.so libwasmedgePluginWasmEdgeTensorflow.so libwasmedgePluginWasmEdgeTensorflowLite.so libwasmedgePluginWasmEdgeImage.so libwasmedgePluginWasmBpf.so libwasmedgePluginWasmEdgeOpenCVMini.so + build_options: -DWASMEDGE_PLUGIN_WASI_CRYPTO=ON -DWASMEDGE_PLUGIN_WASI_LOGGING=ON -DWASMEDGE_PLUGIN_RUSTLS=ON -DWASMEDGE_PLUGIN_PROCESS=ON -DWASMEDGE_PLUGIN_TENSORFLOW=ON -DWASMEDGE_PLUGIN_TENSORFLOWLITE=ON -DWASMEDGE_PLUGIN_IMAGE=ON -DWASMEDGE_PLUGIN_WASM_BPF=ON -DWASMEDGE_PLUGIN_OPENCVMINI=ON -DWASMEDGE_PLUGIN_ZLIB=ON + tar_names: wasi_crypto wasi_logging wasmedge_rustls wasmedge_process wasmedge_tensorflow wasmedge_tensorflowlite wasmedge_image wasm_bpf wasmedge_opencvmini wasmedge_zlib + output_bins: libwasmedgePluginWasiCrypto.so libwasmedgePluginWasiLogging.so libwasmedge_rustls.so libwasmedgePluginWasmEdgeProcess.so libwasmedgePluginWasmEdgeTensorflow.so libwasmedgePluginWasmEdgeTensorflowLite.so libwasmedgePluginWasmEdgeImage.so libwasmedgePluginWasmBpf.so libwasmedgePluginWasmEdgeOpenCVMini.so libwasmedgePluginWasmEdgeZlib.so needs: create_release container: image: wasmedge/wasmedge:ubuntu-20.04-build-clang @@ -305,6 +305,12 @@ jobs: run: | mv plugin_wasmedge_opencvmini.tar.gz WasmEdge-plugin-wasmedge_opencvmini-${{ needs.create_release.outputs.version }}-ubuntu20.04_x86_64.tar.gz gh release upload ${{ needs.create_release.outputs.version }} WasmEdge-plugin-wasmedge_opencvmini-${{ needs.create_release.outputs.version }}-ubuntu20.04_x86_64.tar.gz --clobber + - name: Upload wasmedge_zlib plugin tar.gz package + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + run: | + mv plugin_wasmedge_zlib.tar.gz WasmEdge-plugin-wasmedge_zlib-${{ needs.create_release.outputs.version }}-ubuntu20.04_x86_64.tar.gz + gh release upload ${{ needs.create_release.outputs.version }} WasmEdge-plugin-wasmedge_zlib-${{ needs.create_release.outputs.version }}-ubuntu20.04_x86_64.tar.gz --clobber build_and_upload_wasinn_manylinux: strategy: @@ -407,13 +413,13 @@ jobs: runs-on: ${{ matrix.host_runner }} env: output_prefix: build/plugins - build_options_all_platforms: -DWASMEDGE_PLUGIN_WASI_CRYPTO=ON -DWASMEDGE_PLUGIN_WASI_LOGGING=ON -DWASMEDGE_PLUGIN_PROCESS=ON -DWASMEDGE_PLUGIN_TENSORFLOW=ON -DWASMEDGE_PLUGIN_TENSORFLOWLITE=ON -DWASMEDGE_PLUGIN_IMAGE=ON -DWASMEDGE_PLUGIN_OPENCVMINI=ON + build_options_all_platforms: -DWASMEDGE_PLUGIN_WASI_CRYPTO=ON -DWASMEDGE_PLUGIN_WASI_LOGGING=ON -DWASMEDGE_PLUGIN_PROCESS=ON -DWASMEDGE_PLUGIN_TENSORFLOW=ON -DWASMEDGE_PLUGIN_TENSORFLOWLITE=ON -DWASMEDGE_PLUGIN_IMAGE=ON -DWASMEDGE_PLUGIN_OPENCVMINI=ON -DWASMEDGE_PLUGIN_ZLIB=ON build_options_manylinux2014_x86_64: -DWASMEDGE_PLUGIN_WASM_BPF=ON -DWASMEDGE_PLUGIN_RUSTLS=ON -DWASMEDGE_PLUGIN_WASM_BPF_BUILD_LIBBPF_WITH_PKG_CONF=OFF build_options_manylinux2014_aarch64: - tar_names_all_platforms: wasi_crypto wasi_logging wasmedge_process wasmedge_tensorflow wasmedge_tensorflowlite wasmedge_image wasmedge_opencvmini + tar_names_all_platforms: wasi_crypto wasi_logging wasmedge_process wasmedge_tensorflow wasmedge_tensorflowlite wasmedge_image wasmedge_opencvmini wasmedge_zlib tar_names_manylinux2014_x86_64: wasm_bpf wasmedge_rustls tar_names_manylinux2014_aarch64: - output_bins_all_platforms: libwasmedgePluginWasiCrypto.so libwasmedgePluginWasiLogging.so libwasmedgePluginWasmEdgeProcess.so libwasmedgePluginWasmEdgeTensorflow.so libwasmedgePluginWasmEdgeTensorflowLite.so libwasmedgePluginWasmEdgeImage.so libwasmedgePluginWasmEdgeOpenCVMini.so + output_bins_all_platforms: libwasmedgePluginWasiCrypto.so libwasmedgePluginWasiLogging.so libwasmedgePluginWasmEdgeProcess.so libwasmedgePluginWasmEdgeTensorflow.so libwasmedgePluginWasmEdgeTensorflowLite.so libwasmedgePluginWasmEdgeImage.so libwasmedgePluginWasmEdgeOpenCVMini.so libwasmedgePluginWasmEdgeZlib.so output_bins_manylinux2014_x86_64: libwasmedgePluginWasmBpf.so libwasmedge_rustls.so output_bins_manylinux2014_aarch64: needs: create_release @@ -521,6 +527,12 @@ jobs: run: | mv plugin_wasmedge_opencvmini.tar.gz WasmEdge-plugin-wasmedge_opencvmini-${{ needs.create_release.outputs.version }}-${{ matrix.docker_tag }}.tar.gz gh release upload ${{ needs.create_release.outputs.version }} WasmEdge-plugin-wasmedge_opencvmini-${{ needs.create_release.outputs.version }}-${{ matrix.docker_tag }}.tar.gz --clobber + - name: Upload wasmedge_zlib plugin tar.gz package + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + run: | + mv plugin_wasmedge_zlib.tar.gz WasmEdge-plugin-wasmedge_zlib-${{ needs.create_release.outputs.version }}-${{ matrix.docker_tag }}.tar.gz + gh release upload ${{ needs.create_release.outputs.version }} WasmEdge-plugin-wasmedge_zlib-${{ needs.create_release.outputs.version }}-${{ matrix.docker_tag }}.tar.gz --clobber build_and_upload_plugin_macos: strategy: @@ -540,9 +552,9 @@ jobs: runs-on: ${{ matrix.host_runner }} env: output_prefix: build/plugins - build_options: -DWASMEDGE_PLUGIN_WASI_CRYPTO=ON -DWASMEDGE_PLUGIN_WASI_LOGGING=ON -DWASMEDGE_PLUGIN_RUSTLS=ON -DWASMEDGE_PLUGIN_TENSORFLOW=ON -DWASMEDGE_PLUGIN_TENSORFLOWLITE=ON -DWASMEDGE_PLUGIN_IMAGE=ON -DWASMEDGE_PLUGIN_OPENCVMINI=ON - tar_names: wasi_crypto wasi_logging wasmedge_rustls wasmedge_tensorflow wasmedge_tensorflowlite wasmedge_image wasmedge_opencvmini - output_bins: libwasmedgePluginWasiCrypto.dylib libwasmedgePluginWasiLogging.dylib libwasmedge_rustls.dylib libwasmedgePluginWasmEdgeTensorflow.dylib libwasmedgePluginWasmEdgeTensorflowLite.dylib libwasmedgePluginWasmEdgeImage.dylib libwasmedgePluginWasmEdgeOpenCVMini.dylib + build_options: -DWASMEDGE_PLUGIN_WASI_CRYPTO=ON -DWASMEDGE_PLUGIN_WASI_LOGGING=ON -DWASMEDGE_PLUGIN_RUSTLS=ON -DWASMEDGE_PLUGIN_TENSORFLOW=ON -DWASMEDGE_PLUGIN_TENSORFLOWLITE=ON -DWASMEDGE_PLUGIN_IMAGE=ON -DWASMEDGE_PLUGIN_OPENCVMINI=ON -DWASMEDGE_PLUGIN_ZLIB=ON + tar_names: wasi_crypto wasi_logging wasmedge_rustls wasmedge_tensorflow wasmedge_tensorflowlite wasmedge_image wasmedge_opencvmini wasmedge_zlib + output_bins: libwasmedgePluginWasiCrypto.dylib libwasmedgePluginWasiLogging.dylib libwasmedge_rustls.dylib libwasmedgePluginWasmEdgeTensorflow.dylib libwasmedgePluginWasmEdgeTensorflowLite.dylib libwasmedgePluginWasmEdgeImage.dylib libwasmedgePluginWasmEdgeOpenCVMini.dylib libwasmedgePluginWasmEdgeZlib.so needs: create_release steps: - name: Checkout code @@ -633,6 +645,13 @@ jobs: eval $(/opt/homebrew/bin/brew shellenv) mv plugin_wasmedge_opencvmini.tar.gz WasmEdge-plugin-wasmedge_opencvmini-${{ needs.create_release.outputs.version }}-darwin_${{ matrix.arch }}.tar.gz gh release upload ${{ needs.create_release.outputs.version }} WasmEdge-plugin-wasmedge_opencvmini-${{ needs.create_release.outputs.version }}-darwin_${{ matrix.arch }}.tar.gz --clobber + - name: Upload wasmedge_zlib plugin tar.gz package + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + run: | + eval $(/opt/homebrew/bin/brew shellenv) + mv plugin_wasmedge_zlib.tar.gz WasmEdge-plugin-wasmedge_zlib-${{ needs.create_release.outputs.version }}-darwin_${{ matrix.arch }}.tar.gz + gh release upload ${{ needs.create_release.outputs.version }} WasmEdge-plugin-wasmedge_zlib-${{ needs.create_release.outputs.version }}-darwin_${{ matrix.arch }}.tar.gz --clobber build_manylinux2014_runtime_only: name: Build runtime only on manylinux2014 platform From df4314f5e13fe676fb727bb8f0d01a591d7fec04 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Sat, 9 Sep 2023 05:43:50 +0530 Subject: [PATCH 81/98] Added deflatesetheader & inflategetheader. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibenv.h | 6 ++++ plugins/wasmedge_zlib/zlibfunc.cpp | 58 ++++++++++++++++++++++++++++++ plugins/wasmedge_zlib/zlibfunc.h | 18 ++++++++++ 3 files changed, 82 insertions(+) diff --git a/plugins/wasmedge_zlib/zlibenv.h b/plugins/wasmedge_zlib/zlibenv.h index f876079d08e0..18b34153042e 100644 --- a/plugins/wasmedge_zlib/zlibenv.h +++ b/plugins/wasmedge_zlib/zlibenv.h @@ -83,9 +83,15 @@ class WasmEdgeZlibEnvironment { public: using GZFile_s = std::remove_pointer_t; + struct GZStore { + uint32_t WasmGZHeaderOffset; + std::unique_ptr HostGZHeader; + }; + std::unordered_map> ZStreamMap; std::map, std::greater> GZFileMap; + std::unordered_map GZHeaderMap; /// Initial Configurations static Plugin::PluginRegister Register; diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index fb58f6086793..3f4d075d0a70 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -387,6 +387,35 @@ WasmEdgeZlibDeflatePrime::body(const Runtime::CallingFrame &Frame, return ZRes; } +Expect +WasmEdgeZlibDeflateSetHeader::body(const Runtime::CallingFrame &Frame, + uint32_t ZStreamPtr, uint32_t HeadPtr) { + + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto HostGZHeader = std::make_unique(); + + auto [It, _] = Env.GZHeaderMap.emplace( + std::pair{ + ZStreamPtr, WasmEdgeZlibEnvironment::GZStore{ + .WasmGZHeaderOffset = HeadPtr, + .HostGZHeader = std::move(HostGZHeader)}}); + + const int32_t ZRes = + SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { + return deflateSetHeader(HostZStreamIt->second.get(), + HostGZHeader.get()); + }); + + if (ZRes != Z_OK) + Env.GZHeaderMap.erase(It); + + return ZRes; +} + Expect WasmEdgeZlibInflateInit2::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t WindowBits) { @@ -564,6 +593,35 @@ WasmEdgeZlibInflateMark::body(const Runtime::CallingFrame &Frame, return ZRes; } +Expect +WasmEdgeZlibInflateGetHeader::body(const Runtime::CallingFrame &Frame, + uint32_t ZStreamPtr, uint32_t HeadPtr) { + + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + + auto HostGZHeader = std::make_unique(); + + auto [It, _] = Env.GZHeaderMap.emplace( + std::pair{ + ZStreamPtr, WasmEdgeZlibEnvironment::GZStore{ + .WasmGZHeaderOffset = HeadPtr, + .HostGZHeader = std::move(HostGZHeader)}}); + + const int32_t ZRes = + SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { + return inflateGetHeader(HostZStreamIt->second.get(), + HostGZHeader.get()); + }); + + if (ZRes != Z_OK) + Env.GZHeaderMap.erase(It); + + return ZRes; +} + Expect WasmEdgeZlibInflateBackInit::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t WindowBits, diff --git a/plugins/wasmedge_zlib/zlibfunc.h b/plugins/wasmedge_zlib/zlibfunc.h index a02bf09efbfd..1a7c1fb0b437 100644 --- a/plugins/wasmedge_zlib/zlibfunc.h +++ b/plugins/wasmedge_zlib/zlibfunc.h @@ -149,6 +149,15 @@ class WasmEdgeZlibDeflatePrime : public WasmEdgeZlib { int32_t Bits, int32_t Value); }; +class WasmEdgeZlibDeflateSetHeader + : public WasmEdgeZlib { +public: + WasmEdgeZlibDeflateSetHeader(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + uint32_t HeadPtr); +}; + class WasmEdgeZlibInflateInit2 : public WasmEdgeZlib { public: WasmEdgeZlibInflateInit2(WasmEdgeZlibEnvironment &HostEnv) @@ -221,6 +230,15 @@ class WasmEdgeZlibInflateMark : public WasmEdgeZlib { Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr); }; +class WasmEdgeZlibInflateGetHeader + : public WasmEdgeZlib { +public: + WasmEdgeZlibInflateGetHeader(WasmEdgeZlibEnvironment &HostEnv) + : WasmEdgeZlib(HostEnv) {} + Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, + uint32_t HeadPtr); +}; + class WasmEdgeZlibInflateBackInit : public WasmEdgeZlib { public: From 03a15ead8ba176211e504f73f7ec1b3fd943ed78 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Sat, 9 Sep 2023 06:18:37 +0530 Subject: [PATCH 82/98] Change return type of SyncRun. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 98 +++++++++++++++--------------- 1 file changed, 49 insertions(+), 49 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 3f4d075d0a70..2ac6a3004acf 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -18,7 +18,8 @@ static constexpr uint32_t WasmGZFileStart = sizeof(gzFile); template auto SyncRun(z_stream *HostZStream, uint32_t ZStreamPtr, - const Runtime::CallingFrame &Frame, T Callback) { + const Runtime::CallingFrame &Frame, T Callback) + -> Expect { auto *MemInst = Frame.getMemoryByIndex(0); /* if (MemInst == nullptr) { return Unexpect(ErrCode::Value::HostFuncError); @@ -78,7 +79,7 @@ WasmEdgeZlibDeflateInit::body(const Runtime::CallingFrame &Frame, HostZStream->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored - const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { + const auto ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { return deflateInit(HostZStream.get(), Level); }); @@ -96,7 +97,7 @@ Expect WasmEdgeZlibDeflate::WasmEdgeZlibDeflate::body( return Unexpect(ErrCode::Value::HostFuncError); } - const int32_t ZRes = + const auto ZRes = SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { return deflate(HostZStreamIt->second.get(), Flush); }); @@ -111,7 +112,7 @@ Expect WasmEdgeZlibDeflateEnd::body(const Runtime::CallingFrame &Frame, return Unexpect(ErrCode::Value::HostFuncError); } - const int32_t ZRes = + const auto ZRes = SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { return deflateEnd(HostZStreamIt->second.get()); }); @@ -131,9 +132,8 @@ WasmEdgeZlibInflateInit::body(const Runtime::CallingFrame &Frame, HostZStream->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored - const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { - return inflateInit(HostZStream.get()); - }); + const auto ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, + [&]() { return inflateInit(HostZStream.get()); }); if (ZRes == Z_OK) Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); @@ -149,7 +149,7 @@ Expect WasmEdgeZlibInflate::body(const Runtime::CallingFrame &Frame, return Unexpect(ErrCode::Value::HostFuncError); } - const int32_t ZRes = + const auto ZRes = SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { return inflate(HostZStreamIt->second.get(), Flush); }); @@ -164,7 +164,7 @@ Expect WasmEdgeZlibInflateEnd::body(const Runtime::CallingFrame &Frame, return Unexpect(ErrCode::Value::HostFuncError); } - const int32_t ZRes = + const auto ZRes = SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { return inflateEnd(HostZStreamIt->second.get()); }); @@ -183,7 +183,7 @@ Expect WasmEdgeZlibDeflateInit2::body( HostZStream->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored - const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { + const auto ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { return deflateInit2(HostZStream.get(), Level, Method, WindowBits, MemLevel, Strategy); }); @@ -210,7 +210,7 @@ Expect WasmEdgeZlibDeflateSetDictionary::body( const auto *Dictionary = MemInst->getPointer(DictionaryPtr); - const int32_t ZRes = + const auto ZRes = SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { return deflateSetDictionary(HostZStreamIt->second.get(), Dictionary, DictLength); @@ -236,7 +236,7 @@ Expect WasmEdgeZlibDeflateGetDictionary::body( auto *Dictionary = MemInst->getPointer(DictionaryPtr); auto *DictLength = MemInst->getPointer(DictLengthPtr); - const int32_t ZRes = + const auto ZRes = SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { return deflateGetDictionary(HostZStreamIt->second.get(), Dictionary, DictLength); @@ -264,7 +264,7 @@ WasmEdgeZlibDeflateCopy::body(const Runtime::CallingFrame &Frame, SyncRun(SourceZStreamIt->second.get(), SourcePtr, Frame, []() { return 0; }); - const int32_t ZRes = SyncRun(DestZStream.get(), DestPtr, Frame, [&]() { + const auto ZRes = SyncRun(DestZStream.get(), DestPtr, Frame, [&]() { return deflateCopy(DestZStream.get(), SourceZStreamIt->second.get()); }); @@ -283,7 +283,7 @@ WasmEdgeZlibDeflateReset::body(const Runtime::CallingFrame &Frame, return Unexpect(ErrCode::Value::HostFuncError); } - const int32_t ZRes = + const auto ZRes = SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { return deflateReset(HostZStreamIt->second.get()); }); @@ -300,7 +300,7 @@ WasmEdgeZlibDeflateParams::body(const Runtime::CallingFrame &Frame, return Unexpect(ErrCode::Value::HostFuncError); } - const int32_t ZRes = + const auto ZRes = SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { return deflateParams(HostZStreamIt->second.get(), Level, Strategy); }); @@ -317,7 +317,7 @@ Expect WasmEdgeZlibDeflateTune::body( return Unexpect(ErrCode::Value::HostFuncError); } - const int32_t ZRes = + const auto ZRes = SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { return deflateTune(HostZStreamIt->second.get(), GoodLength, MaxLazy, NiceLength, MaxChain); @@ -335,7 +335,7 @@ WasmEdgeZlibDeflateBound::body(const Runtime::CallingFrame &Frame, return Unexpect(ErrCode::Value::HostFuncError); } - const int32_t ZRes = + const auto ZRes = SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { return deflateBound(HostZStreamIt->second.get(), SourceLen); }); @@ -361,7 +361,7 @@ WasmEdgeZlibDeflatePending::body(const Runtime::CallingFrame &Frame, auto *Pending = MemInst->getPointer(PendingPtr); auto *Bits = MemInst->getPointer(BitsPtr); - const int32_t ZRes = + const auto ZRes = SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { return deflatePending(HostZStreamIt->second.get(), Pending, Bits); }); @@ -379,7 +379,7 @@ WasmEdgeZlibDeflatePrime::body(const Runtime::CallingFrame &Frame, return Unexpect(ErrCode::Value::HostFuncError); } - const int32_t ZRes = + const auto ZRes = SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { return deflatePrime(HostZStreamIt->second.get(), Bits, Value); }); @@ -404,7 +404,7 @@ WasmEdgeZlibDeflateSetHeader::body(const Runtime::CallingFrame &Frame, .WasmGZHeaderOffset = HeadPtr, .HostGZHeader = std::move(HostGZHeader)}}); - const int32_t ZRes = + const auto ZRes = SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { return deflateSetHeader(HostZStreamIt->second.get(), HostGZHeader.get()); @@ -426,7 +426,7 @@ WasmEdgeZlibInflateInit2::body(const Runtime::CallingFrame &Frame, HostZStream->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored - const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { + const auto ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { return inflateInit2(HostZStream.get(), WindowBits); }); @@ -452,7 +452,7 @@ Expect WasmEdgeZlibInflateSetDictionary::body( auto *Dictionary = MemInst->getPointer(DictionaryPtr); - const int32_t ZRes = + const auto ZRes = SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { return inflateSetDictionary(HostZStreamIt->second.get(), Dictionary, DictLength); @@ -478,7 +478,7 @@ Expect WasmEdgeZlibInflateGetDictionary::body( auto *Dictionary = MemInst->getPointer(DictionaryPtr); auto *DictLength = MemInst->getPointer(DictLengthPtr); - const int32_t ZRes = + const auto ZRes = SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { return inflateGetDictionary(HostZStreamIt->second.get(), Dictionary, DictLength); @@ -496,7 +496,7 @@ WasmEdgeZlibInflateSync::body(const Runtime::CallingFrame &Frame, return Unexpect(ErrCode::Value::HostFuncError); } - const int32_t ZRes = + const auto ZRes = SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { return inflateSync(HostZStreamIt->second.get()); }); @@ -516,7 +516,7 @@ WasmEdgeZlibInflateCopy::body(const Runtime::CallingFrame &Frame, SyncRun(SourceZStreamIt->second.get(), SourcePtr, Frame, []() { return 0; }); - const int32_t ZRes = SyncRun(DestZStream.get(), DestPtr, Frame, [&]() { + const auto ZRes = SyncRun(DestZStream.get(), DestPtr, Frame, [&]() { return inflateCopy(DestZStream.get(), SourceZStreamIt->second.get()); }); @@ -535,7 +535,7 @@ WasmEdgeZlibInflateReset::body(const Runtime::CallingFrame &Frame, return Unexpect(ErrCode::Value::HostFuncError); } - const int32_t ZRes = + const auto ZRes = SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { return inflateReset(HostZStreamIt->second.get()); }); @@ -551,7 +551,7 @@ WasmEdgeZlibInflateReset2::body(const Runtime::CallingFrame &Frame, return Unexpect(ErrCode::Value::HostFuncError); } - const int32_t ZRes = + const auto ZRes = SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { return inflateReset2(HostZStreamIt->second.get(), WindowBits); }); @@ -569,7 +569,7 @@ WasmEdgeZlibInflatePrime::body(const Runtime::CallingFrame &Frame, return Unexpect(ErrCode::Value::HostFuncError); } - const int32_t ZRes = + const auto ZRes = SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { return inflatePrime(HostZStreamIt->second.get(), Bits, Value); }); @@ -586,7 +586,7 @@ WasmEdgeZlibInflateMark::body(const Runtime::CallingFrame &Frame, return Unexpect(ErrCode::Value::HostFuncError); } - const int32_t ZRes = + const auto ZRes = SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { return inflateMark(HostZStreamIt->second.get()); }); @@ -610,7 +610,7 @@ WasmEdgeZlibInflateGetHeader::body(const Runtime::CallingFrame &Frame, .WasmGZHeaderOffset = HeadPtr, .HostGZHeader = std::move(HostGZHeader)}}); - const int32_t ZRes = + const auto ZRes = SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { return inflateGetHeader(HostZStreamIt->second.get(), HostGZHeader.get()); @@ -640,7 +640,7 @@ WasmEdgeZlibInflateBackInit::body(const Runtime::CallingFrame &Frame, auto *Window = MemInst->getPointer(WindowPtr); - const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { + const auto ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { return inflateBackInit(HostZStream.get(), WindowBits, Window); }); @@ -658,7 +658,7 @@ WasmEdgeZlibInflateBackEnd::body(const Runtime::CallingFrame &Frame, return Unexpect(ErrCode::Value::HostFuncError); } - const int32_t ZRes = + const auto ZRes = SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { return inflateBackEnd(HostZStreamIt->second.get()); }); @@ -670,7 +670,7 @@ WasmEdgeZlibInflateBackEnd::body(const Runtime::CallingFrame &Frame, Expect WasmEdgeZlibZlibCompilerFlags::body(const Runtime::CallingFrame &) { - const int32_t ZRes = zlibCompileFlags(); + const auto ZRes = zlibCompileFlags(); return ZRes; } @@ -691,7 +691,7 @@ Expect WasmEdgeZlibCompress::body(const Runtime::CallingFrame &Frame, unsigned long HostDestLen; HostDestLen = *DestLen; - const int32_t ZRes = compress(Dest, &HostDestLen, Source, SourceLen); + const auto ZRes = compress(Dest, &HostDestLen, Source, SourceLen); *DestLen = HostDestLen; return ZRes; @@ -714,7 +714,7 @@ Expect WasmEdgeZlibCompress2::body(const Runtime::CallingFrame &Frame, unsigned long HostDestLen; HostDestLen = *DestLen; - const int32_t ZRes = compress2(Dest, &HostDestLen, Source, SourceLen, Level); + const auto ZRes = compress2(Dest, &HostDestLen, Source, SourceLen, Level); *DestLen = HostDestLen; return ZRes; @@ -722,7 +722,7 @@ Expect WasmEdgeZlibCompress2::body(const Runtime::CallingFrame &Frame, Expect WasmEdgeZlibCompressBound::body(const Runtime::CallingFrame &, uint32_t SourceLen) { - const int32_t ZRes = compressBound(SourceLen); + const auto ZRes = compressBound(SourceLen); return ZRes; } @@ -744,7 +744,7 @@ Expect WasmEdgeZlibUncompress::body(const Runtime::CallingFrame &Frame, unsigned long HostDestLen; HostDestLen = *DestLen; - const int32_t ZRes = uncompress(Dest, &HostDestLen, Source, SourceLen); + const auto ZRes = uncompress(Dest, &HostDestLen, Source, SourceLen); *DestLen = HostDestLen; return ZRes; @@ -768,7 +768,7 @@ WasmEdgeZlibUncompress2::body(const Runtime::CallingFrame &Frame, unsigned long HostDestLen, HostSourceLen; HostDestLen = *DestLen; HostSourceLen = *SourceLen; - const int32_t ZRes = uncompress2(Dest, &HostDestLen, Source, &HostSourceLen); + const auto ZRes = uncompress2(Dest, &HostDestLen, Source, &HostSourceLen); *DestLen = HostDestLen; *SourceLen = HostSourceLen; @@ -1151,7 +1151,7 @@ Expect WasmEdgeZlibAdler32::body(const Runtime::CallingFrame &Frame, auto *Buf = MemInst->getPointer(BufPtr); - const int32_t ZRes = adler32(Adler, Buf, Len); + const auto ZRes = adler32(Adler, Buf, Len); return ZRes; } @@ -1166,7 +1166,7 @@ Expect WasmEdgeZlibAdler32_z::body(const Runtime::CallingFrame &Frame, auto *Buf = MemInst->getPointer(BufPtr); - const int32_t ZRes = adler32_z(Adler, Buf, Len); + const auto ZRes = adler32_z(Adler, Buf, Len); return ZRes; } @@ -1175,7 +1175,7 @@ Expect WasmEdgeZlibAdler32Combine::body(const Runtime::CallingFrame &, uint32_t Adler2, int32_t Len2) { - const int32_t ZRes = adler32_combine(Adler1, Adler2, Len2); + const auto ZRes = adler32_combine(Adler1, Adler2, Len2); return ZRes; } @@ -1190,7 +1190,7 @@ Expect WasmEdgeZlibCRC32::body(const Runtime::CallingFrame &Frame, auto *Buf = MemInst->getPointer(BufPtr); - const int32_t ZRes = crc32(CRC, Buf, Len); + const auto ZRes = crc32(CRC, Buf, Len); return ZRes; } @@ -1206,7 +1206,7 @@ Expect WasmEdgeZlibCRC32_z::body(const Runtime::CallingFrame &Frame, auto *Buf = MemInst->getPointer(BufPtr); - const int32_t ZRes = crc32_z(CRC, Buf, Len); + const auto ZRes = crc32_z(CRC, Buf, Len); return ZRes; } @@ -1215,7 +1215,7 @@ Expect WasmEdgeZlibCRC32Combine::body(const Runtime::CallingFrame &, uint32_t CRC1, uint32_t CRC2, int32_t Len2) { - const int32_t ZRes = crc32_combine(CRC1, CRC2, Len2); + const auto ZRes = crc32_combine(CRC1, CRC2, Len2); return ZRes; } @@ -1241,7 +1241,7 @@ WasmEdgeZlibDeflateInit_::body(const Runtime::CallingFrame &Frame, // ignore opaque since zmalloc and zfree was ignored HostZStream->opaque = Z_NULL; - const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { + const auto ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { return deflateInit_(HostZStream.get(), Level, WasmZlibVersion, sizeof(z_stream)); }); @@ -1274,7 +1274,7 @@ WasmEdgeZlibInflateInit_::body(const Runtime::CallingFrame &Frame, // ignore opaque since zmalloc and zfree was ignored HostZStream->opaque = Z_NULL; - const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { + const auto ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { return inflateInit_(HostZStream.get(), WasmZlibVersion, sizeof(z_stream)); }); @@ -1304,7 +1304,7 @@ Expect WasmEdgeZlibDeflateInit2_::body( HostZStream->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored - const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { + const auto ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { return deflateInit2_(HostZStream.get(), Level, Method, WindowBits, MemLevel, Strategy, WasmZlibVersion, sizeof(z_stream)); }); @@ -1335,7 +1335,7 @@ WasmEdgeZlibInflateInit2_::body(const Runtime::CallingFrame &Frame, HostZStream->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored - const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { + const auto ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { return inflateInit2_(HostZStream.get(), WindowBits, WasmZlibVersion, sizeof(z_stream)); }); @@ -1366,7 +1366,7 @@ Expect WasmEdgeZlibInflateBackInit_::body( HostZStream->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored - const int32_t ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { + const auto ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { return inflateBackInit_(HostZStream.get(), WindowBits, Window, WasmZlibVersion, sizeof(z_stream)); }); From a49a4ab5f894cc180e80114bf4864f31aedf5e18 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Sat, 9 Sep 2023 07:09:57 +0530 Subject: [PATCH 83/98] SyncRun Func Design & Params Overhaul. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 466 ++++++++++------------------- 1 file changed, 164 insertions(+), 302 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 2ac6a3004acf..390f2ce59c62 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -17,16 +17,21 @@ constexpr bool CheckSize(int32_t StreamSize) { static constexpr uint32_t WasmGZFileStart = sizeof(gzFile); template -auto SyncRun(z_stream *HostZStream, uint32_t ZStreamPtr, +auto SyncRun(WasmEdgeZlibEnvironment &Env, uint32_t ZStreamPtr, const Runtime::CallingFrame &Frame, T Callback) -> Expect { auto *MemInst = Frame.getMemoryByIndex(0); - /* if (MemInst == nullptr) { + if (MemInst == nullptr) { return Unexpect(ErrCode::Value::HostFuncError); - } */ - + } WasmZStream *ModuleZStream = MemInst->getPointer(ZStreamPtr); + const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); + if (HostZStreamIt == Env.ZStreamMap.end()) { + return Unexpect(ErrCode::Value::HostFuncError); + } + auto HostZStream = HostZStreamIt->second.get(); + HostZStream->next_in = MemInst->getPointer(ModuleZStream->NextIn); HostZStream->avail_in = ModuleZStream->AvailIn; @@ -48,7 +53,7 @@ auto SyncRun(z_stream *HostZStream, uint32_t ZStreamPtr, const auto PreComputeNextIn = HostZStream->next_in; const auto PreComputeNextOut = HostZStream->next_out; - const auto ZRes = Callback(); + const auto ZRes = Callback(HostZStream); ModuleZStream->NextIn += HostZStream->next_in - PreComputeNextIn; ModuleZStream->AvailIn = HostZStream->avail_in; @@ -79,12 +84,15 @@ WasmEdgeZlibDeflateInit::body(const Runtime::CallingFrame &Frame, HostZStream->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored - const auto ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { - return deflateInit(HostZStream.get(), Level); + auto [It, _] = Env.ZStreamMap.emplace( + std::make_pair(ZStreamPtr, std::move(HostZStream))); + + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return deflateInit(HostZStream, Level); }); - if (ZRes == Z_OK) - Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); + if (ZRes != Z_OK) + Env.ZStreamMap.erase(It); return ZRes; } @@ -92,14 +100,9 @@ WasmEdgeZlibDeflateInit::body(const Runtime::CallingFrame &Frame, Expect WasmEdgeZlibDeflate::WasmEdgeZlibDeflate::body( const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t Flush) { - const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); - if (HostZStreamIt == Env.ZStreamMap.end()) { - return Unexpect(ErrCode::Value::HostFuncError); - } - - const auto ZRes = - SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, - [&]() { return deflate(HostZStreamIt->second.get(), Flush); }); + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return deflate(HostZStream, Flush); + }); return ZRes; } @@ -107,14 +110,9 @@ Expect WasmEdgeZlibDeflate::WasmEdgeZlibDeflate::body( Expect WasmEdgeZlibDeflateEnd::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr) { - const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); - if (HostZStreamIt == Env.ZStreamMap.end()) { - return Unexpect(ErrCode::Value::HostFuncError); - } - - const auto ZRes = - SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, - [&]() { return deflateEnd(HostZStreamIt->second.get()); }); + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return deflateEnd(HostZStream); + }); if (ZRes == Z_OK) Env.ZStreamMap.erase(ZStreamPtr); @@ -132,11 +130,15 @@ WasmEdgeZlibInflateInit::body(const Runtime::CallingFrame &Frame, HostZStream->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored - const auto ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, - [&]() { return inflateInit(HostZStream.get()); }); + auto [It, _] = Env.ZStreamMap.emplace( + std::make_pair(ZStreamPtr, std::move(HostZStream))); - if (ZRes == Z_OK) - Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return inflateInit(HostZStream); + }); + + if (ZRes != Z_OK) + Env.ZStreamMap.erase(It); return ZRes; } @@ -144,14 +146,9 @@ WasmEdgeZlibInflateInit::body(const Runtime::CallingFrame &Frame, Expect WasmEdgeZlibInflate::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t Flush) { - const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); - if (HostZStreamIt == Env.ZStreamMap.end()) { - return Unexpect(ErrCode::Value::HostFuncError); - } - - const auto ZRes = - SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, - [&]() { return inflate(HostZStreamIt->second.get(), Flush); }); + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return inflate(HostZStream, Flush); + }); return ZRes; } @@ -159,14 +156,9 @@ Expect WasmEdgeZlibInflate::body(const Runtime::CallingFrame &Frame, Expect WasmEdgeZlibInflateEnd::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr) { - const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); - if (HostZStreamIt == Env.ZStreamMap.end()) { - return Unexpect(ErrCode::Value::HostFuncError); - } - - const auto ZRes = - SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, - [&]() { return inflateEnd(HostZStreamIt->second.get()); }); + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return inflateEnd(HostZStream); + }); Env.ZStreamMap.erase(ZStreamPtr); @@ -183,13 +175,16 @@ Expect WasmEdgeZlibDeflateInit2::body( HostZStream->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored - const auto ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { - return deflateInit2(HostZStream.get(), Level, Method, WindowBits, MemLevel, + auto [It, _] = Env.ZStreamMap.emplace( + std::make_pair(ZStreamPtr, std::move(HostZStream))); + + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return deflateInit2(HostZStream, Level, Method, WindowBits, MemLevel, Strategy); }); - if (ZRes == Z_OK) - Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); + if (ZRes != Z_OK) + Env.ZStreamMap.erase(It); return ZRes; } @@ -198,11 +193,6 @@ Expect WasmEdgeZlibDeflateSetDictionary::body( const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, uint32_t DictionaryPtr, uint32_t DictLength) { - const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); - if (HostZStreamIt == Env.ZStreamMap.end()) { - return Unexpect(ErrCode::Value::HostFuncError); - } - auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { return Unexpect(ErrCode::Value::HostFuncError); @@ -210,11 +200,9 @@ Expect WasmEdgeZlibDeflateSetDictionary::body( const auto *Dictionary = MemInst->getPointer(DictionaryPtr); - const auto ZRes = - SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { - return deflateSetDictionary(HostZStreamIt->second.get(), Dictionary, - DictLength); - }); + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return deflateSetDictionary(HostZStream, Dictionary, DictLength); + }); return ZRes; } @@ -223,11 +211,6 @@ Expect WasmEdgeZlibDeflateGetDictionary::body( const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, uint32_t DictionaryPtr, uint32_t DictLengthPtr) { - const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); - if (HostZStreamIt == Env.ZStreamMap.end()) { - return Unexpect(ErrCode::Value::HostFuncError); - } - auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { return Unexpect(ErrCode::Value::HostFuncError); @@ -236,11 +219,9 @@ Expect WasmEdgeZlibDeflateGetDictionary::body( auto *Dictionary = MemInst->getPointer(DictionaryPtr); auto *DictLength = MemInst->getPointer(DictLengthPtr); - const auto ZRes = - SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { - return deflateGetDictionary(HostZStreamIt->second.get(), Dictionary, - DictLength); - }); + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return deflateGetDictionary(HostZStream, Dictionary, DictLength); + }); return ZRes; } @@ -254,7 +235,6 @@ source to the uninitialized z_stream structure referenced by dest." Expect WasmEdgeZlibDeflateCopy::body(const Runtime::CallingFrame &Frame, uint32_t DestPtr, uint32_t SourcePtr) { - const auto SourceZStreamIt = Env.ZStreamMap.find(SourcePtr); if (SourceZStreamIt == Env.ZStreamMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); @@ -262,14 +242,17 @@ WasmEdgeZlibDeflateCopy::body(const Runtime::CallingFrame &Frame, auto DestZStream = std::make_unique(); - SyncRun(SourceZStreamIt->second.get(), SourcePtr, Frame, []() { return 0; }); + auto [It, _] = + Env.ZStreamMap.emplace(std::make_pair(DestPtr, std::move(DestZStream))); + + SyncRun(Env, DestPtr, Frame, [&](z_stream *) { return 0; }); - const auto ZRes = SyncRun(DestZStream.get(), DestPtr, Frame, [&]() { - return deflateCopy(DestZStream.get(), SourceZStreamIt->second.get()); + const auto ZRes = SyncRun(Env, DestPtr, Frame, [&](z_stream *DestZStream) { + return deflateCopy(DestZStream, SourceZStreamIt->second.get()); }); - if (ZRes == Z_OK) - Env.ZStreamMap.emplace(std::make_pair(DestPtr, std::move(DestZStream))); + if (ZRes != Z_OK) + Env.ZStreamMap.erase(It); return ZRes; } @@ -278,14 +261,9 @@ Expect WasmEdgeZlibDeflateReset::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr) { - const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); - if (HostZStreamIt == Env.ZStreamMap.end()) { - return Unexpect(ErrCode::Value::HostFuncError); - } - - const auto ZRes = - SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, - [&]() { return deflateReset(HostZStreamIt->second.get()); }); + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return deflateReset(HostZStream); + }); return ZRes; } @@ -295,15 +273,9 @@ WasmEdgeZlibDeflateParams::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t Level, int32_t Strategy) { - const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); - if (HostZStreamIt == Env.ZStreamMap.end()) { - return Unexpect(ErrCode::Value::HostFuncError); - } - - const auto ZRes = - SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { - return deflateParams(HostZStreamIt->second.get(), Level, Strategy); - }); + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return deflateParams(HostZStream, Level, Strategy); + }); return ZRes; } @@ -312,16 +284,9 @@ Expect WasmEdgeZlibDeflateTune::body( const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t GoodLength, int32_t MaxLazy, int32_t NiceLength, int32_t MaxChain) { - const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); - if (HostZStreamIt == Env.ZStreamMap.end()) { - return Unexpect(ErrCode::Value::HostFuncError); - } - - const auto ZRes = - SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { - return deflateTune(HostZStreamIt->second.get(), GoodLength, MaxLazy, - NiceLength, MaxChain); - }); + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return deflateTune(HostZStream, GoodLength, MaxLazy, NiceLength, MaxChain); + }); return ZRes; } @@ -330,15 +295,9 @@ Expect WasmEdgeZlibDeflateBound::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, uint32_t SourceLen) { - const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); - if (HostZStreamIt == Env.ZStreamMap.end()) { - return Unexpect(ErrCode::Value::HostFuncError); - } - - const auto ZRes = - SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { - return deflateBound(HostZStreamIt->second.get(), SourceLen); - }); + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return deflateBound(HostZStream, SourceLen); + }); return ZRes; } @@ -348,11 +307,6 @@ WasmEdgeZlibDeflatePending::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, uint32_t PendingPtr, uint32_t BitsPtr) { - const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); - if (HostZStreamIt == Env.ZStreamMap.end()) { - return Unexpect(ErrCode::Value::HostFuncError); - } - auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { return Unexpect(ErrCode::Value::HostFuncError); @@ -361,10 +315,9 @@ WasmEdgeZlibDeflatePending::body(const Runtime::CallingFrame &Frame, auto *Pending = MemInst->getPointer(PendingPtr); auto *Bits = MemInst->getPointer(BitsPtr); - const auto ZRes = - SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { - return deflatePending(HostZStreamIt->second.get(), Pending, Bits); - }); + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return deflatePending(HostZStream, Pending, Bits); + }); return ZRes; } @@ -374,15 +327,9 @@ WasmEdgeZlibDeflatePrime::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t Bits, int32_t Value) { - const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); - if (HostZStreamIt == Env.ZStreamMap.end()) { - return Unexpect(ErrCode::Value::HostFuncError); - } - - const auto ZRes = - SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { - return deflatePrime(HostZStreamIt->second.get(), Bits, Value); - }); + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return deflatePrime(HostZStream, Bits, Value); + }); return ZRes; } @@ -391,11 +338,6 @@ Expect WasmEdgeZlibDeflateSetHeader::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, uint32_t HeadPtr) { - const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); - if (HostZStreamIt == Env.ZStreamMap.end()) { - return Unexpect(ErrCode::Value::HostFuncError); - } - auto HostGZHeader = std::make_unique(); auto [It, _] = Env.GZHeaderMap.emplace( @@ -404,11 +346,9 @@ WasmEdgeZlibDeflateSetHeader::body(const Runtime::CallingFrame &Frame, .WasmGZHeaderOffset = HeadPtr, .HostGZHeader = std::move(HostGZHeader)}}); - const auto ZRes = - SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { - return deflateSetHeader(HostZStreamIt->second.get(), - HostGZHeader.get()); - }); + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return deflateSetHeader(HostZStream, HostGZHeader.get()); + }); if (ZRes != Z_OK) Env.GZHeaderMap.erase(It); @@ -419,19 +359,21 @@ WasmEdgeZlibDeflateSetHeader::body(const Runtime::CallingFrame &Frame, Expect WasmEdgeZlibInflateInit2::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t WindowBits) { - auto HostZStream = std::make_unique(); HostZStream->zalloc = Z_NULL; HostZStream->zfree = Z_NULL; HostZStream->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored - const auto ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { - return inflateInit2(HostZStream.get(), WindowBits); + auto [It, _] = Env.ZStreamMap.emplace( + std::make_pair(ZStreamPtr, std::move(HostZStream))); + + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return inflateInit2(HostZStream, WindowBits); }); - if (ZRes == Z_OK) - Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); + if (ZRes != Z_OK) + Env.ZStreamMap.erase(It); return ZRes; } @@ -440,11 +382,6 @@ Expect WasmEdgeZlibInflateSetDictionary::body( const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, uint32_t DictionaryPtr, uint32_t DictLength) { - const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); - if (HostZStreamIt == Env.ZStreamMap.end()) { - return Unexpect(ErrCode::Value::HostFuncError); - } - auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { return Unexpect(ErrCode::Value::HostFuncError); @@ -452,11 +389,9 @@ Expect WasmEdgeZlibInflateSetDictionary::body( auto *Dictionary = MemInst->getPointer(DictionaryPtr); - const auto ZRes = - SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { - return inflateSetDictionary(HostZStreamIt->second.get(), Dictionary, - DictLength); - }); + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return inflateSetDictionary(HostZStream, Dictionary, DictLength); + }); return ZRes; } @@ -465,11 +400,6 @@ Expect WasmEdgeZlibInflateGetDictionary::body( const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, uint32_t DictionaryPtr, uint32_t DictLengthPtr) { - const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); - if (HostZStreamIt == Env.ZStreamMap.end()) { - return Unexpect(ErrCode::Value::HostFuncError); - } - auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { return Unexpect(ErrCode::Value::HostFuncError); @@ -478,11 +408,9 @@ Expect WasmEdgeZlibInflateGetDictionary::body( auto *Dictionary = MemInst->getPointer(DictionaryPtr); auto *DictLength = MemInst->getPointer(DictLengthPtr); - const auto ZRes = - SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { - return inflateGetDictionary(HostZStreamIt->second.get(), Dictionary, - DictLength); - }); + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return inflateGetDictionary(HostZStream, Dictionary, DictLength); + }); return ZRes; } @@ -491,14 +419,9 @@ Expect WasmEdgeZlibInflateSync::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr) { - const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); - if (HostZStreamIt == Env.ZStreamMap.end()) { - return Unexpect(ErrCode::Value::HostFuncError); - } - - const auto ZRes = - SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, - [&]() { return inflateSync(HostZStreamIt->second.get()); }); + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return inflateSync(HostZStream); + }); return ZRes; } @@ -506,7 +429,6 @@ WasmEdgeZlibInflateSync::body(const Runtime::CallingFrame &Frame, Expect WasmEdgeZlibInflateCopy::body(const Runtime::CallingFrame &Frame, uint32_t DestPtr, uint32_t SourcePtr) { - const auto SourceZStreamIt = Env.ZStreamMap.find(SourcePtr); if (SourceZStreamIt == Env.ZStreamMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); @@ -514,14 +436,17 @@ WasmEdgeZlibInflateCopy::body(const Runtime::CallingFrame &Frame, auto DestZStream = std::make_unique(); - SyncRun(SourceZStreamIt->second.get(), SourcePtr, Frame, []() { return 0; }); + auto [It, _] = + Env.ZStreamMap.emplace(std::make_pair(DestPtr, std::move(DestZStream))); - const auto ZRes = SyncRun(DestZStream.get(), DestPtr, Frame, [&]() { - return inflateCopy(DestZStream.get(), SourceZStreamIt->second.get()); + SyncRun(Env, DestPtr, Frame, [&](z_stream *) { return 0; }); + + const auto ZRes = SyncRun(Env, DestPtr, Frame, [&](z_stream *DestZStream) { + return inflateCopy(DestZStream, SourceZStreamIt->second.get()); }); - if (ZRes == Z_OK) - Env.ZStreamMap.emplace(std::make_pair(DestPtr, std::move(DestZStream))); + if (ZRes != Z_OK) + Env.ZStreamMap.erase(It); return ZRes; } @@ -530,14 +455,9 @@ Expect WasmEdgeZlibInflateReset::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr) { - const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); - if (HostZStreamIt == Env.ZStreamMap.end()) { - return Unexpect(ErrCode::Value::HostFuncError); - } - - const auto ZRes = - SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, - [&]() { return inflateReset(HostZStreamIt->second.get()); }); + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return inflateReset(HostZStream); + }); return ZRes; } @@ -546,15 +466,9 @@ Expect WasmEdgeZlibInflateReset2::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t WindowBits) { - const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); - if (HostZStreamIt == Env.ZStreamMap.end()) { - return Unexpect(ErrCode::Value::HostFuncError); - } - - const auto ZRes = - SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { - return inflateReset2(HostZStreamIt->second.get(), WindowBits); - }); + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return inflateReset2(HostZStream, WindowBits); + }); return ZRes; } @@ -564,15 +478,9 @@ WasmEdgeZlibInflatePrime::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t Bits, int32_t Value) { - const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); - if (HostZStreamIt == Env.ZStreamMap.end()) { - return Unexpect(ErrCode::Value::HostFuncError); - } - - const auto ZRes = - SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { - return inflatePrime(HostZStreamIt->second.get(), Bits, Value); - }); + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return inflatePrime(HostZStream, Bits, Value); + }); return ZRes; } @@ -581,14 +489,9 @@ Expect WasmEdgeZlibInflateMark::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr) { - const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); - if (HostZStreamIt == Env.ZStreamMap.end()) { - return Unexpect(ErrCode::Value::HostFuncError); - } - - const auto ZRes = - SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, - [&]() { return inflateMark(HostZStreamIt->second.get()); }); + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return inflateMark(HostZStream); + }); return ZRes; } @@ -597,11 +500,6 @@ Expect WasmEdgeZlibInflateGetHeader::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, uint32_t HeadPtr) { - const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); - if (HostZStreamIt == Env.ZStreamMap.end()) { - return Unexpect(ErrCode::Value::HostFuncError); - } - auto HostGZHeader = std::make_unique(); auto [It, _] = Env.GZHeaderMap.emplace( @@ -610,11 +508,9 @@ WasmEdgeZlibInflateGetHeader::body(const Runtime::CallingFrame &Frame, .WasmGZHeaderOffset = HeadPtr, .HostGZHeader = std::move(HostGZHeader)}}); - const auto ZRes = - SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, [&]() { - return inflateGetHeader(HostZStreamIt->second.get(), - HostGZHeader.get()); - }); + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return inflateGetHeader(HostZStream, HostGZHeader.get()); + }); if (ZRes != Z_OK) Env.GZHeaderMap.erase(It); @@ -626,7 +522,6 @@ Expect WasmEdgeZlibInflateBackInit::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t WindowBits, uint32_t WindowPtr) { - auto HostZStream = std::make_unique(); HostZStream->zalloc = Z_NULL; HostZStream->zfree = Z_NULL; @@ -640,12 +535,15 @@ WasmEdgeZlibInflateBackInit::body(const Runtime::CallingFrame &Frame, auto *Window = MemInst->getPointer(WindowPtr); - const auto ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { - return inflateBackInit(HostZStream.get(), WindowBits, Window); + auto [It, _] = Env.ZStreamMap.emplace( + std::make_pair(ZStreamPtr, std::move(HostZStream))); + + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return inflateBackInit(HostZStream, WindowBits, Window); }); - if (ZRes == Z_OK) - Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); + if (ZRes != Z_OK) + Env.ZStreamMap.erase(It); return ZRes; } @@ -653,14 +551,10 @@ WasmEdgeZlibInflateBackInit::body(const Runtime::CallingFrame &Frame, Expect WasmEdgeZlibInflateBackEnd::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr) { - const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); - if (HostZStreamIt == Env.ZStreamMap.end()) { - return Unexpect(ErrCode::Value::HostFuncError); - } - const auto ZRes = - SyncRun(HostZStreamIt->second.get(), ZStreamPtr, Frame, - [&]() { return inflateBackEnd(HostZStreamIt->second.get()); }); + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return inflateBackEnd(HostZStream); + }); Env.ZStreamMap.erase(ZStreamPtr); @@ -669,7 +563,6 @@ WasmEdgeZlibInflateBackEnd::body(const Runtime::CallingFrame &Frame, Expect WasmEdgeZlibZlibCompilerFlags::body(const Runtime::CallingFrame &) { - const auto ZRes = zlibCompileFlags(); return ZRes; } @@ -679,7 +572,6 @@ Expect WasmEdgeZlibCompress::body(const Runtime::CallingFrame &Frame, uint32_t DestLenPtr, uint32_t SourcePtr, uint32_t SourceLen) { - auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { return Unexpect(ErrCode::Value::HostFuncError); @@ -702,7 +594,6 @@ Expect WasmEdgeZlibCompress2::body(const Runtime::CallingFrame &Frame, uint32_t DestLenPtr, uint32_t SourcePtr, uint32_t SourceLen, int32_t Level) { - auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { return Unexpect(ErrCode::Value::HostFuncError); @@ -732,7 +623,6 @@ Expect WasmEdgeZlibUncompress::body(const Runtime::CallingFrame &Frame, uint32_t DestLenPtr, uint32_t SourcePtr, uint32_t SourceLen) { - auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { return Unexpect(ErrCode::Value::HostFuncError); @@ -754,7 +644,6 @@ Expect WasmEdgeZlibUncompress2::body(const Runtime::CallingFrame &Frame, uint32_t DestPtr, uint32_t DestLenPtr, uint32_t SourcePtr, uint32_t SourceLenPtr) { - auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { return Unexpect(ErrCode::Value::HostFuncError); @@ -777,7 +666,6 @@ WasmEdgeZlibUncompress2::body(const Runtime::CallingFrame &Frame, Expect WasmEdgeZlibGZOpen::body(const Runtime::CallingFrame &Frame, uint32_t PathPtr, uint32_t ModePtr) { - auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { return Unexpect(ErrCode::Value::HostFuncError); @@ -800,7 +688,6 @@ Expect WasmEdgeZlibGZOpen::body(const Runtime::CallingFrame &Frame, Expect WasmEdgeZlibGZDOpen::body(const Runtime::CallingFrame &Frame, int32_t FD, uint32_t ModePtr) { - auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { return Unexpect(ErrCode::Value::HostFuncError); @@ -822,7 +709,6 @@ Expect WasmEdgeZlibGZDOpen::body(const Runtime::CallingFrame &Frame, Expect WasmEdgeZlibGZBuffer::body(const Runtime::CallingFrame &, uint32_t GZFile, uint32_t Size) { - const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); @@ -836,7 +722,6 @@ Expect WasmEdgeZlibGZBuffer::body(const Runtime::CallingFrame &, Expect WasmEdgeZlibGZSetParams::body(const Runtime::CallingFrame &, uint32_t GZFile, int32_t Level, int32_t Strategy) { - const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); @@ -850,7 +735,6 @@ Expect WasmEdgeZlibGZSetParams::body(const Runtime::CallingFrame &, Expect WasmEdgeZlibGZRead::body(const Runtime::CallingFrame &Frame, uint32_t GZFile, uint32_t BufPtr, uint32_t Len) { - const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); @@ -871,7 +755,6 @@ Expect WasmEdgeZlibGZRead::body(const Runtime::CallingFrame &Frame, Expect WasmEdgeZlibGZFread::body(const Runtime::CallingFrame &Frame, uint32_t BufPtr, uint32_t Size, uint32_t NItems, uint32_t GZFile) { - const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); @@ -892,7 +775,6 @@ Expect WasmEdgeZlibGZFread::body(const Runtime::CallingFrame &Frame, Expect WasmEdgeZlibGZWrite::body(const Runtime::CallingFrame &Frame, uint32_t GZFile, uint32_t BufPtr, uint32_t Len) { - const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); @@ -913,7 +795,6 @@ Expect WasmEdgeZlibGZWrite::body(const Runtime::CallingFrame &Frame, Expect WasmEdgeZlibGZFwrite::body(const Runtime::CallingFrame &Frame, uint32_t BufPtr, uint32_t Size, uint32_t NItems, uint32_t GZFile) { - const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); @@ -933,7 +814,6 @@ Expect WasmEdgeZlibGZFwrite::body(const Runtime::CallingFrame &Frame, Expect WasmEdgeZlibGZPuts::body(const Runtime::CallingFrame &Frame, uint32_t GZFile, uint32_t StringPtr) { - const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); @@ -953,7 +833,6 @@ Expect WasmEdgeZlibGZPuts::body(const Runtime::CallingFrame &Frame, Expect WasmEdgeZlibGZPutc::body(const Runtime::CallingFrame &, uint32_t GZFile, int32_t C) { - const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); @@ -966,7 +845,6 @@ Expect WasmEdgeZlibGZPutc::body(const Runtime::CallingFrame &, Expect WasmEdgeZlibGZGetc::body(const Runtime::CallingFrame &, uint32_t GZFile) { - const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); @@ -979,7 +857,6 @@ Expect WasmEdgeZlibGZGetc::body(const Runtime::CallingFrame &, Expect WasmEdgeZlibGZUngetc::body(const Runtime::CallingFrame &, int32_t C, uint32_t GZFile) { - const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); @@ -992,7 +869,6 @@ Expect WasmEdgeZlibGZUngetc::body(const Runtime::CallingFrame &, Expect WasmEdgeZlibGZFlush::body(const Runtime::CallingFrame &, uint32_t GZFile, int32_t Flush) { - const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); @@ -1006,7 +882,6 @@ Expect WasmEdgeZlibGZFlush::body(const Runtime::CallingFrame &, Expect WasmEdgeZlibGZSeek::body(const Runtime::CallingFrame &, uint32_t GZFile, int32_t Offset, int32_t Whence) { - const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); @@ -1019,7 +894,6 @@ Expect WasmEdgeZlibGZSeek::body(const Runtime::CallingFrame &, Expect WasmEdgeZlibGZRewind::body(const Runtime::CallingFrame &, uint32_t GZFile) { - const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); @@ -1032,7 +906,6 @@ Expect WasmEdgeZlibGZRewind::body(const Runtime::CallingFrame &, Expect WasmEdgeZlibGZTell::body(const Runtime::CallingFrame &, uint32_t GZFile) { - const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); @@ -1045,7 +918,6 @@ Expect WasmEdgeZlibGZTell::body(const Runtime::CallingFrame &, Expect WasmEdgeZlibGZOffset::body(const Runtime::CallingFrame &, uint32_t GZFile) { - const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); @@ -1058,7 +930,6 @@ Expect WasmEdgeZlibGZOffset::body(const Runtime::CallingFrame &, Expect WasmEdgeZlibGZEof::body(const Runtime::CallingFrame &, uint32_t GZFile) { - const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); @@ -1071,7 +942,6 @@ Expect WasmEdgeZlibGZEof::body(const Runtime::CallingFrame &, Expect WasmEdgeZlibGZDirect::body(const Runtime::CallingFrame &, uint32_t GZFile) { - const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); @@ -1084,7 +954,6 @@ Expect WasmEdgeZlibGZDirect::body(const Runtime::CallingFrame &, Expect WasmEdgeZlibGZClose::body(const Runtime::CallingFrame &, uint32_t GZFile) { - const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); @@ -1099,7 +968,6 @@ Expect WasmEdgeZlibGZClose::body(const Runtime::CallingFrame &, Expect WasmEdgeZlibGZClose_r::body(const Runtime::CallingFrame &, uint32_t GZFile) { - const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); @@ -1114,7 +982,6 @@ Expect WasmEdgeZlibGZClose_r::body(const Runtime::CallingFrame &, Expect WasmEdgeZlibGZClose_w::body(const Runtime::CallingFrame &, uint32_t GZFile) { - const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); @@ -1129,7 +996,6 @@ Expect WasmEdgeZlibGZClose_w::body(const Runtime::CallingFrame &, Expect WasmEdgeZlibGZClearerr::body(const Runtime::CallingFrame &, uint32_t GZFile) { - const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); @@ -1143,7 +1009,6 @@ Expect WasmEdgeZlibGZClearerr::body(const Runtime::CallingFrame &, Expect WasmEdgeZlibAdler32::body(const Runtime::CallingFrame &Frame, uint32_t Adler, uint32_t BufPtr, uint32_t Len) { - auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { return Unexpect(ErrCode::Value::HostFuncError); @@ -1158,7 +1023,6 @@ Expect WasmEdgeZlibAdler32::body(const Runtime::CallingFrame &Frame, Expect WasmEdgeZlibAdler32_z::body(const Runtime::CallingFrame &Frame, uint32_t Adler, uint32_t BufPtr, uint32_t Len) { - auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { return Unexpect(ErrCode::Value::HostFuncError); @@ -1174,7 +1038,6 @@ Expect WasmEdgeZlibAdler32Combine::body(const Runtime::CallingFrame &, uint32_t Adler1, uint32_t Adler2, int32_t Len2) { - const auto ZRes = adler32_combine(Adler1, Adler2, Len2); return ZRes; } @@ -1182,7 +1045,6 @@ Expect WasmEdgeZlibAdler32Combine::body(const Runtime::CallingFrame &, Expect WasmEdgeZlibCRC32::body(const Runtime::CallingFrame &Frame, uint32_t CRC, uint32_t BufPtr, uint32_t Len) { - auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { return Unexpect(ErrCode::Value::HostFuncError); @@ -1198,7 +1060,6 @@ Expect WasmEdgeZlibCRC32::body(const Runtime::CallingFrame &Frame, Expect WasmEdgeZlibCRC32_z::body(const Runtime::CallingFrame &Frame, uint32_t CRC, uint32_t BufPtr, uint32_t Len) { - auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { return Unexpect(ErrCode::Value::HostFuncError); @@ -1214,7 +1075,6 @@ Expect WasmEdgeZlibCRC32_z::body(const Runtime::CallingFrame &Frame, Expect WasmEdgeZlibCRC32Combine::body(const Runtime::CallingFrame &, uint32_t CRC1, uint32_t CRC2, int32_t Len2) { - const auto ZRes = crc32_combine(CRC1, CRC2, Len2); return ZRes; } @@ -1223,7 +1083,6 @@ Expect WasmEdgeZlibDeflateInit_::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t Level, uint32_t VersionPtr, int32_t StreamSize) { - if (!CheckSize(StreamSize)) return static_cast(Z_VERSION_ERROR); @@ -1241,13 +1100,15 @@ WasmEdgeZlibDeflateInit_::body(const Runtime::CallingFrame &Frame, // ignore opaque since zmalloc and zfree was ignored HostZStream->opaque = Z_NULL; - const auto ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { - return deflateInit_(HostZStream.get(), Level, WasmZlibVersion, - sizeof(z_stream)); + auto [It, _] = Env.ZStreamMap.emplace( + std::make_pair(ZStreamPtr, std::move(HostZStream))); + + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return deflateInit_(HostZStream, Level, WasmZlibVersion, sizeof(z_stream)); }); - if (ZRes == Z_OK) - Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); + if (ZRes != Z_OK) + Env.ZStreamMap.erase(It); return ZRes; } @@ -1256,7 +1117,6 @@ Expect WasmEdgeZlibInflateInit_::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, uint32_t VersionPtr, int32_t StreamSize) { - if (!CheckSize(StreamSize)) return static_cast(Z_VERSION_ERROR); @@ -1274,12 +1134,15 @@ WasmEdgeZlibInflateInit_::body(const Runtime::CallingFrame &Frame, // ignore opaque since zmalloc and zfree was ignored HostZStream->opaque = Z_NULL; - const auto ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { - return inflateInit_(HostZStream.get(), WasmZlibVersion, sizeof(z_stream)); + auto [It, _] = Env.ZStreamMap.emplace( + std::make_pair(ZStreamPtr, std::move(HostZStream))); + + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return inflateInit_(HostZStream, WasmZlibVersion, sizeof(z_stream)); }); - if (ZRes == Z_OK) - Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); + if (ZRes != Z_OK) + Env.ZStreamMap.erase(It); return ZRes; } @@ -1288,7 +1151,6 @@ Expect WasmEdgeZlibDeflateInit2_::body( const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t Level, int32_t Method, int32_t WindowBits, int32_t MemLevel, int32_t Strategy, uint32_t VersionPtr, int32_t StreamSize) { - if (!CheckSize(StreamSize)) return static_cast(Z_VERSION_ERROR); @@ -1304,13 +1166,16 @@ Expect WasmEdgeZlibDeflateInit2_::body( HostZStream->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored - const auto ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { - return deflateInit2_(HostZStream.get(), Level, Method, WindowBits, MemLevel, + auto [It, _] = Env.ZStreamMap.emplace( + std::make_pair(ZStreamPtr, std::move(HostZStream))); + + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return deflateInit2_(HostZStream, Level, Method, WindowBits, MemLevel, Strategy, WasmZlibVersion, sizeof(z_stream)); }); - if (ZRes == Z_OK) - Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); + if (ZRes != Z_OK) + Env.ZStreamMap.erase(It); return ZRes; } @@ -1319,7 +1184,6 @@ Expect WasmEdgeZlibInflateInit2_::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t WindowBits, uint32_t VersionPtr, int32_t StreamSize) { - if (!CheckSize(StreamSize)) return static_cast(Z_VERSION_ERROR); @@ -1335,13 +1199,16 @@ WasmEdgeZlibInflateInit2_::body(const Runtime::CallingFrame &Frame, HostZStream->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored - const auto ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { - return inflateInit2_(HostZStream.get(), WindowBits, WasmZlibVersion, + auto [It, _] = Env.ZStreamMap.emplace( + std::make_pair(ZStreamPtr, std::move(HostZStream))); + + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return inflateInit2_(HostZStream, WindowBits, WasmZlibVersion, sizeof(z_stream)); }); - if (ZRes == Z_OK) - Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); + if (ZRes != Z_OK) + Env.ZStreamMap.erase(It); return ZRes; } @@ -1349,7 +1216,6 @@ WasmEdgeZlibInflateInit2_::body(const Runtime::CallingFrame &Frame, Expect WasmEdgeZlibInflateBackInit_::body( const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t WindowBits, uint32_t WindowPtr, uint32_t VersionPtr, int32_t StreamSize) { - if (!CheckSize(StreamSize)) return static_cast(Z_VERSION_ERROR); @@ -1366,20 +1232,22 @@ Expect WasmEdgeZlibInflateBackInit_::body( HostZStream->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored - const auto ZRes = SyncRun(HostZStream.get(), ZStreamPtr, Frame, [&]() { - return inflateBackInit_(HostZStream.get(), WindowBits, Window, - WasmZlibVersion, sizeof(z_stream)); + auto [It, _] = Env.ZStreamMap.emplace( + std::make_pair(ZStreamPtr, std::move(HostZStream))); + + const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { + return inflateBackInit_(HostZStream, WindowBits, Window, WasmZlibVersion, + sizeof(z_stream)); }); - if (ZRes == Z_OK) - Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))); + if (ZRes != Z_OK) + Env.ZStreamMap.erase(It); return ZRes; } Expect WasmEdgeZlibGZGetc_::body(const Runtime::CallingFrame &, uint32_t GZFile) { - const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); @@ -1393,7 +1261,6 @@ Expect WasmEdgeZlibGZGetc_::body(const Runtime::CallingFrame &, Expect WasmEdgeZlibInflateSyncPoint::body(const Runtime::CallingFrame &, uint32_t ZStreamPtr) { - const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); if (HostZStreamIt == Env.ZStreamMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); @@ -1407,7 +1274,6 @@ WasmEdgeZlibInflateSyncPoint::body(const Runtime::CallingFrame &, Expect WasmEdgeZlibInflateUndermine::body(const Runtime::CallingFrame &, uint32_t ZStreamPtr, int32_t Subvert) { - const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); if (HostZStreamIt == Env.ZStreamMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); @@ -1421,7 +1287,6 @@ WasmEdgeZlibInflateUndermine::body(const Runtime::CallingFrame &, Expect WasmEdgeZlibInflateValidate::body(const Runtime::CallingFrame &, uint32_t ZStreamPtr, int32_t Check) { - const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); if (HostZStreamIt == Env.ZStreamMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); @@ -1435,7 +1300,6 @@ Expect WasmEdgeZlibInflateValidate::body(const Runtime::CallingFrame &, Expect WasmEdgeZlibInflateCodesUsed::body(const Runtime::CallingFrame &, uint32_t ZStreamPtr) { - const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); if (HostZStreamIt == Env.ZStreamMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); @@ -1449,7 +1313,6 @@ WasmEdgeZlibInflateCodesUsed::body(const Runtime::CallingFrame &, Expect WasmEdgeZlibInflateResetKeep::body(const Runtime::CallingFrame &, uint32_t ZStreamPtr) { - const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); if (HostZStreamIt == Env.ZStreamMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); @@ -1463,7 +1326,6 @@ WasmEdgeZlibInflateResetKeep::body(const Runtime::CallingFrame &, Expect WasmEdgeZlibDeflateResetKeep::body(const Runtime::CallingFrame &, uint32_t ZStreamPtr) { - const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); if (HostZStreamIt == Env.ZStreamMap.end()) { return Unexpect(ErrCode::Value::HostFuncError); From 20011d07bbed96b9f9f3aca66695ef86a7485c35 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Sat, 9 Sep 2023 07:23:18 +0530 Subject: [PATCH 84/98] Remove access to moved unique_ptr. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 390f2ce59c62..caa2cda540c0 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -20,6 +20,7 @@ template auto SyncRun(WasmEdgeZlibEnvironment &Env, uint32_t ZStreamPtr, const Runtime::CallingFrame &Frame, T Callback) -> Expect { + auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { return Unexpect(ErrCode::Value::HostFuncError); @@ -339,6 +340,7 @@ WasmEdgeZlibDeflateSetHeader::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, uint32_t HeadPtr) { auto HostGZHeader = std::make_unique(); + auto HostGZHeaderPtr = HostGZHeader.get(); auto [It, _] = Env.GZHeaderMap.emplace( std::pair{ @@ -347,7 +349,7 @@ WasmEdgeZlibDeflateSetHeader::body(const Runtime::CallingFrame &Frame, .HostGZHeader = std::move(HostGZHeader)}}); const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return deflateSetHeader(HostZStream, HostGZHeader.get()); + return deflateSetHeader(HostZStream, HostGZHeaderPtr); }); if (ZRes != Z_OK) @@ -501,6 +503,7 @@ WasmEdgeZlibInflateGetHeader::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, uint32_t HeadPtr) { auto HostGZHeader = std::make_unique(); + auto HostGZHeaderPtr = HostGZHeader.get(); auto [It, _] = Env.GZHeaderMap.emplace( std::pair{ @@ -509,7 +512,7 @@ WasmEdgeZlibInflateGetHeader::body(const Runtime::CallingFrame &Frame, .HostGZHeader = std::move(HostGZHeader)}}); const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return inflateGetHeader(HostZStream, HostGZHeader.get()); + return inflateGetHeader(HostZStream, HostGZHeaderPtr); }); if (ZRes != Z_OK) From 1d0d852c224b71c772c62974d0aab80ac52b9976 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Sat, 9 Sep 2023 08:23:21 +0530 Subject: [PATCH 85/98] Added GZHeader Sync steps in SyncRun. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 64 ++++++++++++++++++++++++++++++ 1 file changed, 64 insertions(+) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index caa2cda540c0..d8945dc90cce 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -32,6 +32,7 @@ auto SyncRun(WasmEdgeZlibEnvironment &Env, uint32_t ZStreamPtr, return Unexpect(ErrCode::Value::HostFuncError); } auto HostZStream = HostZStreamIt->second.get(); + const auto GZHeaderStoreIt = Env.GZHeaderMap.find(ZStreamPtr); HostZStream->next_in = MemInst->getPointer(ModuleZStream->NextIn); @@ -54,6 +55,43 @@ auto SyncRun(WasmEdgeZlibEnvironment &Env, uint32_t ZStreamPtr, const auto PreComputeNextIn = HostZStream->next_in; const auto PreComputeNextOut = HostZStream->next_out; + unsigned char *PreComputeExtra{}; + unsigned char *PreComputeName{}; + unsigned char *PreComputeComment{}; + + if (GZHeaderStoreIt != Env.GZHeaderMap.end()) { + // Sync GZ Header + + auto *ModuleGZHeader = MemInst->getPointer( + GZHeaderStoreIt->second.WasmGZHeaderOffset); + auto *HostGZHeader = GZHeaderStoreIt->second.HostGZHeader.get(); + + HostGZHeader->text = ModuleGZHeader->Text; + HostGZHeader->time = ModuleGZHeader->Time; + HostGZHeader->xflags = ModuleGZHeader->XFlags; + HostGZHeader->os = ModuleGZHeader->OS; + + HostGZHeader->extra = + MemInst->getPointer(ModuleGZHeader->Extra); + HostGZHeader->extra_len = ModuleGZHeader->ExtraLen; + HostGZHeader->extra_max = ModuleGZHeader->ExtraMax; + + HostGZHeader->name = + MemInst->getPointer(ModuleGZHeader->Name); + HostGZHeader->name_max = ModuleGZHeader->NameMax; + + HostGZHeader->comment = + MemInst->getPointer(ModuleGZHeader->Comment); + HostGZHeader->comm_max = ModuleGZHeader->CommMax; + + HostGZHeader->hcrc = ModuleGZHeader->HCRC; + HostGZHeader->done = ModuleGZHeader->Done; + + PreComputeExtra = HostGZHeader->extra; + PreComputeName = HostGZHeader->name; + PreComputeComment = HostGZHeader->comment; + } + const auto ZRes = Callback(HostZStream); ModuleZStream->NextIn += HostZStream->next_in - PreComputeNextIn; @@ -72,6 +110,32 @@ auto SyncRun(WasmEdgeZlibEnvironment &Env, uint32_t ZStreamPtr, ModuleZStream->Adler = HostZStream->adler; ModuleZStream->Reserved = HostZStream->reserved; + if (GZHeaderStoreIt != Env.GZHeaderMap.end()) { + // Sync GZ Header + + auto *ModuleGZHeader = MemInst->getPointer( + GZHeaderStoreIt->second.WasmGZHeaderOffset); + auto *HostGZHeader = GZHeaderStoreIt->second.HostGZHeader.get(); + + ModuleGZHeader->Text = HostGZHeader->text; + ModuleGZHeader->Time = HostGZHeader->time; + ModuleGZHeader->XFlags = HostGZHeader->xflags; + ModuleGZHeader->OS = HostGZHeader->os; + + ModuleGZHeader->Extra += HostGZHeader->extra - PreComputeExtra; + ModuleGZHeader->ExtraLen = HostGZHeader->extra_len; + ModuleGZHeader->ExtraMax = HostGZHeader->extra_max; + + ModuleGZHeader->Name += HostGZHeader->name - PreComputeName; + ModuleGZHeader->NameMax = HostGZHeader->name_max; + + ModuleGZHeader->Comment += HostGZHeader->comment - PreComputeComment; + ModuleGZHeader->CommMax = HostGZHeader->comm_max; + + ModuleGZHeader->HCRC = HostGZHeader->hcrc; + ModuleGZHeader->Done = HostGZHeader->done; + } + return ZRes; } From f37a0654feea7d4e79e5bea07a9cedccbf13dfcb Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Sat, 9 Sep 2023 08:26:29 +0530 Subject: [PATCH 86/98] Registered deflateSetHeader | inflateGetHeader. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibmodule.cpp | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/plugins/wasmedge_zlib/zlibmodule.cpp b/plugins/wasmedge_zlib/zlibmodule.cpp index b33cb524923c..ecd2fd6e969d 100644 --- a/plugins/wasmedge_zlib/zlibmodule.cpp +++ b/plugins/wasmedge_zlib/zlibmodule.cpp @@ -29,6 +29,8 @@ WasmEdgeZlibModule::WasmEdgeZlibModule() : ModuleInstance("wasmedge_zlib") { addHostFunc("deflatePending", std::make_unique(Env)); addHostFunc("deflatePrime", std::make_unique(Env)); + addHostFunc("deflateSetHeader", + std::make_unique(Env)); addHostFunc("inflateInit2", std::make_unique(Env)); addHostFunc("inflateSetDictionary", std::make_unique(Env)); @@ -41,6 +43,8 @@ WasmEdgeZlibModule::WasmEdgeZlibModule() : ModuleInstance("wasmedge_zlib") { std::make_unique(Env)); addHostFunc("inflatePrime", std::make_unique(Env)); addHostFunc("inflateMark", std::make_unique(Env)); + addHostFunc("inflateGetHeader", + std::make_unique(Env)); addHostFunc("inflateBackInit", std::make_unique(Env)); addHostFunc("inflateBackEnd", From 867cb647fbd9f3d17af80c51e50cd70f12dfdf69 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Sat, 9 Sep 2023 08:28:21 +0530 Subject: [PATCH 87/98] Updated Test to check for deflateSetHeader & inflateGetHeader. Signed-off-by: Saikat Dey --- test/plugins/wasmedge_zlib/wasmedge_zlib.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp b/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp index 0db9da0e76bb..f3841172bf65 100644 --- a/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp +++ b/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp @@ -278,6 +278,7 @@ TEST(WasmEdgeZlibTest, Module) { EXPECT_NE(ZlibMod->findFuncExports("deflateBound"), nullptr); EXPECT_NE(ZlibMod->findFuncExports("deflatePending"), nullptr); EXPECT_NE(ZlibMod->findFuncExports("deflatePrime"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("deflateSetHeader"), nullptr); EXPECT_NE(ZlibMod->findFuncExports("inflateInit2"), nullptr); EXPECT_NE(ZlibMod->findFuncExports("inflateSetDictionary"), nullptr); EXPECT_NE(ZlibMod->findFuncExports("inflateGetDictionary"), nullptr); @@ -287,6 +288,7 @@ TEST(WasmEdgeZlibTest, Module) { EXPECT_NE(ZlibMod->findFuncExports("inflateReset2"), nullptr); EXPECT_NE(ZlibMod->findFuncExports("inflatePrime"), nullptr); EXPECT_NE(ZlibMod->findFuncExports("inflateMark"), nullptr); + EXPECT_NE(ZlibMod->findFuncExports("inflateGetHeader"), nullptr); EXPECT_NE(ZlibMod->findFuncExports("inflateBackInit"), nullptr); EXPECT_NE(ZlibMod->findFuncExports("inflateBackEnd"), nullptr); EXPECT_NE(ZlibMod->findFuncExports("zlibCompileFlags"), nullptr); From 4e431c83cfe1f562d20f696ebd0ad2ef0fa1c806 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Sat, 9 Sep 2023 08:29:19 +0530 Subject: [PATCH 88/98] Updated function count test to check for 76 functions. Signed-off-by: Saikat Dey --- test/plugins/wasmedge_zlib/wasmedge_zlib.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp b/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp index f3841172bf65..45784c5ccd68 100644 --- a/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp +++ b/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp @@ -260,7 +260,7 @@ TEST(WasmEdgeZlibTest, Module) { dynamic_cast(createModule()); EXPECT_FALSE(ZlibMod == nullptr); EXPECT_TRUE(ZlibMod->getEnv().ZStreamMap.empty()); - EXPECT_EQ(ZlibMod->getFuncExportNum(), 74U); + EXPECT_EQ(ZlibMod->getFuncExportNum(), 76U); EXPECT_NE(ZlibMod->findFuncExports("deflateInit"), nullptr); EXPECT_NE(ZlibMod->findFuncExports("deflate"), nullptr); From e03337dcfe750d6bd2bd0cb043f76ceec59691a7 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Sat, 9 Sep 2023 08:43:44 +0530 Subject: [PATCH 89/98] Check if SyncRun fails even with no call to zlib API. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index d8945dc90cce..439e994b4744 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -310,7 +310,9 @@ WasmEdgeZlibDeflateCopy::body(const Runtime::CallingFrame &Frame, auto [It, _] = Env.ZStreamMap.emplace(std::make_pair(DestPtr, std::move(DestZStream))); - SyncRun(Env, DestPtr, Frame, [&](z_stream *) { return 0; }); + const auto Res = SyncRun(Env, DestPtr, Frame, [&](z_stream *) { return 0; }); + if (!Res.has_value()) + return Res; const auto ZRes = SyncRun(Env, DestPtr, Frame, [&](z_stream *DestZStream) { return deflateCopy(DestZStream, SourceZStreamIt->second.get()); @@ -505,7 +507,9 @@ WasmEdgeZlibInflateCopy::body(const Runtime::CallingFrame &Frame, auto [It, _] = Env.ZStreamMap.emplace(std::make_pair(DestPtr, std::move(DestZStream))); - SyncRun(Env, DestPtr, Frame, [&](z_stream *) { return 0; }); + const auto Res = SyncRun(Env, DestPtr, Frame, [&](z_stream *) { return 0; }); + if (!Res.has_value()) + return Res; const auto ZRes = SyncRun(Env, DestPtr, Frame, [&](z_stream *DestZStream) { return inflateCopy(DestZStream, SourceZStreamIt->second.get()); From bda8761bf62ab4f5c543188b90d906a9f9061f87 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Sat, 9 Sep 2023 13:32:48 +0530 Subject: [PATCH 90/98] Removed old unused comments, revert usage of named fields & naming convention fixes. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 84 ++++++---- plugins/wasmedge_zlib/zlibfunc.h | 63 ------- test/plugins/wasmedge_zlib/wasmedge_zlib.cpp | 166 +++++++++---------- 3 files changed, 130 insertions(+), 183 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 439e994b4744..bb4b49eb5cc4 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -149,8 +149,9 @@ WasmEdgeZlibDeflateInit::body(const Runtime::CallingFrame &Frame, HostZStream->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored - auto [It, _] = Env.ZStreamMap.emplace( - std::make_pair(ZStreamPtr, std::move(HostZStream))); + auto It = + Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))) + .second; const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { return deflateInit(HostZStream, Level); @@ -195,8 +196,9 @@ WasmEdgeZlibInflateInit::body(const Runtime::CallingFrame &Frame, HostZStream->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored - auto [It, _] = Env.ZStreamMap.emplace( - std::make_pair(ZStreamPtr, std::move(HostZStream))); + auto It = + Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))) + .second; const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { return inflateInit(HostZStream); @@ -240,8 +242,9 @@ Expect WasmEdgeZlibDeflateInit2::body( HostZStream->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored - auto [It, _] = Env.ZStreamMap.emplace( - std::make_pair(ZStreamPtr, std::move(HostZStream))); + auto It = + Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))) + .second; const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { return deflateInit2(HostZStream, Level, Method, WindowBits, MemLevel, @@ -307,8 +310,9 @@ WasmEdgeZlibDeflateCopy::body(const Runtime::CallingFrame &Frame, auto DestZStream = std::make_unique(); - auto [It, _] = - Env.ZStreamMap.emplace(std::make_pair(DestPtr, std::move(DestZStream))); + auto It = + Env.ZStreamMap.emplace(std::make_pair(DestPtr, std::move(DestZStream))) + .second; const auto Res = SyncRun(Env, DestPtr, Frame, [&](z_stream *) { return 0; }); if (!Res.has_value()) @@ -408,11 +412,13 @@ WasmEdgeZlibDeflateSetHeader::body(const Runtime::CallingFrame &Frame, auto HostGZHeader = std::make_unique(); auto HostGZHeaderPtr = HostGZHeader.get(); - auto [It, _] = Env.GZHeaderMap.emplace( - std::pair{ - ZStreamPtr, WasmEdgeZlibEnvironment::GZStore{ - .WasmGZHeaderOffset = HeadPtr, - .HostGZHeader = std::move(HostGZHeader)}}); + auto It = Env.GZHeaderMap + .emplace(std::pair{ + ZStreamPtr, + WasmEdgeZlibEnvironment::GZStore{ + .WasmGZHeaderOffset = HeadPtr, + .HostGZHeader = std::move(HostGZHeader)}}) + .second; const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { return deflateSetHeader(HostZStream, HostGZHeaderPtr); @@ -433,8 +439,9 @@ WasmEdgeZlibInflateInit2::body(const Runtime::CallingFrame &Frame, HostZStream->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored - auto [It, _] = Env.ZStreamMap.emplace( - std::make_pair(ZStreamPtr, std::move(HostZStream))); + auto It = + Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))) + .second; const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { return inflateInit2(HostZStream, WindowBits); @@ -504,8 +511,9 @@ WasmEdgeZlibInflateCopy::body(const Runtime::CallingFrame &Frame, auto DestZStream = std::make_unique(); - auto [It, _] = - Env.ZStreamMap.emplace(std::make_pair(DestPtr, std::move(DestZStream))); + auto It = + Env.ZStreamMap.emplace(std::make_pair(DestPtr, std::move(DestZStream))) + .second; const auto Res = SyncRun(Env, DestPtr, Frame, [&](z_stream *) { return 0; }); if (!Res.has_value()) @@ -573,11 +581,13 @@ WasmEdgeZlibInflateGetHeader::body(const Runtime::CallingFrame &Frame, auto HostGZHeader = std::make_unique(); auto HostGZHeaderPtr = HostGZHeader.get(); - auto [It, _] = Env.GZHeaderMap.emplace( - std::pair{ - ZStreamPtr, WasmEdgeZlibEnvironment::GZStore{ - .WasmGZHeaderOffset = HeadPtr, - .HostGZHeader = std::move(HostGZHeader)}}); + auto It = Env.GZHeaderMap + .emplace(std::pair{ + ZStreamPtr, + WasmEdgeZlibEnvironment::GZStore{ + .WasmGZHeaderOffset = HeadPtr, + .HostGZHeader = std::move(HostGZHeader)}}) + .second; const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { return inflateGetHeader(HostZStream, HostGZHeaderPtr); @@ -606,8 +616,9 @@ WasmEdgeZlibInflateBackInit::body(const Runtime::CallingFrame &Frame, auto *Window = MemInst->getPointer(WindowPtr); - auto [It, _] = Env.ZStreamMap.emplace( - std::make_pair(ZStreamPtr, std::move(HostZStream))); + auto It = + Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))) + .second; const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { return inflateBackInit(HostZStream, WindowBits, Window); @@ -1171,8 +1182,9 @@ WasmEdgeZlibDeflateInit_::body(const Runtime::CallingFrame &Frame, // ignore opaque since zmalloc and zfree was ignored HostZStream->opaque = Z_NULL; - auto [It, _] = Env.ZStreamMap.emplace( - std::make_pair(ZStreamPtr, std::move(HostZStream))); + auto It = + Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))) + .second; const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { return deflateInit_(HostZStream, Level, WasmZlibVersion, sizeof(z_stream)); @@ -1205,8 +1217,9 @@ WasmEdgeZlibInflateInit_::body(const Runtime::CallingFrame &Frame, // ignore opaque since zmalloc and zfree was ignored HostZStream->opaque = Z_NULL; - auto [It, _] = Env.ZStreamMap.emplace( - std::make_pair(ZStreamPtr, std::move(HostZStream))); + auto It = + Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))) + .second; const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { return inflateInit_(HostZStream, WasmZlibVersion, sizeof(z_stream)); @@ -1237,8 +1250,9 @@ Expect WasmEdgeZlibDeflateInit2_::body( HostZStream->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored - auto [It, _] = Env.ZStreamMap.emplace( - std::make_pair(ZStreamPtr, std::move(HostZStream))); + auto It = + Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))) + .second; const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { return deflateInit2_(HostZStream, Level, Method, WindowBits, MemLevel, @@ -1270,8 +1284,9 @@ WasmEdgeZlibInflateInit2_::body(const Runtime::CallingFrame &Frame, HostZStream->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored - auto [It, _] = Env.ZStreamMap.emplace( - std::make_pair(ZStreamPtr, std::move(HostZStream))); + auto It = + Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))) + .second; const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { return inflateInit2_(HostZStream, WindowBits, WasmZlibVersion, @@ -1303,8 +1318,9 @@ Expect WasmEdgeZlibInflateBackInit_::body( HostZStream->opaque = Z_NULL; // ignore opaque since zmalloc and zfree was ignored - auto [It, _] = Env.ZStreamMap.emplace( - std::make_pair(ZStreamPtr, std::move(HostZStream))); + auto It = + Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))) + .second; const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { return inflateBackInit_(HostZStream, WindowBits, Window, WasmZlibVersion, diff --git a/plugins/wasmedge_zlib/zlibfunc.h b/plugins/wasmedge_zlib/zlibfunc.h index 1a7c1fb0b437..d276462d05c7 100644 --- a/plugins/wasmedge_zlib/zlibfunc.h +++ b/plugins/wasmedge_zlib/zlibfunc.h @@ -8,15 +8,6 @@ namespace WasmEdge { namespace Host { -/* -class WasmEdgeZlibZlibVersion : public WasmEdgeZlib { -public: - WasmEdgeZlibZlibVersion(WasmEdgeZlibEnvironment &HostEnv) - : WasmEdgeZlib(HostEnv) {} - Expect body(const Runtime::CallingFrame &Frame); -}; -*/ - class WasmEdgeZlibDeflateInit : public WasmEdgeZlib { public: WasmEdgeZlibDeflateInit(WasmEdgeZlibEnvironment &HostEnv) @@ -248,16 +239,6 @@ class WasmEdgeZlibInflateBackInit int32_t WindowBits, uint32_t WindowPtr); }; -/* -class WasmEdgeZlibInflateBack : public WasmEdgeZlib { -public: - WasmEdgeZlibInflateBack(WasmEdgeZlibEnvironment &HostEnv) - : WasmEdgeZlib(HostEnv) {} - Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, - int32_t Bits, int32_t Value); -}; -*/ - class WasmEdgeZlibInflateBackEnd : public WasmEdgeZlib { public: @@ -382,14 +363,6 @@ class WasmEdgeZlibGZFwrite : public WasmEdgeZlib { uint32_t Size, uint32_t NItems, uint32_t GZFile); }; -/* class WasmEdgeZlibGZPrintf : public WasmEdgeZlib { -public: - WasmEdgeZlibGZPrintf(WasmEdgeZlibEnvironment &HostEnv) - : WasmEdgeZlib(HostEnv) {} - Expect body(const Runtime::CallingFrame &Frame, uint32_t BufPtr, - uint32_t Size, uint32_t NItems, uint32_t GZFile); -}; */ - class WasmEdgeZlibGZPuts : public WasmEdgeZlib { public: WasmEdgeZlibGZPuts(WasmEdgeZlibEnvironment &HostEnv) @@ -398,14 +371,6 @@ class WasmEdgeZlibGZPuts : public WasmEdgeZlib { uint32_t StringPtr); }; -/* class WasmEdgeZlibGZGets : public WasmEdgeZlib { -public: - WasmEdgeZlibGZGets(WasmEdgeZlibEnvironment &HostEnv) - : WasmEdgeZlib(HostEnv) {} - Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile, - uint32_t BufPtr, int32_t Len); -}; */ - class WasmEdgeZlibGZPutc : public WasmEdgeZlib { public: WasmEdgeZlibGZPutc(WasmEdgeZlibEnvironment &HostEnv) @@ -501,13 +466,6 @@ class WasmEdgeZlibGZClose_w : public WasmEdgeZlib { Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile); }; -/* class WasmEdgeZlibGZError : public WasmEdgeZlib { -public: - WasmEdgeZlibGZError(WasmEdgeZlibEnvironment &HostEnv) - : WasmEdgeZlib(HostEnv) {} - Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile); -}; */ - class WasmEdgeZlibGZClearerr : public WasmEdgeZlib { public: WasmEdgeZlibGZClearerr(WasmEdgeZlibEnvironment &HostEnv) @@ -619,13 +577,6 @@ class WasmEdgeZlibGZGetc_ : public WasmEdgeZlib { Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFile); }; -/* class WasmEdgeZlibZError : public WasmEdgeZlib { -public: - WasmEdgeZlibZError(WasmEdgeZlibEnvironment &HostEnv) - : WasmEdgeZlib(HostEnv) {} - Expect body(const Runtime::CallingFrame &Frame, int32_t Err); -}; */ - class WasmEdgeZlibInflateSyncPoint : public WasmEdgeZlib { public: @@ -634,12 +585,6 @@ class WasmEdgeZlibInflateSyncPoint Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr); }; -/* class WasmEdgeZlibGetCRCTable : public WasmEdgeZlib -{ public: WasmEdgeZlibGetCRCTable(WasmEdgeZlibEnvironment &HostEnv) : -WasmEdgeZlib(HostEnv) {} Expect body(const Runtime::CallingFrame -&Frame); -}; */ - class WasmEdgeZlibInflateUndermine : public WasmEdgeZlib { public: @@ -682,13 +627,5 @@ class WasmEdgeZlibDeflateResetKeep Expect body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr); }; -/* class WasmEdgeZlibGZVPrintf : public WasmEdgeZlib { -public: - WasmEdgeZlibGZVPrintf(WasmEdgeZlibEnvironment &HostEnv) - : WasmEdgeZlib(HostEnv) {} - Expect body(const Runtime::CallingFrame &Frame, uint32_t GZFilePtr, - uint32_t FormatPtr); -}; */ - } // namespace Host } // namespace WasmEdge diff --git a/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp b/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp index 45784c5ccd68..d47474d8dc4f 100644 --- a/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp +++ b/test/plugins/wasmedge_zlib/wasmedge_zlib.cpp @@ -38,7 +38,6 @@ void fillMemContent(WasmEdge::Runtime::Instance::MemoryInstance &MemInst, } static constexpr size_t DATA_SIZE = 1 * 1024 * 1024ULL; -// static constexpr size_t INPUT_BUFFER_SIZE = 32 * 1024llu; static constexpr size_t OUTPUT_BUFFER_SIZE = 64 * 1024ULL; constexpr auto RandChar = []() -> char { @@ -64,194 +63,189 @@ TEST(WasmEdgeZlibTest, DeflateInflateCycle) { auto &MemInst = *MemInstPtr; uint32_t // WASM Memory Heap Pointer - wasm_hp = 1, - wasm_data, wasm_zlib_version, wasm_z_stream, wasm_compressed_data, - wasm_decompressed_data; - uint32_t wasm_compressed_data_size = 0, wasm_decompressed_data_size = 0; + WasmHP = 1, + WasmData, WasmZlibVersion, ModuleZStream, WasmCompressedData, + WasmDecompressedData; + uint32_t WasmCompressedData_size = 0, WasmDecompressedData_size = 0; WasmEdge::Runtime::CallingFrame CallFrame(nullptr, &Mod); auto *FuncInst = ZlibMod->findFuncExports("deflateInit_"); EXPECT_NE(FuncInst, nullptr); EXPECT_TRUE(FuncInst->isHostFunction()); - auto &__deflateInit_ = - dynamic_cast( - FuncInst->getHostFunc()); + auto &DeflateInit_ = dynamic_cast( + FuncInst->getHostFunc()); FuncInst = ZlibMod->findFuncExports("deflate"); EXPECT_NE(FuncInst, nullptr); EXPECT_TRUE(FuncInst->isHostFunction()); - auto &__deflate = dynamic_cast( + auto &Deflate = dynamic_cast( FuncInst->getHostFunc()); FuncInst = ZlibMod->findFuncExports("deflateEnd"); EXPECT_NE(FuncInst, nullptr); EXPECT_TRUE(FuncInst->isHostFunction()); - auto &__deflateEnd = dynamic_cast( + auto &DeflateEnd = dynamic_cast( FuncInst->getHostFunc()); FuncInst = ZlibMod->findFuncExports("inflateInit_"); EXPECT_NE(FuncInst, nullptr); EXPECT_TRUE(FuncInst->isHostFunction()); - auto &__inflateInit_ = - dynamic_cast( - FuncInst->getHostFunc()); + auto &InflateInit_ = dynamic_cast( + FuncInst->getHostFunc()); FuncInst = ZlibMod->findFuncExports("inflate"); EXPECT_NE(FuncInst, nullptr); EXPECT_TRUE(FuncInst->isHostFunction()); - auto &__inflate = dynamic_cast( + auto &Inflate = dynamic_cast( FuncInst->getHostFunc()); FuncInst = ZlibMod->findFuncExports("inflateEnd"); EXPECT_NE(FuncInst, nullptr); EXPECT_TRUE(FuncInst->isHostFunction()); - auto &__inflateEnd = dynamic_cast( + auto &InflateEnd = dynamic_cast( FuncInst->getHostFunc()); std::array RetVal; - wasm_zlib_version = wasm_hp; - std::snprintf(MemInst.getPointer(wasm_hp), std::strlen(ZLIB_VERSION), + WasmZlibVersion = WasmHP; + std::snprintf(MemInst.getPointer(WasmHP), std::strlen(ZLIB_VERSION), ZLIB_VERSION); - wasm_hp += std::strlen(ZLIB_VERSION); + WasmHP += std::strlen(ZLIB_VERSION); - wasm_data = wasm_hp; - std::generate_n(MemInst.getPointer(wasm_hp), DATA_SIZE, RandChar); - wasm_hp += DATA_SIZE; + WasmData = WasmHP; + std::generate_n(MemInst.getPointer(WasmHP), DATA_SIZE, RandChar); + WasmHP += DATA_SIZE; - wasm_z_stream = wasm_hp; - WasmZStream *strm = MemInst.getPointer(wasm_z_stream); - wasm_hp += sizeof(WasmZStream); + ModuleZStream = WasmHP; + WasmZStream *strm = MemInst.getPointer(ModuleZStream); + WasmHP += sizeof(WasmZStream); // ----- Deflate Routine START------ - fillMemContent(MemInst, wasm_z_stream, sizeof(WasmZStream), 0U); + fillMemContent(MemInst, ModuleZStream, sizeof(WasmZStream), 0U); // deflateInit_ Test // WASM z_stream size Mismatch - EXPECT_TRUE(__deflateInit_.run( - CallFrame, - std::initializer_list{wasm_z_stream, INT32_C(-1), - wasm_zlib_version, - sizeof(WasmZStream) + 16}, - RetVal)); + EXPECT_TRUE(DeflateInit_.run(CallFrame, + std::initializer_list{ + ModuleZStream, INT32_C(-1), WasmZlibVersion, + sizeof(WasmZStream) + 16}, + RetVal)); EXPECT_EQ(RetVal[0].get(), Z_VERSION_ERROR); // Version Mismatch - EXPECT_TRUE(__deflateInit_.run( + EXPECT_TRUE(DeflateInit_.run( CallFrame, - std::initializer_list{wasm_z_stream, INT32_C(-1), - wasm_zlib_version + 2, - sizeof(WasmZStream)}, + std::initializer_list{ + ModuleZStream, INT32_C(-1), WasmZlibVersion + 2, sizeof(WasmZStream)}, RetVal)); EXPECT_EQ(RetVal[0].get(), Z_VERSION_ERROR); - EXPECT_TRUE(__deflateInit_.run( + EXPECT_TRUE(DeflateInit_.run( CallFrame, std::initializer_list{ - wasm_z_stream, INT32_C(-1), wasm_zlib_version, sizeof(WasmZStream)}, + ModuleZStream, INT32_C(-1), WasmZlibVersion, sizeof(WasmZStream)}, RetVal)); EXPECT_EQ(RetVal[0].get(), Z_OK); - wasm_compressed_data = wasm_hp; + WasmCompressedData = WasmHP; strm->AvailIn = DATA_SIZE; - strm->NextIn = wasm_data; + strm->NextIn = WasmData; strm->AvailOut = OUTPUT_BUFFER_SIZE; - strm->NextOut = wasm_compressed_data; + strm->NextOut = WasmCompressedData; // deflate Test do { if (strm->AvailOut == 0) { - wasm_hp += OUTPUT_BUFFER_SIZE; + WasmHP += OUTPUT_BUFFER_SIZE; strm->AvailOut = OUTPUT_BUFFER_SIZE; - strm->NextOut = wasm_hp; + strm->NextOut = WasmHP; } - EXPECT_TRUE(__deflate.run(CallFrame, - std::initializer_list{ - wasm_z_stream, - INT32_C(Z_FINISH), - }, - RetVal)); + EXPECT_TRUE(Deflate.run(CallFrame, + std::initializer_list{ + ModuleZStream, + INT32_C(Z_FINISH), + }, + RetVal)); EXPECT_NE(RetVal[0].get(), Z_STREAM_ERROR); } while (RetVal[0].get() != Z_STREAM_END); // deflateEnd Test - EXPECT_TRUE(__deflateEnd.run( - CallFrame, std::initializer_list{wasm_z_stream}, + EXPECT_TRUE(DeflateEnd.run( + CallFrame, std::initializer_list{ModuleZStream}, RetVal)); EXPECT_EQ(RetVal[0].get(), Z_OK); - wasm_hp += OUTPUT_BUFFER_SIZE - strm->AvailOut; - wasm_compressed_data_size = wasm_hp - wasm_compressed_data; + WasmHP += OUTPUT_BUFFER_SIZE - strm->AvailOut; + WasmCompressedData_size = WasmHP - WasmCompressedData; // ----- Deflate Routine END------ // ----- Inflate Routine START------ - fillMemContent(MemInst, wasm_z_stream, sizeof(WasmZStream), 0U); + fillMemContent(MemInst, ModuleZStream, sizeof(WasmZStream), 0U); // inflateInit_ Test // WASM z_stream size Mismatch - EXPECT_TRUE(__inflateInit_.run( + EXPECT_TRUE(InflateInit_.run( CallFrame, std::initializer_list{ - wasm_z_stream, wasm_zlib_version, sizeof(WasmZStream) + 16}, + ModuleZStream, WasmZlibVersion, sizeof(WasmZStream) + 16}, RetVal)); EXPECT_EQ(RetVal[0].get(), Z_VERSION_ERROR); // Version Mismatch - EXPECT_TRUE(__inflateInit_.run( + EXPECT_TRUE(InflateInit_.run( CallFrame, std::initializer_list{ - wasm_z_stream, wasm_zlib_version + 2, sizeof(WasmZStream)}, + ModuleZStream, WasmZlibVersion + 2, sizeof(WasmZStream)}, RetVal)); EXPECT_EQ(RetVal[0].get(), Z_VERSION_ERROR); - EXPECT_TRUE(__inflateInit_.run( - CallFrame, - std::initializer_list{ - wasm_z_stream, wasm_zlib_version, sizeof(WasmZStream)}, - RetVal)); + EXPECT_TRUE( + InflateInit_.run(CallFrame, + std::initializer_list{ + ModuleZStream, WasmZlibVersion, sizeof(WasmZStream)}, + RetVal)); EXPECT_EQ(RetVal[0].get(), Z_OK); - wasm_decompressed_data = wasm_hp; + WasmDecompressedData = WasmHP; - strm->AvailIn = wasm_compressed_data_size; - strm->NextIn = wasm_compressed_data; + strm->AvailIn = WasmCompressedData_size; + strm->NextIn = WasmCompressedData; strm->AvailOut = OUTPUT_BUFFER_SIZE; - strm->NextOut = wasm_decompressed_data; + strm->NextOut = WasmDecompressedData; // inflate test do { if (strm->AvailOut == 0) { - wasm_hp += OUTPUT_BUFFER_SIZE; + WasmHP += OUTPUT_BUFFER_SIZE; strm->AvailOut = OUTPUT_BUFFER_SIZE; - strm->NextOut = wasm_hp; + strm->NextOut = WasmHP; } - EXPECT_TRUE(__inflate.run(CallFrame, - std::initializer_list{ - wasm_z_stream, - INT32_C(Z_FINISH), - }, - RetVal)); + EXPECT_TRUE(Inflate.run(CallFrame, + std::initializer_list{ + ModuleZStream, + INT32_C(Z_FINISH), + }, + RetVal)); EXPECT_NE(RetVal[0].get(), Z_STREAM_ERROR); } while (RetVal[0].get() != Z_STREAM_END); - EXPECT_TRUE(__inflateEnd.run( - CallFrame, std::initializer_list{wasm_z_stream}, + EXPECT_TRUE(InflateEnd.run( + CallFrame, std::initializer_list{ModuleZStream}, RetVal)); EXPECT_EQ(RetVal[0].get(), Z_OK); - wasm_hp += OUTPUT_BUFFER_SIZE - strm->AvailOut; - wasm_decompressed_data_size = wasm_hp - wasm_decompressed_data; + WasmHP += OUTPUT_BUFFER_SIZE - strm->AvailOut; + WasmDecompressedData_size = WasmHP - WasmDecompressedData; // ----- Inflate Routine END------ // Test Decompressed Buffer size against source Data size. - EXPECT_EQ(wasm_decompressed_data_size, DATA_SIZE); + EXPECT_EQ(WasmDecompressedData_size, DATA_SIZE); // Test Decompressed Buffer content against source Data. - EXPECT_TRUE( - std::equal(MemInst.getPointer(wasm_decompressed_data), - MemInst.getPointer(wasm_decompressed_data + - wasm_decompressed_data_size), - MemInst.getPointer(wasm_data))); + EXPECT_TRUE(std::equal(MemInst.getPointer(WasmDecompressedData), + MemInst.getPointer( + WasmDecompressedData + WasmDecompressedData_size), + MemInst.getPointer(WasmData))); } TEST(WasmEdgeZlibTest, Module) { @@ -342,7 +336,7 @@ TEST(WasmEdgeZlibTest, Module) { delete ZlibMod; } -GTEST_API_ int main(int argc, char **argv) { - testing::InitGoogleTest(&argc, argv); +GTEST_API_ int main(int ArgC, char **ArgV) { + testing::InitGoogleTest(&ArgC, ArgV); return RUN_ALL_TESTS(); } From 2079bfee4ffef35752177c86d025240c92a04088 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Sat, 9 Sep 2023 14:03:32 +0530 Subject: [PATCH 91/98] Added extensive error logging to Zlib Plugin. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 116 +++++++++++++++++++++++++++++ 1 file changed, 116 insertions(+) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index bb4b49eb5cc4..2d8fc242b022 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -23,12 +23,16 @@ auto SyncRun(WasmEdgeZlibEnvironment &Env, uint32_t ZStreamPtr, auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { + spdlog::error("[WasmEdge-Zlib] [SyncRun]"sv + "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } WasmZStream *ModuleZStream = MemInst->getPointer(ZStreamPtr); const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); if (HostZStreamIt == Env.ZStreamMap.end()) { + spdlog::error("[WasmEdge-Zlib] [SyncRun]"sv + "Invalid ZStreamPtr received."sv); return Unexpect(ErrCode::Value::HostFuncError); } auto HostZStream = HostZStreamIt->second.get(); @@ -263,6 +267,8 @@ Expect WasmEdgeZlibDeflateSetDictionary::body( auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibDeflateSetDictionary]"sv + "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -281,6 +287,8 @@ Expect WasmEdgeZlibDeflateGetDictionary::body( auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibDeflateGetDictionary]"sv + "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -305,6 +313,8 @@ WasmEdgeZlibDeflateCopy::body(const Runtime::CallingFrame &Frame, uint32_t DestPtr, uint32_t SourcePtr) { const auto SourceZStreamIt = Env.ZStreamMap.find(SourcePtr); if (SourceZStreamIt == Env.ZStreamMap.end()) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibDeflateCopy]"sv + "Invalid SourcePtr received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -380,6 +390,8 @@ WasmEdgeZlibDeflatePending::body(const Runtime::CallingFrame &Frame, auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibDeflatePending]"sv + "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -459,6 +471,8 @@ Expect WasmEdgeZlibInflateSetDictionary::body( auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateSetDictionary]"sv + "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -477,6 +491,8 @@ Expect WasmEdgeZlibInflateGetDictionary::body( auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateGetDictionary]"sv + "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -506,6 +522,8 @@ WasmEdgeZlibInflateCopy::body(const Runtime::CallingFrame &Frame, uint32_t DestPtr, uint32_t SourcePtr) { const auto SourceZStreamIt = Env.ZStreamMap.find(SourcePtr); if (SourceZStreamIt == Env.ZStreamMap.end()) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateCopy]"sv + "Invalid SourcePtr received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -611,6 +629,8 @@ WasmEdgeZlibInflateBackInit::body(const Runtime::CallingFrame &Frame, auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateBackInit]"sv + "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -656,6 +676,8 @@ Expect WasmEdgeZlibCompress::body(const Runtime::CallingFrame &Frame, uint32_t SourceLen) { auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibCompress]"sv + "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -678,6 +700,8 @@ Expect WasmEdgeZlibCompress2::body(const Runtime::CallingFrame &Frame, uint32_t SourceLen, int32_t Level) { auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibCompress2]"sv + "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -707,6 +731,8 @@ Expect WasmEdgeZlibUncompress::body(const Runtime::CallingFrame &Frame, uint32_t SourceLen) { auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibUncompress]"sv + "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -728,6 +754,8 @@ WasmEdgeZlibUncompress2::body(const Runtime::CallingFrame &Frame, uint32_t SourcePtr, uint32_t SourceLenPtr) { auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibUncompress2]"sv + "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -750,6 +778,8 @@ Expect WasmEdgeZlibGZOpen::body(const Runtime::CallingFrame &Frame, uint32_t PathPtr, uint32_t ModePtr) { auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZOpen]"sv + "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -772,6 +802,8 @@ Expect WasmEdgeZlibGZDOpen::body(const Runtime::CallingFrame &Frame, int32_t FD, uint32_t ModePtr) { auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZDOpen]"sv + "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -793,6 +825,8 @@ Expect WasmEdgeZlibGZBuffer::body(const Runtime::CallingFrame &, uint32_t GZFile, uint32_t Size) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZBuffer]"sv + "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -806,6 +840,8 @@ Expect WasmEdgeZlibGZSetParams::body(const Runtime::CallingFrame &, int32_t Strategy) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZSetParams]"sv + "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -819,11 +855,15 @@ Expect WasmEdgeZlibGZRead::body(const Runtime::CallingFrame &Frame, uint32_t Len) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZRead]"sv + "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZRead]"sv + "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -839,11 +879,15 @@ Expect WasmEdgeZlibGZFread::body(const Runtime::CallingFrame &Frame, uint32_t NItems, uint32_t GZFile) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZFread]"sv + "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZFread]"sv + "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -859,11 +903,15 @@ Expect WasmEdgeZlibGZWrite::body(const Runtime::CallingFrame &Frame, uint32_t Len) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZWrite]"sv + "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZWrite]"sv + "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -879,11 +927,15 @@ Expect WasmEdgeZlibGZFwrite::body(const Runtime::CallingFrame &Frame, uint32_t NItems, uint32_t GZFile) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZFwrite]"sv + "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZFwrite]"sv + "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -898,11 +950,15 @@ Expect WasmEdgeZlibGZPuts::body(const Runtime::CallingFrame &Frame, uint32_t GZFile, uint32_t StringPtr) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZPuts]"sv + "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZPuts]"sv + "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -917,6 +973,8 @@ Expect WasmEdgeZlibGZPutc::body(const Runtime::CallingFrame &, uint32_t GZFile, int32_t C) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZPutc]"sv + "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -929,6 +987,8 @@ Expect WasmEdgeZlibGZGetc::body(const Runtime::CallingFrame &, uint32_t GZFile) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZGetc]"sv + "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -941,6 +1001,8 @@ Expect WasmEdgeZlibGZUngetc::body(const Runtime::CallingFrame &, int32_t C, uint32_t GZFile) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZUngetc]"sv + "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -953,6 +1015,8 @@ Expect WasmEdgeZlibGZFlush::body(const Runtime::CallingFrame &, uint32_t GZFile, int32_t Flush) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZFlush]"sv + "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -966,6 +1030,8 @@ Expect WasmEdgeZlibGZSeek::body(const Runtime::CallingFrame &, int32_t Whence) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZSeek]"sv + "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -978,6 +1044,8 @@ Expect WasmEdgeZlibGZRewind::body(const Runtime::CallingFrame &, uint32_t GZFile) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZRewind]"sv + "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -990,6 +1058,8 @@ Expect WasmEdgeZlibGZTell::body(const Runtime::CallingFrame &, uint32_t GZFile) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZTell]"sv + "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1002,6 +1072,8 @@ Expect WasmEdgeZlibGZOffset::body(const Runtime::CallingFrame &, uint32_t GZFile) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZOffset]"sv + "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1014,6 +1086,8 @@ Expect WasmEdgeZlibGZEof::body(const Runtime::CallingFrame &, uint32_t GZFile) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZEof]"sv + "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1026,6 +1100,8 @@ Expect WasmEdgeZlibGZDirect::body(const Runtime::CallingFrame &, uint32_t GZFile) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZDirect]"sv + "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1038,6 +1114,8 @@ Expect WasmEdgeZlibGZClose::body(const Runtime::CallingFrame &, uint32_t GZFile) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZClose]"sv + "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1052,6 +1130,8 @@ Expect WasmEdgeZlibGZClose_r::body(const Runtime::CallingFrame &, uint32_t GZFile) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZClose_r]"sv + "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1066,6 +1146,8 @@ Expect WasmEdgeZlibGZClose_w::body(const Runtime::CallingFrame &, uint32_t GZFile) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZClose_w]"sv + "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1080,6 +1162,8 @@ Expect WasmEdgeZlibGZClearerr::body(const Runtime::CallingFrame &, uint32_t GZFile) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZClearerr]"sv + "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1093,6 +1177,8 @@ Expect WasmEdgeZlibAdler32::body(const Runtime::CallingFrame &Frame, uint32_t Len) { auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibAdler32]"sv + "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1107,6 +1193,8 @@ Expect WasmEdgeZlibAdler32_z::body(const Runtime::CallingFrame &Frame, uint32_t Len) { auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibAdler32_z]"sv + "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1129,6 +1217,8 @@ Expect WasmEdgeZlibCRC32::body(const Runtime::CallingFrame &Frame, uint32_t Len) { auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibCRC32]"sv + "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1144,6 +1234,8 @@ Expect WasmEdgeZlibCRC32_z::body(const Runtime::CallingFrame &Frame, uint32_t Len) { auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibCRC32_z]"sv + "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1170,6 +1262,8 @@ WasmEdgeZlibDeflateInit_::body(const Runtime::CallingFrame &Frame, auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibDeflateInit_]"sv + "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1205,6 +1299,8 @@ WasmEdgeZlibInflateInit_::body(const Runtime::CallingFrame &Frame, auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateInit_]"sv + "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1240,6 +1336,8 @@ Expect WasmEdgeZlibDeflateInit2_::body( auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibDeflateInit2_]"sv + "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1274,6 +1372,8 @@ WasmEdgeZlibInflateInit2_::body(const Runtime::CallingFrame &Frame, auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateInit2_]"sv + "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1307,6 +1407,8 @@ Expect WasmEdgeZlibInflateBackInit_::body( auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateBackInit_]"sv + "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1337,6 +1439,8 @@ Expect WasmEdgeZlibGZGetc_::body(const Runtime::CallingFrame &, uint32_t GZFile) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZGetc_]"sv + "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1350,6 +1454,8 @@ WasmEdgeZlibInflateSyncPoint::body(const Runtime::CallingFrame &, uint32_t ZStreamPtr) { const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); if (HostZStreamIt == Env.ZStreamMap.end()) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateSyncPoint]"sv + "Invalid ZStreamPtr received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1363,6 +1469,8 @@ WasmEdgeZlibInflateUndermine::body(const Runtime::CallingFrame &, uint32_t ZStreamPtr, int32_t Subvert) { const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); if (HostZStreamIt == Env.ZStreamMap.end()) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateUndermine]"sv + "Invalid ZStreamPtr received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1376,6 +1484,8 @@ Expect WasmEdgeZlibInflateValidate::body(const Runtime::CallingFrame &, int32_t Check) { const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); if (HostZStreamIt == Env.ZStreamMap.end()) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateValidate]"sv + "Invalid ZStreamPtr received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1389,6 +1499,8 @@ WasmEdgeZlibInflateCodesUsed::body(const Runtime::CallingFrame &, uint32_t ZStreamPtr) { const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); if (HostZStreamIt == Env.ZStreamMap.end()) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateCodesUsed]"sv + "Invalid ZStreamPtr received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1402,6 +1514,8 @@ WasmEdgeZlibInflateResetKeep::body(const Runtime::CallingFrame &, uint32_t ZStreamPtr) { const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); if (HostZStreamIt == Env.ZStreamMap.end()) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateResetKeep]"sv + "Invalid ZStreamPtr received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1415,6 +1529,8 @@ WasmEdgeZlibDeflateResetKeep::body(const Runtime::CallingFrame &, uint32_t ZStreamPtr) { const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); if (HostZStreamIt == Env.ZStreamMap.end()) { + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibDeflateResetKeep]"sv + "Invalid ZStreamPtr received."sv); return Unexpect(ErrCode::Value::HostFuncError); } From 4e546be8726b5750933c775c7d00e5694d2fe2ed Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Sat, 9 Sep 2023 14:16:03 +0530 Subject: [PATCH 92/98] Added Function Instance Name, to SyncRun Error messages for better debug experience. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 275 +++++++++++++++++------------ 1 file changed, 160 insertions(+), 115 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 2d8fc242b022..f53fcbfa82d3 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -17,22 +17,24 @@ constexpr bool CheckSize(int32_t StreamSize) { static constexpr uint32_t WasmGZFileStart = sizeof(gzFile); template -auto SyncRun(WasmEdgeZlibEnvironment &Env, uint32_t ZStreamPtr, - const Runtime::CallingFrame &Frame, T Callback) - -> Expect { +auto SyncRun(const std::string_view &Msg, WasmEdgeZlibEnvironment &Env, + uint32_t ZStreamPtr, const Runtime::CallingFrame &Frame, + T Callback) -> Expect { auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { - spdlog::error("[WasmEdge-Zlib] [SyncRun]"sv - "Frame.getMemoryByIndex(0) returned nullptr."sv); + spdlog::error("[WasmEdge-Zlib] [{}]"sv + "Frame.getMemoryByIndex(0) returned nullptr."sv, + Msg); return Unexpect(ErrCode::Value::HostFuncError); } WasmZStream *ModuleZStream = MemInst->getPointer(ZStreamPtr); const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); if (HostZStreamIt == Env.ZStreamMap.end()) { - spdlog::error("[WasmEdge-Zlib] [SyncRun]"sv - "Invalid ZStreamPtr received."sv); + spdlog::error("[WasmEdge-Zlib] [{}]"sv + "Invalid ZStreamPtr received."sv, + Msg); return Unexpect(ErrCode::Value::HostFuncError); } auto HostZStream = HostZStreamIt->second.get(); @@ -157,9 +159,9 @@ WasmEdgeZlibDeflateInit::body(const Runtime::CallingFrame &Frame, Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))) .second; - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return deflateInit(HostZStream, Level); - }); + const auto ZRes = SyncRun( + "WasmEdgeZlibDeflateInit", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { return deflateInit(HostZStream, Level); }); if (ZRes != Z_OK) Env.ZStreamMap.erase(It); @@ -170,9 +172,9 @@ WasmEdgeZlibDeflateInit::body(const Runtime::CallingFrame &Frame, Expect WasmEdgeZlibDeflate::WasmEdgeZlibDeflate::body( const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t Flush) { - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return deflate(HostZStream, Flush); - }); + const auto ZRes = SyncRun( + "WasmEdgeZlibDeflate", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { return deflate(HostZStream, Flush); }); return ZRes; } @@ -180,9 +182,9 @@ Expect WasmEdgeZlibDeflate::WasmEdgeZlibDeflate::body( Expect WasmEdgeZlibDeflateEnd::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr) { - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return deflateEnd(HostZStream); - }); + const auto ZRes = + SyncRun("WasmEdgeZlibDeflateEnd", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { return deflateEnd(HostZStream); }); if (ZRes == Z_OK) Env.ZStreamMap.erase(ZStreamPtr); @@ -204,9 +206,9 @@ WasmEdgeZlibInflateInit::body(const Runtime::CallingFrame &Frame, Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))) .second; - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return inflateInit(HostZStream); - }); + const auto ZRes = + SyncRun("WasmEdgeZlibInflateInit", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { return inflateInit(HostZStream); }); if (ZRes != Z_OK) Env.ZStreamMap.erase(It); @@ -217,9 +219,9 @@ WasmEdgeZlibInflateInit::body(const Runtime::CallingFrame &Frame, Expect WasmEdgeZlibInflate::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t Flush) { - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return inflate(HostZStream, Flush); - }); + const auto ZRes = SyncRun( + "WasmEdgeZlibInflate", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { return inflate(HostZStream, Flush); }); return ZRes; } @@ -227,9 +229,9 @@ Expect WasmEdgeZlibInflate::body(const Runtime::CallingFrame &Frame, Expect WasmEdgeZlibInflateEnd::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr) { - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return inflateEnd(HostZStream); - }); + const auto ZRes = + SyncRun("WasmEdgeZlibInflateEnd", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { return inflateEnd(HostZStream); }); Env.ZStreamMap.erase(ZStreamPtr); @@ -250,10 +252,12 @@ Expect WasmEdgeZlibDeflateInit2::body( Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))) .second; - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return deflateInit2(HostZStream, Level, Method, WindowBits, MemLevel, - Strategy); - }); + const auto ZRes = + SyncRun("WasmEdgeZlibDeflateInit2", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { + return deflateInit2(HostZStream, Level, Method, WindowBits, + MemLevel, Strategy); + }); if (ZRes != Z_OK) Env.ZStreamMap.erase(It); @@ -274,9 +278,11 @@ Expect WasmEdgeZlibDeflateSetDictionary::body( const auto *Dictionary = MemInst->getPointer(DictionaryPtr); - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return deflateSetDictionary(HostZStream, Dictionary, DictLength); - }); + const auto ZRes = SyncRun("WasmEdgeZlibDeflateSetDictionary", Env, ZStreamPtr, + Frame, [&](z_stream *HostZStream) { + return deflateSetDictionary( + HostZStream, Dictionary, DictLength); + }); return ZRes; } @@ -295,9 +301,11 @@ Expect WasmEdgeZlibDeflateGetDictionary::body( auto *Dictionary = MemInst->getPointer(DictionaryPtr); auto *DictLength = MemInst->getPointer(DictLengthPtr); - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return deflateGetDictionary(HostZStream, Dictionary, DictLength); - }); + const auto ZRes = SyncRun("WasmEdgeZlibDeflateGetDictionary", Env, ZStreamPtr, + Frame, [&](z_stream *HostZStream) { + return deflateGetDictionary( + HostZStream, Dictionary, DictLength); + }); return ZRes; } @@ -324,13 +332,16 @@ WasmEdgeZlibDeflateCopy::body(const Runtime::CallingFrame &Frame, Env.ZStreamMap.emplace(std::make_pair(DestPtr, std::move(DestZStream))) .second; - const auto Res = SyncRun(Env, DestPtr, Frame, [&](z_stream *) { return 0; }); + const auto Res = SyncRun("WasmEdgeZlibDeflateCopy", Env, DestPtr, Frame, + [&](z_stream *) { return 0; }); if (!Res.has_value()) return Res; - const auto ZRes = SyncRun(Env, DestPtr, Frame, [&](z_stream *DestZStream) { - return deflateCopy(DestZStream, SourceZStreamIt->second.get()); - }); + const auto ZRes = + SyncRun("WasmEdgeZlibDeflateCopy", Env, DestPtr, Frame, + [&](z_stream *DestZStream) { + return deflateCopy(DestZStream, SourceZStreamIt->second.get()); + }); if (ZRes != Z_OK) Env.ZStreamMap.erase(It); @@ -342,9 +353,9 @@ Expect WasmEdgeZlibDeflateReset::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr) { - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return deflateReset(HostZStream); - }); + const auto ZRes = + SyncRun("WasmEdgeZlibDeflateReset", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { return deflateReset(HostZStream); }); return ZRes; } @@ -354,9 +365,11 @@ WasmEdgeZlibDeflateParams::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t Level, int32_t Strategy) { - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return deflateParams(HostZStream, Level, Strategy); - }); + const auto ZRes = + SyncRun("WasmEdgeZlibDeflateParams", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { + return deflateParams(HostZStream, Level, Strategy); + }); return ZRes; } @@ -365,9 +378,11 @@ Expect WasmEdgeZlibDeflateTune::body( const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t GoodLength, int32_t MaxLazy, int32_t NiceLength, int32_t MaxChain) { - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return deflateTune(HostZStream, GoodLength, MaxLazy, NiceLength, MaxChain); - }); + const auto ZRes = SyncRun("WasmEdgeZlibDeflateTune", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { + return deflateTune(HostZStream, GoodLength, + MaxLazy, NiceLength, MaxChain); + }); return ZRes; } @@ -376,9 +391,10 @@ Expect WasmEdgeZlibDeflateBound::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, uint32_t SourceLen) { - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return deflateBound(HostZStream, SourceLen); - }); + const auto ZRes = SyncRun("WasmEdgeZlibDeflateBound", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { + return deflateBound(HostZStream, SourceLen); + }); return ZRes; } @@ -398,9 +414,10 @@ WasmEdgeZlibDeflatePending::body(const Runtime::CallingFrame &Frame, auto *Pending = MemInst->getPointer(PendingPtr); auto *Bits = MemInst->getPointer(BitsPtr); - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return deflatePending(HostZStream, Pending, Bits); - }); + const auto ZRes = SyncRun("WasmEdgeZlibDeflatePending", Env, ZStreamPtr, + Frame, [&](z_stream *HostZStream) { + return deflatePending(HostZStream, Pending, Bits); + }); return ZRes; } @@ -410,9 +427,10 @@ WasmEdgeZlibDeflatePrime::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t Bits, int32_t Value) { - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return deflatePrime(HostZStream, Bits, Value); - }); + const auto ZRes = SyncRun("WasmEdgeZlibDeflatePrime", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { + return deflatePrime(HostZStream, Bits, Value); + }); return ZRes; } @@ -432,9 +450,11 @@ WasmEdgeZlibDeflateSetHeader::body(const Runtime::CallingFrame &Frame, .HostGZHeader = std::move(HostGZHeader)}}) .second; - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return deflateSetHeader(HostZStream, HostGZHeaderPtr); - }); + const auto ZRes = + SyncRun("WasmEdgeZlibDeflateSetHeader", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { + return deflateSetHeader(HostZStream, HostGZHeaderPtr); + }); if (ZRes != Z_OK) Env.GZHeaderMap.erase(It); @@ -455,9 +475,10 @@ WasmEdgeZlibInflateInit2::body(const Runtime::CallingFrame &Frame, Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))) .second; - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return inflateInit2(HostZStream, WindowBits); - }); + const auto ZRes = SyncRun("WasmEdgeZlibInflateInit2", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { + return inflateInit2(HostZStream, WindowBits); + }); if (ZRes != Z_OK) Env.ZStreamMap.erase(It); @@ -478,9 +499,11 @@ Expect WasmEdgeZlibInflateSetDictionary::body( auto *Dictionary = MemInst->getPointer(DictionaryPtr); - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return inflateSetDictionary(HostZStream, Dictionary, DictLength); - }); + const auto ZRes = SyncRun("WasmEdgeZlibInflateSetDictionary", Env, ZStreamPtr, + Frame, [&](z_stream *HostZStream) { + return inflateSetDictionary( + HostZStream, Dictionary, DictLength); + }); return ZRes; } @@ -499,9 +522,11 @@ Expect WasmEdgeZlibInflateGetDictionary::body( auto *Dictionary = MemInst->getPointer(DictionaryPtr); auto *DictLength = MemInst->getPointer(DictLengthPtr); - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return inflateGetDictionary(HostZStream, Dictionary, DictLength); - }); + const auto ZRes = SyncRun("WasmEdgeZlibInflateGetDictionary", Env, ZStreamPtr, + Frame, [&](z_stream *HostZStream) { + return inflateGetDictionary( + HostZStream, Dictionary, DictLength); + }); return ZRes; } @@ -510,9 +535,9 @@ Expect WasmEdgeZlibInflateSync::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr) { - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return inflateSync(HostZStream); - }); + const auto ZRes = + SyncRun("WasmEdgeZlibInflateSync", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { return inflateSync(HostZStream); }); return ZRes; } @@ -533,13 +558,16 @@ WasmEdgeZlibInflateCopy::body(const Runtime::CallingFrame &Frame, Env.ZStreamMap.emplace(std::make_pair(DestPtr, std::move(DestZStream))) .second; - const auto Res = SyncRun(Env, DestPtr, Frame, [&](z_stream *) { return 0; }); + const auto Res = SyncRun("WasmEdgeZlibInflateCopy", Env, DestPtr, Frame, + [&](z_stream *) { return 0; }); if (!Res.has_value()) return Res; - const auto ZRes = SyncRun(Env, DestPtr, Frame, [&](z_stream *DestZStream) { - return inflateCopy(DestZStream, SourceZStreamIt->second.get()); - }); + const auto ZRes = + SyncRun("WasmEdgeZlibInflateCopy", Env, DestPtr, Frame, + [&](z_stream *DestZStream) { + return inflateCopy(DestZStream, SourceZStreamIt->second.get()); + }); if (ZRes != Z_OK) Env.ZStreamMap.erase(It); @@ -551,9 +579,9 @@ Expect WasmEdgeZlibInflateReset::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr) { - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return inflateReset(HostZStream); - }); + const auto ZRes = + SyncRun("WasmEdgeZlibInflateReset", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { return inflateReset(HostZStream); }); return ZRes; } @@ -562,9 +590,10 @@ Expect WasmEdgeZlibInflateReset2::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t WindowBits) { - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return inflateReset2(HostZStream, WindowBits); - }); + const auto ZRes = SyncRun("WasmEdgeZlibInflateReset2", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { + return inflateReset2(HostZStream, WindowBits); + }); return ZRes; } @@ -574,9 +603,10 @@ WasmEdgeZlibInflatePrime::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t Bits, int32_t Value) { - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return inflatePrime(HostZStream, Bits, Value); - }); + const auto ZRes = SyncRun("WasmEdgeZlibInflatePrime", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { + return inflatePrime(HostZStream, Bits, Value); + }); return ZRes; } @@ -585,9 +615,9 @@ Expect WasmEdgeZlibInflateMark::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr) { - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return inflateMark(HostZStream); - }); + const auto ZRes = + SyncRun("WasmEdgeZlibInflateMark", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { return inflateMark(HostZStream); }); return ZRes; } @@ -607,9 +637,11 @@ WasmEdgeZlibInflateGetHeader::body(const Runtime::CallingFrame &Frame, .HostGZHeader = std::move(HostGZHeader)}}) .second; - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return inflateGetHeader(HostZStream, HostGZHeaderPtr); - }); + const auto ZRes = + SyncRun("WasmEdgeZlibInflateGetHeader", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { + return inflateGetHeader(HostZStream, HostGZHeaderPtr); + }); if (ZRes != Z_OK) Env.GZHeaderMap.erase(It); @@ -640,9 +672,11 @@ WasmEdgeZlibInflateBackInit::body(const Runtime::CallingFrame &Frame, Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))) .second; - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return inflateBackInit(HostZStream, WindowBits, Window); - }); + const auto ZRes = + SyncRun("WasmEdgeZlibInflateBackInit", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { + return inflateBackInit(HostZStream, WindowBits, Window); + }); if (ZRes != Z_OK) Env.ZStreamMap.erase(It); @@ -654,9 +688,9 @@ Expect WasmEdgeZlibInflateBackEnd::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr) { - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return inflateBackEnd(HostZStream); - }); + const auto ZRes = SyncRun( + "WasmEdgeZlibInflateBackEnd", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { return inflateBackEnd(HostZStream); }); Env.ZStreamMap.erase(ZStreamPtr); @@ -1280,9 +1314,12 @@ WasmEdgeZlibDeflateInit_::body(const Runtime::CallingFrame &Frame, Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))) .second; - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return deflateInit_(HostZStream, Level, WasmZlibVersion, sizeof(z_stream)); - }); + const auto ZRes = + SyncRun("WasmEdgeZlibDeflateInit_", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { + return deflateInit_(HostZStream, Level, WasmZlibVersion, + sizeof(z_stream)); + }); if (ZRes != Z_OK) Env.ZStreamMap.erase(It); @@ -1317,9 +1354,11 @@ WasmEdgeZlibInflateInit_::body(const Runtime::CallingFrame &Frame, Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))) .second; - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return inflateInit_(HostZStream, WasmZlibVersion, sizeof(z_stream)); - }); + const auto ZRes = SyncRun("WasmEdgeZlibInflateInit_", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { + return inflateInit_(HostZStream, WasmZlibVersion, + sizeof(z_stream)); + }); if (ZRes != Z_OK) Env.ZStreamMap.erase(It); @@ -1352,10 +1391,12 @@ Expect WasmEdgeZlibDeflateInit2_::body( Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))) .second; - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return deflateInit2_(HostZStream, Level, Method, WindowBits, MemLevel, - Strategy, WasmZlibVersion, sizeof(z_stream)); - }); + const auto ZRes = SyncRun( + "WasmEdgeZlibDeflateInit2_", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { + return deflateInit2_(HostZStream, Level, Method, WindowBits, MemLevel, + Strategy, WasmZlibVersion, sizeof(z_stream)); + }); if (ZRes != Z_OK) Env.ZStreamMap.erase(It); @@ -1388,10 +1429,12 @@ WasmEdgeZlibInflateInit2_::body(const Runtime::CallingFrame &Frame, Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))) .second; - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return inflateInit2_(HostZStream, WindowBits, WasmZlibVersion, - sizeof(z_stream)); - }); + const auto ZRes = + SyncRun("WasmEdgeZlibInflateInit2_", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { + return inflateInit2_(HostZStream, WindowBits, WasmZlibVersion, + sizeof(z_stream)); + }); if (ZRes != Z_OK) Env.ZStreamMap.erase(It); @@ -1424,10 +1467,12 @@ Expect WasmEdgeZlibInflateBackInit_::body( Env.ZStreamMap.emplace(std::make_pair(ZStreamPtr, std::move(HostZStream))) .second; - const auto ZRes = SyncRun(Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { - return inflateBackInit_(HostZStream, WindowBits, Window, WasmZlibVersion, - sizeof(z_stream)); - }); + const auto ZRes = + SyncRun("WasmEdgeZlibInflateBackInit_", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { + return inflateBackInit_(HostZStream, WindowBits, Window, + WasmZlibVersion, sizeof(z_stream)); + }); if (ZRes != Z_OK) Env.ZStreamMap.erase(It); From 1ef077e2111bf5fc7860d9b3ac227a88046e47e4 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Sat, 9 Sep 2023 14:19:46 +0530 Subject: [PATCH 93/98] Added a space between error msg tag & message. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 116 ++++++++++++++--------------- 1 file changed, 58 insertions(+), 58 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index f53fcbfa82d3..0d64355f77ef 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -23,7 +23,7 @@ auto SyncRun(const std::string_view &Msg, WasmEdgeZlibEnvironment &Env, auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { - spdlog::error("[WasmEdge-Zlib] [{}]"sv + spdlog::error("[WasmEdge-Zlib] [{}] "sv "Frame.getMemoryByIndex(0) returned nullptr."sv, Msg); return Unexpect(ErrCode::Value::HostFuncError); @@ -32,7 +32,7 @@ auto SyncRun(const std::string_view &Msg, WasmEdgeZlibEnvironment &Env, const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); if (HostZStreamIt == Env.ZStreamMap.end()) { - spdlog::error("[WasmEdge-Zlib] [{}]"sv + spdlog::error("[WasmEdge-Zlib] [{}] "sv "Invalid ZStreamPtr received."sv, Msg); return Unexpect(ErrCode::Value::HostFuncError); @@ -271,7 +271,7 @@ Expect WasmEdgeZlibDeflateSetDictionary::body( auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibDeflateSetDictionary]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibDeflateSetDictionary] "sv "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -293,7 +293,7 @@ Expect WasmEdgeZlibDeflateGetDictionary::body( auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibDeflateGetDictionary]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibDeflateGetDictionary] "sv "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -321,7 +321,7 @@ WasmEdgeZlibDeflateCopy::body(const Runtime::CallingFrame &Frame, uint32_t DestPtr, uint32_t SourcePtr) { const auto SourceZStreamIt = Env.ZStreamMap.find(SourcePtr); if (SourceZStreamIt == Env.ZStreamMap.end()) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibDeflateCopy]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibDeflateCopy] "sv "Invalid SourcePtr received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -406,7 +406,7 @@ WasmEdgeZlibDeflatePending::body(const Runtime::CallingFrame &Frame, auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibDeflatePending]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibDeflatePending] "sv "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -492,7 +492,7 @@ Expect WasmEdgeZlibInflateSetDictionary::body( auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateSetDictionary]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateSetDictionary] "sv "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -514,7 +514,7 @@ Expect WasmEdgeZlibInflateGetDictionary::body( auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateGetDictionary]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateGetDictionary] "sv "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -547,7 +547,7 @@ WasmEdgeZlibInflateCopy::body(const Runtime::CallingFrame &Frame, uint32_t DestPtr, uint32_t SourcePtr) { const auto SourceZStreamIt = Env.ZStreamMap.find(SourcePtr); if (SourceZStreamIt == Env.ZStreamMap.end()) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateCopy]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateCopy] "sv "Invalid SourcePtr received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -661,7 +661,7 @@ WasmEdgeZlibInflateBackInit::body(const Runtime::CallingFrame &Frame, auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateBackInit]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateBackInit] "sv "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -710,7 +710,7 @@ Expect WasmEdgeZlibCompress::body(const Runtime::CallingFrame &Frame, uint32_t SourceLen) { auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibCompress]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibCompress] "sv "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -734,7 +734,7 @@ Expect WasmEdgeZlibCompress2::body(const Runtime::CallingFrame &Frame, uint32_t SourceLen, int32_t Level) { auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibCompress2]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibCompress2] "sv "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -765,7 +765,7 @@ Expect WasmEdgeZlibUncompress::body(const Runtime::CallingFrame &Frame, uint32_t SourceLen) { auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibUncompress]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibUncompress] "sv "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -788,7 +788,7 @@ WasmEdgeZlibUncompress2::body(const Runtime::CallingFrame &Frame, uint32_t SourcePtr, uint32_t SourceLenPtr) { auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibUncompress2]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibUncompress2] "sv "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -812,7 +812,7 @@ Expect WasmEdgeZlibGZOpen::body(const Runtime::CallingFrame &Frame, uint32_t PathPtr, uint32_t ModePtr) { auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZOpen]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZOpen] "sv "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -836,7 +836,7 @@ Expect WasmEdgeZlibGZDOpen::body(const Runtime::CallingFrame &Frame, int32_t FD, uint32_t ModePtr) { auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZDOpen]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZDOpen] "sv "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -859,7 +859,7 @@ Expect WasmEdgeZlibGZBuffer::body(const Runtime::CallingFrame &, uint32_t GZFile, uint32_t Size) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZBuffer]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZBuffer] "sv "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -874,7 +874,7 @@ Expect WasmEdgeZlibGZSetParams::body(const Runtime::CallingFrame &, int32_t Strategy) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZSetParams]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZSetParams] "sv "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -889,14 +889,14 @@ Expect WasmEdgeZlibGZRead::body(const Runtime::CallingFrame &Frame, uint32_t Len) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZRead]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZRead] "sv "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZRead]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZRead] "sv "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -913,14 +913,14 @@ Expect WasmEdgeZlibGZFread::body(const Runtime::CallingFrame &Frame, uint32_t NItems, uint32_t GZFile) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZFread]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZFread] "sv "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZFread]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZFread] "sv "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -937,14 +937,14 @@ Expect WasmEdgeZlibGZWrite::body(const Runtime::CallingFrame &Frame, uint32_t Len) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZWrite]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZWrite] "sv "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZWrite]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZWrite] "sv "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -961,14 +961,14 @@ Expect WasmEdgeZlibGZFwrite::body(const Runtime::CallingFrame &Frame, uint32_t NItems, uint32_t GZFile) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZFwrite]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZFwrite] "sv "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZFwrite]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZFwrite] "sv "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -984,14 +984,14 @@ Expect WasmEdgeZlibGZPuts::body(const Runtime::CallingFrame &Frame, uint32_t GZFile, uint32_t StringPtr) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZPuts]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZPuts] "sv "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZPuts]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZPuts] "sv "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1007,7 +1007,7 @@ Expect WasmEdgeZlibGZPutc::body(const Runtime::CallingFrame &, uint32_t GZFile, int32_t C) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZPutc]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZPutc] "sv "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1021,7 +1021,7 @@ Expect WasmEdgeZlibGZGetc::body(const Runtime::CallingFrame &, uint32_t GZFile) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZGetc]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZGetc] "sv "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1035,7 +1035,7 @@ Expect WasmEdgeZlibGZUngetc::body(const Runtime::CallingFrame &, int32_t C, uint32_t GZFile) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZUngetc]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZUngetc] "sv "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1049,7 +1049,7 @@ Expect WasmEdgeZlibGZFlush::body(const Runtime::CallingFrame &, uint32_t GZFile, int32_t Flush) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZFlush]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZFlush] "sv "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1064,7 +1064,7 @@ Expect WasmEdgeZlibGZSeek::body(const Runtime::CallingFrame &, int32_t Whence) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZSeek]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZSeek] "sv "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1078,7 +1078,7 @@ Expect WasmEdgeZlibGZRewind::body(const Runtime::CallingFrame &, uint32_t GZFile) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZRewind]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZRewind] "sv "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1092,7 +1092,7 @@ Expect WasmEdgeZlibGZTell::body(const Runtime::CallingFrame &, uint32_t GZFile) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZTell]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZTell] "sv "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1106,7 +1106,7 @@ Expect WasmEdgeZlibGZOffset::body(const Runtime::CallingFrame &, uint32_t GZFile) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZOffset]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZOffset] "sv "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1120,7 +1120,7 @@ Expect WasmEdgeZlibGZEof::body(const Runtime::CallingFrame &, uint32_t GZFile) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZEof]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZEof] "sv "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1134,7 +1134,7 @@ Expect WasmEdgeZlibGZDirect::body(const Runtime::CallingFrame &, uint32_t GZFile) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZDirect]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZDirect] "sv "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1148,7 +1148,7 @@ Expect WasmEdgeZlibGZClose::body(const Runtime::CallingFrame &, uint32_t GZFile) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZClose]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZClose] "sv "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1164,7 +1164,7 @@ Expect WasmEdgeZlibGZClose_r::body(const Runtime::CallingFrame &, uint32_t GZFile) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZClose_r]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZClose_r] "sv "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1180,7 +1180,7 @@ Expect WasmEdgeZlibGZClose_w::body(const Runtime::CallingFrame &, uint32_t GZFile) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZClose_w]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZClose_w] "sv "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1196,7 +1196,7 @@ Expect WasmEdgeZlibGZClearerr::body(const Runtime::CallingFrame &, uint32_t GZFile) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZClearerr]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZClearerr] "sv "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1211,7 +1211,7 @@ Expect WasmEdgeZlibAdler32::body(const Runtime::CallingFrame &Frame, uint32_t Len) { auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibAdler32]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibAdler32] "sv "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1227,7 +1227,7 @@ Expect WasmEdgeZlibAdler32_z::body(const Runtime::CallingFrame &Frame, uint32_t Len) { auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibAdler32_z]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibAdler32_z] "sv "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1251,7 +1251,7 @@ Expect WasmEdgeZlibCRC32::body(const Runtime::CallingFrame &Frame, uint32_t Len) { auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibCRC32]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibCRC32] "sv "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1268,7 +1268,7 @@ Expect WasmEdgeZlibCRC32_z::body(const Runtime::CallingFrame &Frame, uint32_t Len) { auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibCRC32_z]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibCRC32_z] "sv "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1296,7 +1296,7 @@ WasmEdgeZlibDeflateInit_::body(const Runtime::CallingFrame &Frame, auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibDeflateInit_]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibDeflateInit_] "sv "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1336,7 +1336,7 @@ WasmEdgeZlibInflateInit_::body(const Runtime::CallingFrame &Frame, auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateInit_]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateInit_] "sv "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1375,7 +1375,7 @@ Expect WasmEdgeZlibDeflateInit2_::body( auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibDeflateInit2_]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibDeflateInit2_] "sv "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1413,7 +1413,7 @@ WasmEdgeZlibInflateInit2_::body(const Runtime::CallingFrame &Frame, auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateInit2_]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateInit2_] "sv "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1450,7 +1450,7 @@ Expect WasmEdgeZlibInflateBackInit_::body( auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateBackInit_]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateBackInit_] "sv "Frame.getMemoryByIndex(0) returned nullptr."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1484,7 +1484,7 @@ Expect WasmEdgeZlibGZGetc_::body(const Runtime::CallingFrame &, uint32_t GZFile) { const auto GZFileIt = Env.GZFileMap.find(GZFile); if (GZFileIt == Env.GZFileMap.end()) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZGetc_]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibGZGetc_] "sv "Invalid GZFile received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1499,7 +1499,7 @@ WasmEdgeZlibInflateSyncPoint::body(const Runtime::CallingFrame &, uint32_t ZStreamPtr) { const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); if (HostZStreamIt == Env.ZStreamMap.end()) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateSyncPoint]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateSyncPoint] "sv "Invalid ZStreamPtr received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1514,7 +1514,7 @@ WasmEdgeZlibInflateUndermine::body(const Runtime::CallingFrame &, uint32_t ZStreamPtr, int32_t Subvert) { const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); if (HostZStreamIt == Env.ZStreamMap.end()) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateUndermine]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateUndermine] "sv "Invalid ZStreamPtr received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1529,7 +1529,7 @@ Expect WasmEdgeZlibInflateValidate::body(const Runtime::CallingFrame &, int32_t Check) { const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); if (HostZStreamIt == Env.ZStreamMap.end()) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateValidate]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateValidate] "sv "Invalid ZStreamPtr received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1544,7 +1544,7 @@ WasmEdgeZlibInflateCodesUsed::body(const Runtime::CallingFrame &, uint32_t ZStreamPtr) { const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); if (HostZStreamIt == Env.ZStreamMap.end()) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateCodesUsed]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateCodesUsed] "sv "Invalid ZStreamPtr received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1559,7 +1559,7 @@ WasmEdgeZlibInflateResetKeep::body(const Runtime::CallingFrame &, uint32_t ZStreamPtr) { const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); if (HostZStreamIt == Env.ZStreamMap.end()) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateResetKeep]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibInflateResetKeep] "sv "Invalid ZStreamPtr received."sv); return Unexpect(ErrCode::Value::HostFuncError); } @@ -1574,7 +1574,7 @@ WasmEdgeZlibDeflateResetKeep::body(const Runtime::CallingFrame &, uint32_t ZStreamPtr) { const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); if (HostZStreamIt == Env.ZStreamMap.end()) { - spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibDeflateResetKeep]"sv + spdlog::error("[WasmEdge-Zlib] [WasmEdgeZlibDeflateResetKeep] "sv "Invalid ZStreamPtr received."sv); return Unexpect(ErrCode::Value::HostFuncError); } From 84a54ee1506193fad4d437a815f7800d5606e2af Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Sat, 9 Sep 2023 14:22:46 +0530 Subject: [PATCH 94/98] Added info to error msg if the error is caught inside SyncRun. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 0d64355f77ef..7809b33b9da1 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -23,7 +23,7 @@ auto SyncRun(const std::string_view &Msg, WasmEdgeZlibEnvironment &Env, auto *MemInst = Frame.getMemoryByIndex(0); if (MemInst == nullptr) { - spdlog::error("[WasmEdge-Zlib] [{}] "sv + spdlog::error("[WasmEdge-Zlib] [{}-SyncRun] "sv "Frame.getMemoryByIndex(0) returned nullptr."sv, Msg); return Unexpect(ErrCode::Value::HostFuncError); @@ -32,7 +32,7 @@ auto SyncRun(const std::string_view &Msg, WasmEdgeZlibEnvironment &Env, const auto HostZStreamIt = Env.ZStreamMap.find(ZStreamPtr); if (HostZStreamIt == Env.ZStreamMap.end()) { - spdlog::error("[WasmEdge-Zlib] [{}] "sv + spdlog::error("[WasmEdge-Zlib] [{}-SyncRun] "sv "Invalid ZStreamPtr received."sv, Msg); return Unexpect(ErrCode::Value::HostFuncError); From 4884578b975723f22b19f528415dc0b730b8398e Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Tue, 12 Sep 2023 04:50:48 +0530 Subject: [PATCH 95/98] Removed usage of a temporary ZRes variable wherever not absolutely necessary. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 290 ++++++++++------------------- 1 file changed, 98 insertions(+), 192 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 7809b33b9da1..785fe2f8217c 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -172,11 +172,9 @@ WasmEdgeZlibDeflateInit::body(const Runtime::CallingFrame &Frame, Expect WasmEdgeZlibDeflate::WasmEdgeZlibDeflate::body( const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t Flush) { - const auto ZRes = SyncRun( + return SyncRun( "WasmEdgeZlibDeflate", Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { return deflate(HostZStream, Flush); }); - - return ZRes; } Expect WasmEdgeZlibDeflateEnd::body(const Runtime::CallingFrame &Frame, @@ -219,11 +217,9 @@ WasmEdgeZlibInflateInit::body(const Runtime::CallingFrame &Frame, Expect WasmEdgeZlibInflate::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t Flush) { - const auto ZRes = SyncRun( + return SyncRun( "WasmEdgeZlibInflate", Env, ZStreamPtr, Frame, [&](z_stream *HostZStream) { return inflate(HostZStream, Flush); }); - - return ZRes; } Expect WasmEdgeZlibInflateEnd::body(const Runtime::CallingFrame &Frame, @@ -278,13 +274,11 @@ Expect WasmEdgeZlibDeflateSetDictionary::body( const auto *Dictionary = MemInst->getPointer(DictionaryPtr); - const auto ZRes = SyncRun("WasmEdgeZlibDeflateSetDictionary", Env, ZStreamPtr, - Frame, [&](z_stream *HostZStream) { - return deflateSetDictionary( - HostZStream, Dictionary, DictLength); - }); - - return ZRes; + return SyncRun("WasmEdgeZlibDeflateSetDictionary", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { + return deflateSetDictionary(HostZStream, Dictionary, + DictLength); + }); } Expect WasmEdgeZlibDeflateGetDictionary::body( @@ -301,13 +295,11 @@ Expect WasmEdgeZlibDeflateGetDictionary::body( auto *Dictionary = MemInst->getPointer(DictionaryPtr); auto *DictLength = MemInst->getPointer(DictLengthPtr); - const auto ZRes = SyncRun("WasmEdgeZlibDeflateGetDictionary", Env, ZStreamPtr, - Frame, [&](z_stream *HostZStream) { - return deflateGetDictionary( - HostZStream, Dictionary, DictLength); - }); - - return ZRes; + return SyncRun("WasmEdgeZlibDeflateGetDictionary", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { + return deflateGetDictionary(HostZStream, Dictionary, + DictLength); + }); } /* @@ -353,11 +345,9 @@ Expect WasmEdgeZlibDeflateReset::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr) { - const auto ZRes = - SyncRun("WasmEdgeZlibDeflateReset", Env, ZStreamPtr, Frame, - [&](z_stream *HostZStream) { return deflateReset(HostZStream); }); - - return ZRes; + return SyncRun( + "WasmEdgeZlibDeflateReset", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { return deflateReset(HostZStream); }); } Expect @@ -365,38 +355,31 @@ WasmEdgeZlibDeflateParams::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t Level, int32_t Strategy) { - const auto ZRes = - SyncRun("WasmEdgeZlibDeflateParams", Env, ZStreamPtr, Frame, - [&](z_stream *HostZStream) { - return deflateParams(HostZStream, Level, Strategy); - }); - - return ZRes; + return SyncRun("WasmEdgeZlibDeflateParams", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { + return deflateParams(HostZStream, Level, Strategy); + }); } Expect WasmEdgeZlibDeflateTune::body( const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t GoodLength, int32_t MaxLazy, int32_t NiceLength, int32_t MaxChain) { - const auto ZRes = SyncRun("WasmEdgeZlibDeflateTune", Env, ZStreamPtr, Frame, - [&](z_stream *HostZStream) { - return deflateTune(HostZStream, GoodLength, - MaxLazy, NiceLength, MaxChain); - }); - - return ZRes; + return SyncRun("WasmEdgeZlibDeflateTune", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { + return deflateTune(HostZStream, GoodLength, MaxLazy, + NiceLength, MaxChain); + }); } Expect WasmEdgeZlibDeflateBound::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, uint32_t SourceLen) { - const auto ZRes = SyncRun("WasmEdgeZlibDeflateBound", Env, ZStreamPtr, Frame, - [&](z_stream *HostZStream) { - return deflateBound(HostZStream, SourceLen); - }); - - return ZRes; + return SyncRun("WasmEdgeZlibDeflateBound", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { + return deflateBound(HostZStream, SourceLen); + }); } Expect @@ -414,12 +397,10 @@ WasmEdgeZlibDeflatePending::body(const Runtime::CallingFrame &Frame, auto *Pending = MemInst->getPointer(PendingPtr); auto *Bits = MemInst->getPointer(BitsPtr); - const auto ZRes = SyncRun("WasmEdgeZlibDeflatePending", Env, ZStreamPtr, - Frame, [&](z_stream *HostZStream) { - return deflatePending(HostZStream, Pending, Bits); - }); - - return ZRes; + return SyncRun("WasmEdgeZlibDeflatePending", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { + return deflatePending(HostZStream, Pending, Bits); + }); } Expect @@ -427,12 +408,10 @@ WasmEdgeZlibDeflatePrime::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t Bits, int32_t Value) { - const auto ZRes = SyncRun("WasmEdgeZlibDeflatePrime", Env, ZStreamPtr, Frame, - [&](z_stream *HostZStream) { - return deflatePrime(HostZStream, Bits, Value); - }); - - return ZRes; + return SyncRun("WasmEdgeZlibDeflatePrime", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { + return deflatePrime(HostZStream, Bits, Value); + }); } Expect @@ -499,13 +478,11 @@ Expect WasmEdgeZlibInflateSetDictionary::body( auto *Dictionary = MemInst->getPointer(DictionaryPtr); - const auto ZRes = SyncRun("WasmEdgeZlibInflateSetDictionary", Env, ZStreamPtr, - Frame, [&](z_stream *HostZStream) { - return inflateSetDictionary( - HostZStream, Dictionary, DictLength); - }); - - return ZRes; + return SyncRun("WasmEdgeZlibInflateSetDictionary", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { + return inflateSetDictionary(HostZStream, Dictionary, + DictLength); + }); } Expect WasmEdgeZlibInflateGetDictionary::body( @@ -522,24 +499,20 @@ Expect WasmEdgeZlibInflateGetDictionary::body( auto *Dictionary = MemInst->getPointer(DictionaryPtr); auto *DictLength = MemInst->getPointer(DictLengthPtr); - const auto ZRes = SyncRun("WasmEdgeZlibInflateGetDictionary", Env, ZStreamPtr, - Frame, [&](z_stream *HostZStream) { - return inflateGetDictionary( - HostZStream, Dictionary, DictLength); - }); - - return ZRes; + return SyncRun("WasmEdgeZlibInflateGetDictionary", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { + return inflateGetDictionary(HostZStream, Dictionary, + DictLength); + }); } Expect WasmEdgeZlibInflateSync::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr) { - const auto ZRes = - SyncRun("WasmEdgeZlibInflateSync", Env, ZStreamPtr, Frame, - [&](z_stream *HostZStream) { return inflateSync(HostZStream); }); - - return ZRes; + return SyncRun( + "WasmEdgeZlibInflateSync", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { return inflateSync(HostZStream); }); } Expect @@ -579,23 +552,19 @@ Expect WasmEdgeZlibInflateReset::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr) { - const auto ZRes = - SyncRun("WasmEdgeZlibInflateReset", Env, ZStreamPtr, Frame, - [&](z_stream *HostZStream) { return inflateReset(HostZStream); }); - - return ZRes; + return SyncRun( + "WasmEdgeZlibInflateReset", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { return inflateReset(HostZStream); }); } Expect WasmEdgeZlibInflateReset2::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t WindowBits) { - const auto ZRes = SyncRun("WasmEdgeZlibInflateReset2", Env, ZStreamPtr, Frame, - [&](z_stream *HostZStream) { - return inflateReset2(HostZStream, WindowBits); - }); - - return ZRes; + return SyncRun("WasmEdgeZlibInflateReset2", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { + return inflateReset2(HostZStream, WindowBits); + }); } Expect @@ -603,23 +572,19 @@ WasmEdgeZlibInflatePrime::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr, int32_t Bits, int32_t Value) { - const auto ZRes = SyncRun("WasmEdgeZlibInflatePrime", Env, ZStreamPtr, Frame, - [&](z_stream *HostZStream) { - return inflatePrime(HostZStream, Bits, Value); - }); - - return ZRes; + return SyncRun("WasmEdgeZlibInflatePrime", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { + return inflatePrime(HostZStream, Bits, Value); + }); } Expect WasmEdgeZlibInflateMark::body(const Runtime::CallingFrame &Frame, uint32_t ZStreamPtr) { - const auto ZRes = - SyncRun("WasmEdgeZlibInflateMark", Env, ZStreamPtr, Frame, - [&](z_stream *HostZStream) { return inflateMark(HostZStream); }); - - return ZRes; + return SyncRun( + "WasmEdgeZlibInflateMark", Env, ZStreamPtr, Frame, + [&](z_stream *HostZStream) { return inflateMark(HostZStream); }); } Expect @@ -699,8 +664,7 @@ WasmEdgeZlibInflateBackEnd::body(const Runtime::CallingFrame &Frame, Expect WasmEdgeZlibZlibCompilerFlags::body(const Runtime::CallingFrame &) { - const auto ZRes = zlibCompileFlags(); - return ZRes; + return zlibCompileFlags(); } Expect WasmEdgeZlibCompress::body(const Runtime::CallingFrame &Frame, @@ -753,9 +717,7 @@ Expect WasmEdgeZlibCompress2::body(const Runtime::CallingFrame &Frame, Expect WasmEdgeZlibCompressBound::body(const Runtime::CallingFrame &, uint32_t SourceLen) { - const auto ZRes = compressBound(SourceLen); - - return ZRes; + return compressBound(SourceLen); } Expect WasmEdgeZlibUncompress::body(const Runtime::CallingFrame &Frame, @@ -864,9 +826,7 @@ Expect WasmEdgeZlibGZBuffer::body(const Runtime::CallingFrame &, return Unexpect(ErrCode::Value::HostFuncError); } - auto ZRes = gzbuffer(GZFileIt->second.get(), Size); - - return ZRes; + return gzbuffer(GZFileIt->second.get(), Size); } Expect WasmEdgeZlibGZSetParams::body(const Runtime::CallingFrame &, @@ -879,9 +839,7 @@ Expect WasmEdgeZlibGZSetParams::body(const Runtime::CallingFrame &, return Unexpect(ErrCode::Value::HostFuncError); } - auto ZRes = gzsetparams(GZFileIt->second.get(), Level, Strategy); - - return ZRes; + return gzsetparams(GZFileIt->second.get(), Level, Strategy); } Expect WasmEdgeZlibGZRead::body(const Runtime::CallingFrame &Frame, @@ -903,9 +861,7 @@ Expect WasmEdgeZlibGZRead::body(const Runtime::CallingFrame &Frame, auto *Buf = MemInst->getPointer(BufPtr); - auto ZRes = gzread(GZFileIt->second.get(), Buf, Len); - - return ZRes; + return gzread(GZFileIt->second.get(), Buf, Len); } Expect WasmEdgeZlibGZFread::body(const Runtime::CallingFrame &Frame, @@ -927,9 +883,7 @@ Expect WasmEdgeZlibGZFread::body(const Runtime::CallingFrame &Frame, auto *Buf = MemInst->getPointer(BufPtr); - auto ZRes = gzfread(Buf, Size, NItems, GZFileIt->second.get()); - - return ZRes; + return gzfread(Buf, Size, NItems, GZFileIt->second.get()); } Expect WasmEdgeZlibGZWrite::body(const Runtime::CallingFrame &Frame, @@ -951,9 +905,7 @@ Expect WasmEdgeZlibGZWrite::body(const Runtime::CallingFrame &Frame, auto *Buf = MemInst->getPointer(BufPtr); - auto ZRes = gzwrite(GZFileIt->second.get(), Buf, Len); - - return ZRes; + return gzwrite(GZFileIt->second.get(), Buf, Len); } Expect WasmEdgeZlibGZFwrite::body(const Runtime::CallingFrame &Frame, @@ -975,9 +927,7 @@ Expect WasmEdgeZlibGZFwrite::body(const Runtime::CallingFrame &Frame, auto *Buf = MemInst->getPointer(BufPtr); - auto ZRes = gzfwrite(Buf, Size, NItems, GZFileIt->second.get()); - - return ZRes; + return gzfwrite(Buf, Size, NItems, GZFileIt->second.get()); } Expect WasmEdgeZlibGZPuts::body(const Runtime::CallingFrame &Frame, @@ -998,9 +948,7 @@ Expect WasmEdgeZlibGZPuts::body(const Runtime::CallingFrame &Frame, auto *String = MemInst->getPointer(StringPtr); - auto ZRes = gzputs(GZFileIt->second.get(), String); - - return ZRes; + return gzputs(GZFileIt->second.get(), String); } Expect WasmEdgeZlibGZPutc::body(const Runtime::CallingFrame &, @@ -1012,9 +960,7 @@ Expect WasmEdgeZlibGZPutc::body(const Runtime::CallingFrame &, return Unexpect(ErrCode::Value::HostFuncError); } - auto ZRes = gzputc(GZFileIt->second.get(), C); - - return ZRes; + return gzputc(GZFileIt->second.get(), C); } Expect WasmEdgeZlibGZGetc::body(const Runtime::CallingFrame &, @@ -1026,9 +972,7 @@ Expect WasmEdgeZlibGZGetc::body(const Runtime::CallingFrame &, return Unexpect(ErrCode::Value::HostFuncError); } - auto ZRes = gzgetc(GZFileIt->second.get()); - - return ZRes; + return gzgetc(GZFileIt->second.get()); } Expect WasmEdgeZlibGZUngetc::body(const Runtime::CallingFrame &, @@ -1040,9 +984,7 @@ Expect WasmEdgeZlibGZUngetc::body(const Runtime::CallingFrame &, return Unexpect(ErrCode::Value::HostFuncError); } - auto ZRes = gzungetc(C, GZFileIt->second.get()); - - return ZRes; + return gzungetc(C, GZFileIt->second.get()); } Expect WasmEdgeZlibGZFlush::body(const Runtime::CallingFrame &, @@ -1054,9 +996,7 @@ Expect WasmEdgeZlibGZFlush::body(const Runtime::CallingFrame &, return Unexpect(ErrCode::Value::HostFuncError); } - auto ZRes = gzflush(GZFileIt->second.get(), Flush); - - return ZRes; + return gzflush(GZFileIt->second.get(), Flush); } Expect WasmEdgeZlibGZSeek::body(const Runtime::CallingFrame &, @@ -1069,9 +1009,7 @@ Expect WasmEdgeZlibGZSeek::body(const Runtime::CallingFrame &, return Unexpect(ErrCode::Value::HostFuncError); } - auto ZRes = gzseek(GZFileIt->second.get(), Offset, Whence); - - return ZRes; + return gzseek(GZFileIt->second.get(), Offset, Whence); } Expect WasmEdgeZlibGZRewind::body(const Runtime::CallingFrame &, @@ -1083,9 +1021,7 @@ Expect WasmEdgeZlibGZRewind::body(const Runtime::CallingFrame &, return Unexpect(ErrCode::Value::HostFuncError); } - auto ZRes = gzrewind(GZFileIt->second.get()); - - return ZRes; + return gzrewind(GZFileIt->second.get()); } Expect WasmEdgeZlibGZTell::body(const Runtime::CallingFrame &, @@ -1097,9 +1033,7 @@ Expect WasmEdgeZlibGZTell::body(const Runtime::CallingFrame &, return Unexpect(ErrCode::Value::HostFuncError); } - auto ZRes = gztell(GZFileIt->second.get()); - - return ZRes; + return gztell(GZFileIt->second.get()); } Expect WasmEdgeZlibGZOffset::body(const Runtime::CallingFrame &, @@ -1111,9 +1045,7 @@ Expect WasmEdgeZlibGZOffset::body(const Runtime::CallingFrame &, return Unexpect(ErrCode::Value::HostFuncError); } - auto ZRes = gzoffset(GZFileIt->second.get()); - - return ZRes; + return gzoffset(GZFileIt->second.get()); } Expect WasmEdgeZlibGZEof::body(const Runtime::CallingFrame &, @@ -1125,9 +1057,7 @@ Expect WasmEdgeZlibGZEof::body(const Runtime::CallingFrame &, return Unexpect(ErrCode::Value::HostFuncError); } - auto ZRes = gzeof(GZFileIt->second.get()); - - return ZRes; + return gzeof(GZFileIt->second.get()); } Expect WasmEdgeZlibGZDirect::body(const Runtime::CallingFrame &, @@ -1139,9 +1069,7 @@ Expect WasmEdgeZlibGZDirect::body(const Runtime::CallingFrame &, return Unexpect(ErrCode::Value::HostFuncError); } - auto ZRes = gzdirect(GZFileIt->second.get()); - - return ZRes; + return gzdirect(GZFileIt->second.get()); } Expect WasmEdgeZlibGZClose::body(const Runtime::CallingFrame &, @@ -1153,7 +1081,7 @@ Expect WasmEdgeZlibGZClose::body(const Runtime::CallingFrame &, return Unexpect(ErrCode::Value::HostFuncError); } - auto ZRes = gzclose(GZFileIt->second.get()); + const auto ZRes = gzclose(GZFileIt->second.get()); Env.GZFileMap.erase(GZFileIt); @@ -1169,7 +1097,7 @@ Expect WasmEdgeZlibGZClose_r::body(const Runtime::CallingFrame &, return Unexpect(ErrCode::Value::HostFuncError); } - auto ZRes = gzclose_r(GZFileIt->second.get()); + const auto ZRes = gzclose_r(GZFileIt->second.get()); Env.GZFileMap.erase(GZFileIt); @@ -1185,7 +1113,7 @@ Expect WasmEdgeZlibGZClose_w::body(const Runtime::CallingFrame &, return Unexpect(ErrCode::Value::HostFuncError); } - auto ZRes = gzclose_w(GZFileIt->second.get()); + const auto ZRes = gzclose_w(GZFileIt->second.get()); Env.GZFileMap.erase(GZFileIt); @@ -1218,8 +1146,7 @@ Expect WasmEdgeZlibAdler32::body(const Runtime::CallingFrame &Frame, auto *Buf = MemInst->getPointer(BufPtr); - const auto ZRes = adler32(Adler, Buf, Len); - return ZRes; + return adler32(Adler, Buf, Len); } Expect WasmEdgeZlibAdler32_z::body(const Runtime::CallingFrame &Frame, @@ -1234,16 +1161,14 @@ Expect WasmEdgeZlibAdler32_z::body(const Runtime::CallingFrame &Frame, auto *Buf = MemInst->getPointer(BufPtr); - const auto ZRes = adler32_z(Adler, Buf, Len); - return ZRes; + return adler32_z(Adler, Buf, Len); } Expect WasmEdgeZlibAdler32Combine::body(const Runtime::CallingFrame &, uint32_t Adler1, uint32_t Adler2, int32_t Len2) { - const auto ZRes = adler32_combine(Adler1, Adler2, Len2); - return ZRes; + return adler32_combine(Adler1, Adler2, Len2); } Expect WasmEdgeZlibCRC32::body(const Runtime::CallingFrame &Frame, @@ -1258,9 +1183,7 @@ Expect WasmEdgeZlibCRC32::body(const Runtime::CallingFrame &Frame, auto *Buf = MemInst->getPointer(BufPtr); - const auto ZRes = crc32(CRC, Buf, Len); - - return ZRes; + return crc32(CRC, Buf, Len); } Expect WasmEdgeZlibCRC32_z::body(const Runtime::CallingFrame &Frame, @@ -1275,16 +1198,13 @@ Expect WasmEdgeZlibCRC32_z::body(const Runtime::CallingFrame &Frame, auto *Buf = MemInst->getPointer(BufPtr); - const auto ZRes = crc32_z(CRC, Buf, Len); - - return ZRes; + return crc32_z(CRC, Buf, Len); } Expect WasmEdgeZlibCRC32Combine::body(const Runtime::CallingFrame &, uint32_t CRC1, uint32_t CRC2, int32_t Len2) { - const auto ZRes = crc32_combine(CRC1, CRC2, Len2); - return ZRes; + return crc32_combine(CRC1, CRC2, Len2); } Expect @@ -1489,9 +1409,7 @@ Expect WasmEdgeZlibGZGetc_::body(const Runtime::CallingFrame &, return Unexpect(ErrCode::Value::HostFuncError); } - auto ZRes = gzgetc_(GZFileIt->second.get()); - - return ZRes; + return gzgetc_(GZFileIt->second.get()); } Expect @@ -1504,9 +1422,7 @@ WasmEdgeZlibInflateSyncPoint::body(const Runtime::CallingFrame &, return Unexpect(ErrCode::Value::HostFuncError); } - auto ZRes = inflateSyncPoint(HostZStreamIt->second.get()); - - return ZRes; + return inflateSyncPoint(HostZStreamIt->second.get()); } Expect @@ -1519,9 +1435,7 @@ WasmEdgeZlibInflateUndermine::body(const Runtime::CallingFrame &, return Unexpect(ErrCode::Value::HostFuncError); } - auto ZRes = inflateUndermine(HostZStreamIt->second.get(), Subvert); - - return ZRes; + return inflateUndermine(HostZStreamIt->second.get(), Subvert); } Expect WasmEdgeZlibInflateValidate::body(const Runtime::CallingFrame &, @@ -1534,9 +1448,7 @@ Expect WasmEdgeZlibInflateValidate::body(const Runtime::CallingFrame &, return Unexpect(ErrCode::Value::HostFuncError); } - auto ZRes = inflateValidate(HostZStreamIt->second.get(), Check); - - return ZRes; + return inflateValidate(HostZStreamIt->second.get(), Check); } Expect @@ -1549,9 +1461,7 @@ WasmEdgeZlibInflateCodesUsed::body(const Runtime::CallingFrame &, return Unexpect(ErrCode::Value::HostFuncError); } - auto ZRes = inflateCodesUsed(HostZStreamIt->second.get()); - - return ZRes; + return inflateCodesUsed(HostZStreamIt->second.get()); } Expect @@ -1564,9 +1474,7 @@ WasmEdgeZlibInflateResetKeep::body(const Runtime::CallingFrame &, return Unexpect(ErrCode::Value::HostFuncError); } - auto ZRes = inflateResetKeep(HostZStreamIt->second.get()); - - return ZRes; + return inflateResetKeep(HostZStreamIt->second.get()); } Expect @@ -1579,9 +1487,7 @@ WasmEdgeZlibDeflateResetKeep::body(const Runtime::CallingFrame &, return Unexpect(ErrCode::Value::HostFuncError); } - auto ZRes = deflateResetKeep(HostZStreamIt->second.get()); - - return ZRes; + return deflateResetKeep(HostZStreamIt->second.get()); } } // namespace Host From 1d0ac2336eb2489473e93b9bba8cc0a29a64657f Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Tue, 12 Sep 2023 05:05:35 +0530 Subject: [PATCH 96/98] Fix Bug: Properly return a placeholder number to Module to act as a pointer to Host gzFile_s. We don't need to pass the raw pointer to Module, since gzFile_s is an opaque structure & the zlib app shouldn't try to access any of it's fields. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 785fe2f8217c..87d76ab1d627 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -784,14 +784,16 @@ Expect WasmEdgeZlibGZOpen::body(const Runtime::CallingFrame &Frame, auto ZRes = gzopen(Path, Mode); - const auto NewWasmGZFile = WasmGZFileStart + Env.GZFileMap.size(); + const auto NewWasmGZFile = + WasmGZFileStart + + static_cast(Env.GZFileMap.size()); auto El = std::pair>( NewWasmGZFile, ZRes); Env.GZFileMap.emplace(std::move(El)); - return 0; + return NewWasmGZFile; } Expect WasmEdgeZlibGZDOpen::body(const Runtime::CallingFrame &Frame, @@ -807,14 +809,16 @@ Expect WasmEdgeZlibGZDOpen::body(const Runtime::CallingFrame &Frame, auto ZRes = gzdopen(FD, Mode); - const auto NewWasmGZFile = WasmGZFileStart + Env.GZFileMap.size(); + const auto NewWasmGZFile = + WasmGZFileStart + + static_cast(Env.GZFileMap.size()); auto El = std::pair>( NewWasmGZFile, ZRes); Env.GZFileMap.emplace(std::move(El)); - return 0; + return NewWasmGZFile; } Expect WasmEdgeZlibGZBuffer::body(const Runtime::CallingFrame &, From 49018cb086054158f99e7b30fe4f13b402757cd3 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Tue, 12 Sep 2023 05:07:28 +0530 Subject: [PATCH 97/98] [Style Change] Remove trailing _s from GZFile_s. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibenv.h | 5 ++--- plugins/wasmedge_zlib/zlibfunc.cpp | 4 ++-- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibenv.h b/plugins/wasmedge_zlib/zlibenv.h index 18b34153042e..97781a573b63 100644 --- a/plugins/wasmedge_zlib/zlibenv.h +++ b/plugins/wasmedge_zlib/zlibenv.h @@ -81,7 +81,7 @@ namespace Host { class WasmEdgeZlibEnvironment { public: - using GZFile_s = std::remove_pointer_t; + using GZFile = std::remove_pointer_t; struct GZStore { uint32_t WasmGZHeaderOffset; @@ -89,8 +89,7 @@ class WasmEdgeZlibEnvironment { }; std::unordered_map> ZStreamMap; - std::map, std::greater> - GZFileMap; + std::map, std::greater> GZFileMap; std::unordered_map GZHeaderMap; /// Initial Configurations diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index 87d76ab1d627..bef8c6a81841 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -788,7 +788,7 @@ Expect WasmEdgeZlibGZOpen::body(const Runtime::CallingFrame &Frame, WasmGZFileStart + static_cast(Env.GZFileMap.size()); auto El = - std::pair>( + std::pair>( NewWasmGZFile, ZRes); Env.GZFileMap.emplace(std::move(El)); @@ -813,7 +813,7 @@ Expect WasmEdgeZlibGZDOpen::body(const Runtime::CallingFrame &Frame, WasmGZFileStart + static_cast(Env.GZFileMap.size()); auto El = - std::pair>( + std::pair>( NewWasmGZFile, ZRes); Env.GZFileMap.emplace(std::move(El)); From 8846a16981a272cf119c3e4167caba0a29ea0730 Mon Sep 17 00:00:00 2001 From: Saikat Dey Date: Tue, 12 Sep 2023 06:49:33 +0530 Subject: [PATCH 98/98] Removed usage of decltype, due to gcc [error: type qualifiers ignored on cast result type]. Using remove_cv to supress, would create code bloat. Signed-off-by: Saikat Dey --- plugins/wasmedge_zlib/zlibfunc.cpp | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/plugins/wasmedge_zlib/zlibfunc.cpp b/plugins/wasmedge_zlib/zlibfunc.cpp index bef8c6a81841..04aeac05af0c 100644 --- a/plugins/wasmedge_zlib/zlibfunc.cpp +++ b/plugins/wasmedge_zlib/zlibfunc.cpp @@ -784,9 +784,7 @@ Expect WasmEdgeZlibGZOpen::body(const Runtime::CallingFrame &Frame, auto ZRes = gzopen(Path, Mode); - const auto NewWasmGZFile = - WasmGZFileStart + - static_cast(Env.GZFileMap.size()); + const auto NewWasmGZFile = WasmGZFileStart + Env.GZFileMap.size(); auto El = std::pair>( NewWasmGZFile, ZRes); @@ -809,9 +807,7 @@ Expect WasmEdgeZlibGZDOpen::body(const Runtime::CallingFrame &Frame, auto ZRes = gzdopen(FD, Mode); - const auto NewWasmGZFile = - WasmGZFileStart + - static_cast(Env.GZFileMap.size()); + const auto NewWasmGZFile = WasmGZFileStart + Env.GZFileMap.size(); auto El = std::pair>( NewWasmGZFile, ZRes);