add code coverage host functions

libraries/chain/include/eosio/chain/controller.hpp

@@ -12,6 +12,7 @@
 #include <eosio/chain/block_log_config.hpp>
 #include <eosio/chain/backing_store.hpp>
 
+struct test_chain;
 namespace chainbase {
    class database;
 }
@@ -399,6 +400,7 @@ namespace eosio { namespace chain {
       private:
          friend class apply_context;
          friend class transaction_context;
+         friend struct ::test_chain;
 
          chainbase::database& mutable_db()const;
 

libraries/chain/include/eosio/chain/webassembly/eos-vm-oc/intrinsic_mapping.hpp

@@ -276,7 +276,9 @@ constexpr auto intrinsic_table = boost::hana::make_tuple(
    "env.push_data"_s,
    "env.print_time_us"_s,
    "env.get_input_data"_s,
-   "env.set_output_data"_s
+   "env.set_output_data"_s,
+   "env.coverage_getinc"_s,
+   "env.coverage_dump"_s
 );
 
 }}}

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

@@ -1897,6 +1897,10 @@ namespace eosio { namespace chain { namespace webassembly {
          int32_t __lttf2(uint64_t, uint64_t, uint64_t, uint64_t) const;
          int32_t __unordtf2(uint64_t, uint64_t, uint64_t, uint64_t) const;
 
+         // code coverage support functions 
+         uint32_t coverage_getinc(uint64_t code, uint32_t file_num, uint32_t func_or_line_num, uint32_t mode, bool inc);
+         uint64_t coverage_dump(uint64_t code, uint32_t file_num, span<const char> file_name, uint32_t max, bool append, uint32_t mode, bool reset);
+
       private:
          apply_context& context;
    };

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

@@ -3,6 +3,9 @@
 #include <eosio/chain/types.hpp>
 #include <eosio/chain/webassembly/common.hpp>
 #include <eosio/chain/webassembly/eos-vm.hpp>
+#ifdef EOSIO_EOS_VM_OC_RUNTIME_ENABLED
+#include <eosio/chain/webassembly/eos-vm-oc.hpp>
+#endif
 
 #include <eosio/vm/backend.hpp>
 #include <eosio/vm/host_function.hpp>
@@ -167,4 +170,16 @@ namespace eosio { namespace chain { namespace webassembly {
             static_assert( are_whitelisted_legacy_types_v<std::decay_t<decltype(args)>...>, "legacy whitelisted type violation");
          }));
 
+   template <auto HostFunction, typename... Preconditions>
+   struct host_function_registrator {
+      template <typename Mod, typename Name>
+      constexpr host_function_registrator(Mod mod_name, Name fn_name) {
+         using rhf_t = eos_vm_host_functions_t;
+         rhf_t::add<HostFunction, Preconditions...>(mod_name.c_str(), fn_name.c_str());
+   #ifdef EOSIO_EOS_VM_OC_RUNTIME_ENABLED
+         eosvmoc::register_eosvm_oc<HostFunction, std::tuple<Preconditions...>>(mod_name + BOOST_HANA_STRING(".") + fn_name);
+   #endif
+      }
+   };
+
 }}} // ns eosio::chain::webassembly

libraries/chain/webassembly/runtimes/eos-vm.cpp

@@ -7,11 +7,7 @@
 //eos-vm includes
 #include <eosio/vm/backend.hpp>
 #include <eosio/chain/webassembly/preconditions.hpp>
-#ifdef EOSIO_EOS_VM_OC_RUNTIME_ENABLED
-#include <eosio/chain/webassembly/eos-vm-oc.hpp>
-#endif
 #include <boost/hana/string.hpp>
-#include <boost/hana/equal.hpp>
 
 namespace eosio { namespace chain { namespace webassembly { namespace eos_vm_runtime {
 
@@ -289,18 +285,6 @@ std::unique_ptr<wasm_instantiated_module_interface> eos_vm_profile_runtime::inst
 
 }
 
-template <auto HostFunction, typename... Preconditions>
-struct host_function_registrator {
-   template <typename Mod, typename Name>
-   constexpr host_function_registrator(Mod mod_name, Name fn_name) {
-      using rhf_t = eos_vm_host_functions_t;
-      rhf_t::add<HostFunction, Preconditions...>(mod_name.c_str(), fn_name.c_str());
-#ifdef EOSIO_EOS_VM_OC_RUNTIME_ENABLED
-      eosvmoc::register_eosvm_oc<HostFunction, std::tuple<Preconditions...>>(mod_name + BOOST_HANA_STRING(".") + fn_name);
-#endif
-   }
-};
-
 #define REGISTER_HOST_FUNCTION(NAME, ...)                                                                              \
    static host_function_registrator<&interface::NAME, core_precondition, context_aware_check, ##__VA_ARGS__>           \
        NAME##_registrator_impl() {                                                                                     \

libraries/rodeos/include/b1/rodeos/callbacks/coverage.hpp

@@ -0,0 +1,61 @@
+#pragma once
+
+#include <b1/rodeos/callbacks/vm_types.hpp>
+#include <eosio/coverage.hpp>
+
+namespace b1::rodeos {
+
+using eosio::coverage::coverage_maps;
+using eosio::coverage::coverage_mode;
+
+constexpr auto rodeos_n = eosio::name{"rodeos"}.value;
+
+struct coverage_state {
+};
+
+template <typename Derived>
+struct coverage_callbacks {
+   Derived& derived() { return static_cast<Derived&>(*this); }
+
+   uint32_t coverage_getinc(uint64_t code, uint32_t file_num, uint32_t func_or_line_num, uint32_t mode, bool inc) {
+      if(inc) {
+         if (mode == coverage_mode::func) {
+            eosio::coverage::coverage_inc_cnt(code, file_num, func_or_line_num, coverage_maps<rodeos_n>::instance().funcnt_map);
+         } else if (mode == coverage_mode::line) {
+            eosio::coverage::coverage_inc_cnt(code, file_num, func_or_line_num, coverage_maps<rodeos_n>::instance().linecnt_map);
+         }
+      }
+      else {
+         if (mode == coverage_mode::func) {
+            return eosio::coverage::coverage_get_cnt(code, file_num, func_or_line_num, coverage_maps<rodeos_n>::instance().funcnt_map);
+         }
+         else if (mode == coverage_mode::line) {
+            return eosio::coverage::coverage_get_cnt(code, file_num, func_or_line_num, coverage_maps<rodeos_n>::instance().linecnt_map);
+         }
+      }
+      return 0;
+   }
+
+   uint64_t coverage_dump(uint64_t code, uint32_t file_num, eosio::vm::span<const char> file_name, uint32_t max, bool append, uint32_t mode, bool reset) {
+      if (reset) {
+         coverage_maps<rodeos_n>::instance().funcnt_map.clear();
+         coverage_maps<rodeos_n>::instance().linecnt_map.clear();
+      }
+      else if (mode == coverage_mode::func) {
+         return eosio::coverage::coverage_dump(code, file_num, file_name.data(), file_name.size(), max, append, coverage_maps<rodeos_n>::instance().funcnt_map);
+      }
+      else if (mode == coverage_mode::line) {
+         return eosio::coverage::coverage_dump(code, file_num, file_name.data(), file_name.size(), max, append, coverage_maps<rodeos_n>::instance().linecnt_map);
+      }
+      return 0;
+   }
+
+   template <typename Rft>
+   static void register_callbacks() {
+      // todo: preconditions
+      RODEOS_REGISTER_CALLBACK(Rft, Derived, coverage_getinc);
+      RODEOS_REGISTER_CALLBACK(Rft, Derived, coverage_dump);
+   }
+}; // coverage_callbacks
+
+} // namespace b1::rodeos

libraries/rodeos/include/b1/rodeos/filter.hpp

@@ -10,6 +10,7 @@
 #include <b1/rodeos/callbacks/system.hpp>
 #include <b1/rodeos/callbacks/unimplemented.hpp>
 #include <b1/rodeos/callbacks/unimplemented_filter.hpp>
+#include <b1/rodeos/callbacks/coverage.hpp>
 #ifdef EOSIO_EOS_VM_OC_RUNTIME_ENABLED
 #   include <eosio/chain/webassembly/eos-vm-oc/code_cache.hpp>
 #   include <eosio/chain/webassembly/eos-vm-oc/executor.hpp>
@@ -65,19 +66,23 @@ struct callbacks : b1::rodeos::chaindb_callbacks<callbacks>,
                    b1::rodeos::filter_callbacks<callbacks>,
                    b1::rodeos::memory_callbacks<callbacks>,
                    b1::rodeos::unimplemented_callbacks<callbacks>,
-                   b1::rodeos::system_callbacks<callbacks> {
+                   b1::rodeos::system_callbacks<callbacks>, 
+                   b1::rodeos::coverage_callbacks<callbacks> {
    filter::filter_state&      filter_state;
    b1::rodeos::chaindb_state& chaindb_state;
    b1::rodeos::db_view_state& db_view_state;
+   b1::rodeos::coverage_state& coverage_state;
 
    callbacks(filter::filter_state& filter_state, b1::rodeos::chaindb_state& chaindb_state,
-             b1::rodeos::db_view_state& db_view_state)
-       : filter_state{ filter_state }, chaindb_state{ chaindb_state }, db_view_state{ db_view_state } {}
+             b1::rodeos::db_view_state& db_view_state, b1::rodeos::coverage_state& coverage_state)
+       : filter_state{ filter_state }, chaindb_state{ chaindb_state }, db_view_state{ db_view_state }
+       , coverage_state{ coverage_state } {}
 
    auto& get_state() { return filter_state; }
    auto& get_filter_callback_state() { return filter_state; }
    auto& get_chaindb_state() { return chaindb_state; }
    auto& get_db_view_state() { return db_view_state; }
+   auto& get_coverage_state() { return coverage_state; }
 };
 
 inline void register_callbacks() {
@@ -92,6 +97,7 @@ inline void register_callbacks() {
    b1::rodeos::memory_callbacks<callbacks>::register_callbacks<rhf_t>();
    b1::rodeos::system_callbacks<callbacks>::register_callbacks<rhf_t>();
    b1::rodeos::unimplemented_callbacks<callbacks>::register_callbacks<rhf_t>();
+   b1::rodeos::coverage_callbacks<callbacks>::register_callbacks<rhf_t>();
 }
 
 } // namespace b1::rodeos::filter

libraries/rodeos/include/eosio/coverage.hpp

@@ -0,0 +1,110 @@
+#pragma once
+
+#include <eosio/chain/name.hpp>
+#include <unordered_map>
+#include <string>
+#include <fstream>
+
+using cov_map_t = std::unordered_map<uint64_t, std::unordered_map<uint32_t, std::unordered_map<uint32_t, uint32_t> > >;
+
+// rodeos lib is not the ideal location for this as it is also used by eosio-tester but rodeos lib keeps it out of nodeos
+namespace eosio {
+namespace coverage {
+
+template<uint64_t Unique>
+class coverage_maps {
+   public:
+      static coverage_maps& instance() {
+         static coverage_maps instance;
+         return instance;
+      }
+      coverage_maps(const coverage_maps&) = delete;
+      void operator=(const coverage_maps&) = delete;
+
+      cov_map_t funcnt_map;
+      cov_map_t linecnt_map;
+   private:
+      coverage_maps() = default;
+};
+
+enum class coverage_mode : uint32_t {
+   func=0,
+   line=1
+};
+
+inline void coverage_inc_cnt( uint64_t code, uint32_t file_num, uint32_t func_or_line_num, cov_map_t& cov_map) {
+   auto& code_map = cov_map[code];
+   auto& cnt_map = code_map[file_num];
+   cnt_map[func_or_line_num]++;
+}
+
+inline uint32_t coverage_get_cnt( uint64_t code, uint32_t file_num, uint32_t func_or_line_num, cov_map_t& cov_map) {
+   auto& code_map = cov_map[code];
+   auto& cnt_map = code_map[file_num];
+   return cnt_map[func_or_line_num];
+}
+
+// dump coverage output (function or line) to binary file
+// if code == 0, begin at first code in the map
+//    max is only checked for every code, so it is possible to exceed the number
+// if max == 0, then only dump coverage for specific code and specific file_num
+//     in theis case code must be > 0
+// returns the next code, or 0 if at end
+inline uint64_t coverage_dump(uint64_t code, uint32_t file_num, const char* file_name, uint32_t file_name_size, uint32_t max, bool append, cov_map_t& cov_map) {
+   std::ofstream out_bin_file;
+   auto flags = std::ofstream::out | std::ofstream::binary;
+   if (append)
+      flags = flags | std::ofstream::app;
+   else
+      flags = flags | std::ofstream::trunc;
+
+   ilog("coverage_dump_funcnt: file_name= ${f} max= ${max} ${app}", ("f", file_name)("nax", max)("app", append));
+   out_bin_file.open(file_name, flags );
+   uint32_t i = 0;
+   auto code_itr = cov_map.begin();
+   if (max == 0 && code == 0) {
+      elog("coverage_dump_funcnt: when max == 0, code must be > 0");
+      return 0;
+   }
+   if (code > 0) {
+      code_itr = cov_map.find(code);
+   }
+   while (code_itr != cov_map.end() && (max == 0 || i < max)) {
+      auto codenum = code_itr->first;
+      auto& filenum_map = code_itr->second;
+      auto filenum_itr = filenum_map.begin();
+      if (max == 0) {
+         filenum_itr = filenum_map.find(file_num);
+      }
+      while (filenum_itr != filenum_map.end()) {
+         auto filenum = filenum_itr->first;
+         auto& funcnum_map = filenum_itr->second;
+         for (const auto& funcnum_itr : funcnum_map) {
+            auto func_or_line_num = funcnum_itr.first;
+            auto calls = funcnum_itr.second;
+            out_bin_file.write(reinterpret_cast<const char*>(&codenum), sizeof(code));
+            out_bin_file.write(reinterpret_cast<const char*>(&filenum), sizeof(filenum));
+            out_bin_file.write(reinterpret_cast<const char*>(&func_or_line_num), sizeof(func_or_line_num));
+            out_bin_file.write(reinterpret_cast<const char*>(&calls), sizeof(calls));
+            ++i;
+         }
+         ++filenum_itr;
+         if (max == 0)
+            break;
+      }
+      ++code_itr;
+      if (max == 0)
+         break;
+   }
+
+   out_bin_file.flush();
+   out_bin_file.close();
+
+   uint64_t r = 0;
+   if(code_itr != cov_map.end())
+      r = code_itr->first;
+   return r;
+}
+
+} // namespace coverage
+} // namespace eosio

libraries/rodeos/rodeos.cpp

@@ -337,8 +337,9 @@ void rodeos_filter::process(rodeos_db_snapshot& snapshot, const ship_protocol::g
    snapshot.check_write(result);
    chaindb_state chaindb_state;
    db_view_state view_state{ name, *snapshot.db, *snapshot.write_session, snapshot.partition->contract_kv_prefix };
+   coverage_state coverage_state;
    view_state.kv_state.enable_write  = true;
-   filter::callbacks cb{ *filter_state, chaindb_state, view_state };
+   filter::callbacks cb{ *filter_state, chaindb_state, view_state, coverage_state };
    filter_state->max_console_size = 10000;
    filter_state->console.clear();
    filter_state->input_data = bin;

libraries/rodeos/wasm_ql.cpp

@@ -6,6 +6,7 @@
 #include <b1/rodeos/callbacks/crypto.hpp>
 #include <b1/rodeos/callbacks/memory.hpp>
 #include <b1/rodeos/callbacks/unimplemented.hpp>
+#include <b1/rodeos/callbacks/coverage.hpp>
 #include <b1/rodeos/rodeos.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/multi_index/member.hpp>
@@ -72,18 +73,22 @@ struct callbacks : action_callbacks<callbacks>,
                    db_callbacks<callbacks>,
                    memory_callbacks<callbacks>,
                    query_callbacks<callbacks>,
-                   unimplemented_callbacks<callbacks> {
+                   unimplemented_callbacks<callbacks>, 
+                   coverage_callbacks<callbacks> {
    wasm_ql::thread_state& thread_state;
    rodeos::chaindb_state& chaindb_state;
    rodeos::db_view_state& db_view_state;
+   rodeos::coverage_state& coverage_state;
 
    callbacks(wasm_ql::thread_state& thread_state, rodeos::chaindb_state& chaindb_state,
-             rodeos::db_view_state& db_view_state)
-       : thread_state{ thread_state }, chaindb_state{ chaindb_state }, db_view_state{ db_view_state } {}
+             rodeos::db_view_state& db_view_state, rodeos::coverage_state& coverage_state)
+       : thread_state{ thread_state }, chaindb_state{ chaindb_state }, db_view_state{ db_view_state }
+       , coverage_state{ coverage_state } {}
 
    auto& get_state() { return thread_state; }
    auto& get_chaindb_state() { return chaindb_state; }
    auto& get_db_view_state() { return db_view_state; }
+   auto& get_coverage_state() { return coverage_state; }
 };
 
 std::once_flag registered_callbacks;
@@ -99,6 +104,7 @@ void register_callbacks() {
    memory_callbacks<callbacks>::register_callbacks<rhf_t>();
    query_callbacks<callbacks>::register_callbacks<rhf_t>();
    unimplemented_callbacks<callbacks>::register_callbacks<rhf_t>();
+   coverage_callbacks<callbacks>::register_callbacks<rhf_t>();
 }
 
 struct backend_entry {
@@ -273,7 +279,8 @@ void run_action(wasm_ql::thread_state& thread_state, const std::vector<char>& co
    thread_state.block_info.reset();
 
    chaindb_state chaindb_state;
-   callbacks     cb{ thread_state, chaindb_state, db_view_state };
+   coverage_state coverage_state;
+   callbacks     cb{ thread_state, chaindb_state, db_view_state, coverage_state };
    entry->backend->set_wasm_allocator(&thread_state.wa);
 
    try {