add code coverage host functions

libraries/chain/CMakeLists.txt

@@ -62,6 +62,7 @@ set(CHAIN_WEBASSEMBLY_SOURCES
    webassembly/compiler_builtins.cpp
    webassembly/context_free.cpp
    webassembly/console.cpp
+   webassembly/coverage.cpp
    webassembly/crypto.cpp
    webassembly/database.cpp
    webassembly/kv_database.cpp

libraries/chain/controller.cpp

@@ -277,6 +277,7 @@ struct controller_impl {
       set_activation_handler<builtin_protocol_feature_t::kv_database>();
       set_activation_handler<builtin_protocol_feature_t::configurable_wasm_limits>();
       set_activation_handler<builtin_protocol_feature_t::blockchain_parameters>();
+      set_activation_handler<builtin_protocol_feature_t::wasm_code_coverage>();
 
       self.irreversible_block.connect([this](const block_state_ptr& bsp) {
          wasmif.current_lib(bsp->block_num);
@@ -3456,6 +3457,19 @@ void controller_impl::on_activation<builtin_protocol_feature_t::blockchain_param
    } );
 }
 
+template<>
+void controller_impl::on_activation<builtin_protocol_feature_t::wasm_code_coverage>() {
+   db.modify( db.get<protocol_state_object>(), [&]( auto& ps ) {
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "coverage_inc_fun_cnt" );
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "coverage_inc_line_cnt" );
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "coverage_get_fun_cnt" );
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "coverage_get_line_cnt" );
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "coverage_dump" );
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "coverage_reset" );
+   } );
+}
+
+
 /// End of protocol feature activation handlers
 
 } } /// eosio::chain

libraries/chain/include/eosio/chain/protocol_feature_manager.hpp

@@ -26,7 +26,8 @@ enum class builtin_protocol_feature_t : uint32_t {
    action_return_value,
    kv_database,
    configurable_wasm_limits,
-   blockchain_parameters
+   blockchain_parameters,
+   wasm_code_coverage
 };
 
 struct protocol_feature_subjective_restrictions {

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

@@ -276,7 +276,13 @@ 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_inc_fun_cnt"_s,
+   "env.coverage_inc_line_cnt"_s,
+   "env.coverage_get_fun_cnt"_s,
+   "env.coverage_get_line_cnt"_s,
+   "env.coverage_dump"_s,
+   "env.coverage_reset"_s
 );
 
 }}}

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

@@ -1897,6 +1897,14 @@ 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 
+         void coverage_inc_fun_cnt(account_name code, uint32_t file_num, uint32_t func_num);
+         void coverage_inc_line_cnt(account_name code, uint32_t file_num, uint32_t line_num);
+         uint32_t coverage_get_fun_cnt(account_name code, uint32_t file_num, uint32_t func_num);
+         uint32_t coverage_get_line_cnt(account_name code, uint32_t file_num, uint32_t line_num);
+         void coverage_dump();
+         void coverage_reset();
+
       private:
          apply_context& context;
    };

libraries/chain/webassembly/coverage.cpp

@@ -0,0 +1,94 @@
+#include <eosio/chain/webassembly/interface.hpp>
+
+#include <unordered_map>
+#include <fstream>
+
+namespace eosio { namespace chain { namespace webassembly {
+   static std::unordered_map<name, std::unordered_map<uint32_t, std::unordered_map<uint32_t, uint32_t> > > funcnt_map;
+   static std::unordered_map<name, std::unordered_map<uint32_t, std::unordered_map<uint32_t, uint32_t> > > linecnt_map;
+
+   void interface::coverage_inc_fun_cnt(account_name code, uint32_t file_num, uint32_t func_num) {
+       auto &code_map = funcnt_map[code];
+       auto &funcnt = code_map[file_num];
+       funcnt[func_num]++;
+   }
+
+   void interface::coverage_inc_line_cnt(account_name code, uint32_t file_num, uint32_t line_num) {
+       auto &code_map = linecnt_map[code];
+       auto &linecnt = code_map[file_num];
+       linecnt[line_num]++;
+   }
+
+   uint32_t interface::coverage_get_fun_cnt(account_name code, uint32_t file_num, uint32_t func_num) {
+       uint32_t ret_val = 0;
+       if (funcnt_map.count(code) > 0) {
+            auto &code_map = funcnt_map[code];
+            if (code_map.count(file_num) > 0) {
+                auto &funcnt = code_map[file_num];
+                if (funcnt.count(func_num) > 0) {
+                    ret_val = funcnt[func_num];
+                }
+            }
+       }
+       return ret_val;
+   }
+
+   uint32_t interface::coverage_get_line_cnt(account_name code, uint32_t file_num, uint32_t line_num) {
+       uint32_t ret_val = 0;
+       if (linecnt_map.count(code) > 0) {
+            auto &code_map = linecnt_map[code];
+            if (code_map.count(file_num) > 0) {
+                auto &linecnt = code_map[file_num];
+                if (linecnt.count(line_num) > 0) {
+                    ret_val = linecnt[line_num];
+                }
+            }
+       }
+       return ret_val;
+   }
+
+   void interface::coverage_dump() {
+       auto fName = std::string("call-counts.json");
+       std::ofstream out_json_file;
+       out_json_file.open(fName);
+
+       // dont use auto JSON serialization because 
+       // we want to convert maps to arrays
+       out_json_file << "{\n";
+       out_json_file << "\t\"functions\": {";
+       for (auto code_map : funcnt_map) {
+            auto code_str = code_map.first.to_string();
+            out_json_file << "\t\t\"" << code_str <<"\": [\n";
+            for (auto funcnt : code_map.second) {
+                auto file_num = funcnt.first;
+                for (auto func : funcnt.second) {
+                    auto func_num = func.first;
+                    auto calls = func.second;
+                    out_json_file << "\t\t\t[" << file_num << ", " << func_num << ", " << calls << "]\n";
+                }
+            }
+            out_json_file << "\t\t]\n";
+       }
+       out_json_file << "\t}\n";
+
+       out_json_file << "\t\"lines\": {";
+       for (auto code_map : linecnt_map) {
+            auto code_str = code_map.first.to_string();
+            out_json_file << "{ \"" << code_str <<"\"";
+
+            for (auto linecnt : code_map.second) {
+                for (auto line : linecnt.second) {
+
+                }
+            }
+            out_json_file << "]\n";
+       }
+       out_json_file << "\t}\n";
+       out_json_file.close();
+   }
+
+   void interface::coverage_reset() {
+       funcnt_map.clear();
+       linecnt_map.clear();
+   }
+}}}

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

@@ -574,6 +574,14 @@ REGISTER_CF_HOST_FUNCTION(__letf2);
 REGISTER_CF_HOST_FUNCTION(__lttf2);
 REGISTER_CF_HOST_FUNCTION(__unordtf2);
 
+// code coverage API 
+REGISTER_HOST_FUNCTION(coverage_inc_fun_cnt)
+REGISTER_HOST_FUNCTION(coverage_inc_line_cnt)
+REGISTER_HOST_FUNCTION(coverage_get_fun_cnt)
+REGISTER_HOST_FUNCTION(coverage_get_line_cnt)
+REGISTER_HOST_FUNCTION(coverage_dump)
+REGISTER_HOST_FUNCTION(coverage_reset)
+
 } // namespace webassembly
 } // namespace chain
 } // namespace eosio