Experimental/wb2 jit

.cicd/generate-pipeline.sh

@@ -182,7 +182,7 @@ for ROUND in $(seq 1 $ROUNDS); do
       BUILDKITE_AGENT_ACCESS_TOKEN:
     agents:
       queue: "$BUILDKITE_AGENT_QUEUE"
-    timeout: ${TIMEOUT:-10}
+    timeout: ${TIMEOUT:-15}
     skip: \${SKIP_$(echo "$PLATFORM_JSON" | jq -r .PLATFORM_NAME_UPCASE)_$(echo "$PLATFORM_JSON" | jq -r .VERSION_MAJOR)$(echo "$PLATFORM_JSON" | jq -r .VERSION_MINOR)}${SKIP_UNIT_TESTS}
 
 EOF
@@ -208,7 +208,7 @@ EOF
             - 'registry_1'
             - 'registry_2'
           pre-execute-sleep: 5
-    timeout: ${TIMEOUT:-30}
+    timeout: ${TIMEOUT:-45}
     agents: "queue=mac-anka-node-fleet"
     skip: \${SKIP_$(echo "$PLATFORM_JSON" | jq -r .PLATFORM_NAME_UPCASE)_$(echo "$PLATFORM_JSON" | jq -r .VERSION_MAJOR)$(echo "$PLATFORM_JSON" | jq -r .VERSION_MINOR)}${SKIP_UNIT_TESTS}
 

.gitmodules

@@ -18,6 +18,9 @@
 [submodule "libraries/yubihsm"]
 	path = libraries/yubihsm
 	url = https://github.com/Yubico/yubihsm-shell
+[submodule "libraries/eos-vm"]
+	path = libraries/eos-vm
+	url = https://github.com/eosio/eos-vm
 [submodule "eosio-wasm-spec-tests"]
 	path = eosio-wasm-spec-tests
 	url = https://github.com/EOSIO/eosio-wasm-spec-tests

CMakeLists.txt

@@ -76,6 +76,13 @@ if(CMAKE_SIZEOF_VOID_P EQUAL 8 AND NOT WIN32)
    endif()
 endif()
 
+if(CMAKE_SIZEOF_VOID_P EQUAL 8 AND NOT WIN32)
+   list(APPEND EOSIO_WASM_RUNTIMES eos-vm)
+   if(CMAKE_SYSTEM_PROCESSOR STREQUAL x86_64)
+      list(APPEND EOSIO_WASM_RUNTIMES eos-vm-jit)
+   endif()
+endif()
+
 if(UNIX)
   if(APPLE)
     set(whole_archive_flag "-force_load")

libraries/CMakeLists.txt

@@ -15,6 +15,16 @@ set(RUN_RE2C OFF CACHE BOOL "Run re2c")
 set(WITH_EXCEPTIONS ON CACHE BOOL "Build with exceptions enabled" FORCE)
 add_subdirectory( wabt )
 
+set(USE_EXISTING_SOFTFLOAT ON CACHE BOOL "use pre-exisiting softfloat lib")
+set(ENABLE_TOOLS OFF CACHE BOOL "Build tools")
+set(ENABLE_TESTS OFF CACHE BOOL "Build tests")
+set(ENABLE_ADDRESS_SANITIZER OFF CACHE BOOL "Use address sanitizer")
+set(ENABLE_UNDEFINED_BEHAVIOR_SANITIZER OFF CACHE BOOL "Use UB sanitizer")
+set(ENABLE_PROFILE OFF CACHE BOOL "Enable for profile builds")
+if(eos-vm IN_LIST EOSIO_WASM_RUNTIMES OR eos-vm-jit IN_LIST EOSIO_WASM_RUNTIMES)
+add_subdirectory( eos-vm )
+endif()
+
 set(ENABLE_STATIC ON)
 set(CMAKE_MACOSX_RPATH OFF)
 set(BUILD_ONLY_LIB ON CACHE BOOL "Library only build")

libraries/chain/CMakeLists.txt

@@ -20,6 +20,11 @@ if("wavm" IN_LIST EOSIO_WASM_RUNTIMES)
    set(CHAIN_WAVM_SOURCES "webassembly/wavm.cpp")
 endif()
 
+if("eos-vm" IN_LIST EOSIO_WASM_RUNTIMES OR "eos-vm-jit" IN_LIST EOSIO_WASM_RUNTIMES)
+   set(CHAIN_EOSVM_SOURCES "webassembly/eos-vm.cpp")
+   set(CHAIN_EOSVM_LIBRARIES eos-vm)
+endif()
+
 ## SORT .cpp by most likely to change / break compile
 add_library( eosio_chain
              merkle.cpp
@@ -56,6 +61,7 @@ add_library( eosio_chain
 
              ${CHAIN_WAVM_SOURCES}
              webassembly/wabt.cpp
+             ${CHAIN_EOSVM_SOURCES}
 
 #             get_config.cpp
 #
@@ -76,11 +82,12 @@ add_library( eosio_chain
              )
 
 target_link_libraries( eosio_chain fc chainbase Logging IR WAST WASM Runtime
-                       softfloat builtins wabt
+                       softfloat builtins wabt ${CHAIN_EOSVM_LIBRARIES}
                      )
 target_include_directories( eosio_chain
                             PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include" "${CMAKE_CURRENT_BINARY_DIR}/include"
                                    "${CMAKE_CURRENT_SOURCE_DIR}/../wasm-jit/Include"
+                                   "${CMAKE_CURRENT_SOURCE_DIR}/libraries/eos-vm/include"
                                    "${CMAKE_SOURCE_DIR}/libraries/wabt"
                                    "${CMAKE_BINARY_DIR}/libraries/wabt"
                             )

libraries/chain/include/eosio/chain/platform_timer.hpp

@@ -34,7 +34,7 @@ struct platform_timer {
       _expiration_callback_data = user;
    }
 
-   volatile sig_atomic_t expired = 1;
+   std::atomic_bool expired = true;
 
 private:
    struct impl;
@@ -46,9 +46,10 @@ struct platform_timer {
       if(atomic_compare_exchange_strong(&_callback_variables_busy, &expect_false, true)) {
          void(*cb)(void*) = _expiration_callback;
          void* cb_data = _expiration_callback_data;
-         _callback_variables_busy.store(false, std::memory_order_release);
-         if(cb)
+         if(cb) {
             cb(cb_data);
+         }
+         _callback_variables_busy.store(false, std::memory_order_release);
       }
    }
 
@@ -57,4 +58,4 @@ struct platform_timer {
    void* _expiration_callback_data;
 };
 
-}}
+}}

libraries/chain/include/eosio/chain/transaction_context.hpp

@@ -21,7 +21,7 @@ namespace eosio { namespace chain {
             result in an exception. Use nullptr to disable a previously set callback. */
          void set_expiration_callback(void(*func)(void*), void* user);
 
-         volatile sig_atomic_t& expired;
+         std::atomic_bool& expired;
       private:
          platform_timer& _timer;
 

libraries/chain/include/eosio/chain/wasm_interface.hpp

@@ -3,6 +3,9 @@
 #include <eosio/chain/types.hpp>
 #include <eosio/chain/whitelisted_intrinsics.hpp>
 #include <eosio/chain/exceptions.hpp>
+#if defined(EOSIO_EOS_VM_RUNTIME_ENABLED) || defined(EOSIO_EOS_VM_JIT_RUNTIME_ENABLED)
+#include <eosio/vm/allocator.hpp>
+#endif
 #include "Runtime/Linker.h"
 #include "Runtime/Runtime.h"
 
@@ -73,7 +76,9 @@ namespace eosio { namespace chain {
       public:
          enum class vm_type {
             wavm,
-            wabt
+            wabt,
+            eos_vm,
+            eos_vm_jit
          };
 
          wasm_interface(vm_type vm, const chainbase::database& db);
@@ -85,6 +90,11 @@ namespace eosio { namespace chain {
          //validates code -- does a WASM validation pass and checks the wasm against EOSIO specific constraints
          static void validate(const controller& control, const bytes& code);
 
+#if defined(EOSIO_EOS_VM_RUNTIME_ENABLED) || defined(EOSIO_EOS_VM_JIT_RUNTIME_ENABLED)
+         //get the wasm_allocator used for the linear memory for wasm
+         static vm::wasm_allocator* get_wasm_allocator();
+#endif
+
          //indicate that a particular code probably won't be used after given block_num
          void code_block_num_last_used(const digest_type& code_hash, const uint8_t& vm_type, const uint8_t& vm_version, const uint32_t& block_num);
 
@@ -108,4 +118,4 @@ namespace eosio{ namespace chain {
    std::istream& operator>>(std::istream& in, wasm_interface::vm_type& runtime);
 }}
 
-FC_REFLECT_ENUM( eosio::chain::wasm_interface::vm_type, (wavm)(wabt) )
+FC_REFLECT_ENUM( eosio::chain::wasm_interface::vm_type, (wavm)(wabt)(eos_vm)(eos_vm_jit) )

libraries/chain/include/eosio/chain/wasm_interface_private.hpp

@@ -3,6 +3,7 @@
 #include <eosio/chain/wasm_interface.hpp>
 #include <eosio/chain/webassembly/wavm.hpp>
 #include <eosio/chain/webassembly/wabt.hpp>
+#include <eosio/chain/webassembly/eos-vm.hpp>
 #include <eosio/chain/webassembly/runtime_interface.hpp>
 #include <eosio/chain/wasm_eosio_injection.hpp>
 #include <eosio/chain/transaction_context.hpp>
@@ -16,10 +17,15 @@
 #include "WAST/WAST.h"
 #include "IR/Validate.h"
 
+#if defined(EOSIO_EOS_VM_RUNTIME_ENABLED) || defined(EOSIO_EOS_VM_JIT_RUNTIME_ENABLED)
+#include <eosio/vm/allocator.hpp>
+#endif
+
 using namespace fc;
 using namespace eosio::chain::webassembly;
 using namespace IR;
 using namespace Runtime;
+
 using boost::multi_index_container;
 
 namespace eosio { namespace chain {
@@ -44,6 +50,14 @@ namespace eosio { namespace chain {
 #endif
          if(vm == wasm_interface::vm_type::wabt)
             runtime_interface = std::make_unique<webassembly::wabt_runtime::wabt_runtime>();
+#ifdef EOSIO_EOS_VM_RUNTIME_ENABLED
+         if(vm == wasm_interface::vm_type::eos_vm)
+            runtime_interface = std::make_unique<webassembly::eos_vm_runtime::eos_vm_runtime<eosio::vm::interpreter>>();
+#endif
+#ifdef EOSIO_EOS_VM_JIT_RUNTIME_ENABLED
+         if(vm == wasm_interface::vm_type::eos_vm_jit)
+            runtime_interface = std::make_unique<webassembly::eos_vm_runtime::eos_vm_runtime<eosio::vm::jit>>();
+#endif
          if(!runtime_interface)
             EOS_THROW(wasm_exception, "${r} wasm runtime not supported on this platform and/or configuration", ("r", vm));
       }
@@ -56,6 +70,13 @@ namespace eosio { namespace chain {
                });
       }
 
+#if defined(EOSIO_EOS_VM_RUNTIME_ENABLED) || defined(EOSIO_EOS_VM_JIT_RUNTIME_ENABLED)
+      static eosio::vm::wasm_allocator* get_wasm_allocator() {
+         static eosio::vm::wasm_allocator walloc;
+         return &walloc;
+      }
+#endif
+
       std::vector<uint8_t> parse_initial_memory(const Module& module) {
          std::vector<uint8_t> mem_image;
 
@@ -115,28 +136,31 @@ namespace eosio { namespace chain {
             });
             trx_context.pause_billing_timer();
             IR::Module module;
+            std::vector<U8> bytes = {
+                (const U8*)codeobject->code.data(),
+                (const U8*)codeobject->code.data() + codeobject->code.size()};
             try {
-               Serialization::MemoryInputStream stream((const U8*)codeobject->code.data(), codeobject->code.size());
+               Serialization::MemoryInputStream stream((const U8*)bytes.data(),
+                                                       bytes.size());
                WASM::serialize(stream, module);
                module.userSections.clear();
-            } catch(const Serialization::FatalSerializationException& e) {
+            } catch (const Serialization::FatalSerializationException& e) {
                EOS_ASSERT(false, wasm_serialization_error, e.message.c_str());
-            } catch(const IR::ValidationException& e) {
+            } catch (const IR::ValidationException& e) {
                EOS_ASSERT(false, wasm_serialization_error, e.message.c_str());
             }
-
-            wasm_injections::wasm_binary_injection<true> injector(module);
-            injector.inject();
-
-            std::vector<U8> bytes;
-            try {
-               Serialization::ArrayOutputStream outstream;
-               WASM::serialize(outstream, module);
-               bytes = outstream.getBytes();
-            } catch(const Serialization::FatalSerializationException& e) {
-               EOS_ASSERT(false, wasm_serialization_error, e.message.c_str());
-            } catch(const IR::ValidationException& e) {
-               EOS_ASSERT(false, wasm_serialization_error, e.message.c_str());
+            if (runtime_interface->inject_module(module)) {
+               try {
+                  Serialization::ArrayOutputStream outstream;
+                  WASM::serialize(outstream, module);
+                  bytes = outstream.getBytes();
+               } catch (const Serialization::FatalSerializationException& e) {
+                  EOS_ASSERT(false, wasm_serialization_error,
+                             e.message.c_str());
+               } catch (const IR::ValidationException& e) {
+                  EOS_ASSERT(false, wasm_serialization_error,
+                             e.message.c_str());
+               }
             }
 
             wasm_instantiation_cache.modify(it, [&](auto& c) {
@@ -175,8 +199,9 @@ namespace eosio { namespace chain {
 #define _WRAPPED_SEQ(SEQ) BOOST_PP_CAT(_ADD_PAREN_1 SEQ, _END)
 
 #define _REGISTER_INTRINSIC_EXPLICIT(CLS, MOD, METHOD, WASM_SIG, NAME, SIG)\
-   _REGISTER_WAVM_INTRINSIC(CLS, MOD, METHOD, WASM_SIG, NAME, SIG)\
-   _REGISTER_WABT_INTRINSIC(CLS, MOD, METHOD, WASM_SIG, NAME, SIG)
+   _REGISTER_WAVM_INTRINSIC(CLS, MOD, METHOD, WASM_SIG, NAME, SIG)         \
+   _REGISTER_WABT_INTRINSIC(CLS, MOD, METHOD, WASM_SIG, NAME, SIG)         \
+   _REGISTER_EOS_VM_INTRINSIC(CLS, MOD, METHOD, WASM_SIG, NAME, SIG)
 
 #define _REGISTER_INTRINSIC4(CLS, MOD, METHOD, WASM_SIG, NAME, SIG)\
    _REGISTER_INTRINSIC_EXPLICIT(CLS, MOD, METHOD, WASM_SIG, NAME, SIG )

libraries/chain/include/eosio/chain/webassembly/common.hpp

@@ -7,7 +7,7 @@
 
 using namespace fc;
 
-namespace eosio { namespace chain { 
+namespace eosio { namespace chain {
 
    class apply_context;
    class transaction_context;
@@ -23,7 +23,7 @@ namespace eosio { namespace chain {
          return T(ctx);
       }
    };
-   
+
    template<>
    struct class_from_wasm<transaction_context> {
       /**
@@ -68,13 +68,12 @@ namespace eosio { namespace chain {
          return value;
       }
 
-      template<typename U>
-      operator U *() const {
-         return static_cast<U *>(value);
+      operator T *() const {
+         return value;
       }
 
       T *value;
-   }; 
+   };
 
    /**
     * class to represent an in-wasm-memory char array that must be null terminated
@@ -90,9 +89,8 @@ namespace eosio { namespace chain {
          return value;
       }
 
-      template<typename U>
-      operator U *() const {
-         return static_cast<U *>(value);
+      operator char *() const {
+         return value;
       }
 
       char *value;