// MIT License
//
// Copyright (c) 2022 Advanced Micro Devices, Inc. All Rights Reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.

#include "module_function.hpp"
#include "InstructionCategories.h"
#include "fwd.hpp"
#include "log.hpp"
#include "omnitrace.hpp"

#include <stdexcept>

module_function::width_t&
module_function::get_width()
{
    static width_t _instance = []() {
        width_t _tmp;
        _tmp.fill(0);
        return _tmp;
    }();
    return _instance;
}

void
module_function::reset_width()
{
    get_width().fill(0);
}

void
module_function::update_width(const module_function& rhs)
{
    get_width()[0] = std::max<size_t>(get_width()[0], rhs.module_name.length());
    get_width()[1] = std::max<size_t>(get_width()[1], rhs.function_name.length());
    get_width()[2] = std::max<size_t>(get_width()[2], rhs.signature.get().length());
}

module_function::module_function(module_t* mod, procedure_t* proc)
: module{ mod }
, function{ proc }
, flow_graph{ proc->getCFG() }
, module_name{ get_name(module) }
, function_name{ get_name(function) }
{
    OMNITRACE_ADD_LOG_ENTRY("Adding function", function_name, "from module", module_name);

    if(!function->isInstrumentable())
    {
        verbprintf(1,
                   "Warning! module function generated for un-instrumentable "
                   "function: %s [%s]\n",
                   function_name.c_str(), module_name.c_str());
    }

    auto _range = std::pair<address_t, address_t>{};
    if(function->getAddressRange(_range.first, _range.second))
    {
        start_address = _range.first;
        address_range = _range.second - _range.first;
    }

    signature = get_func_file_line_info(module, function);

    // make sure all exist
    for(int i = 0; i <= instruction_category_t::c_NoCategory; ++i)
        instruction_types[static_cast<instruction_category_t>(i)] = 0;

    if(function->isInstrumentable())
    {
        // this information is potentially not available and
        // appears to be the cause of a segfault in testing
        // so only attempt to extract it for instrumentable
        // functions
        if(flow_graph)
        {
            flow_graph->getAllBasicBlocks(basic_blocks);
            flow_graph->getOuterLoops(loop_blocks);
        }

        instructions.reserve(basic_blocks.size());
        size_t _n = 0;
        for(const auto& itr : basic_blocks)
        {
            std::vector<std::pair<instruction_t, address_t>> _instructions{};
            try
            {
                if(itr->getInstructions(_instructions))
                {
                    auto _num_instr = _instructions.size();
                    num_instructions += _num_instr;
                    for(auto&& iitr : _instructions)
                    {
                        instruction_types[iitr.first.getCategory()] += 1;
                    }
                    // num_instructions += _instructions.size();
                    if(debug_print || verbose_level > 3 || instr_print)
                        instructions.emplace_back(std::move(_instructions));
                }
                else
                {
                    // on average, the number of instructions is address range / 4
                    auto _num_instr = (itr->getEndAddress() - itr->getStartAddress()) / 4;
                    verbprintf(2,
                               "No instructions found for basic block %zu in %s. "
                               "Approximating with %lu...\n",
                               _n, function_name.c_str(), _num_instr);
                    num_instructions += _num_instr;
                }
            } catch(std::runtime_error& _e)
            {
                errprintf(1, "Dyninst error: %s\n", _e.what());
            }
            ++_n;
        }
    }
}

void
module_function::write_header(std::ostream& os)
{
    auto w0 = std::min<size_t>(get_width()[0], absolute_max_width);
    auto w1 = std::min<size_t>(get_width()[1], absolute_max_width);
    auto w2 = std::min<size_t>(get_width()[2], absolute_max_width);

    std::stringstream ss;
    ss << std::setw(14) << "StartAddress"
       << " " << std::setw(14) << "AddressRange"
       << " " << std::setw(14) << "#Instructions"
       << " " << std::setw(6) << "Ratio"
       << "  " << std::setw(w0 + 8) << std::left << "Module"
       << " " << std::setw(w1 + 8) << std::left << "Function"
       << " " << std::setw(w2 + 8) << std::left << "FunctionSignature"
       << "\n";
    os << ss.str();
}

bool
module_function::should_instrument() const
{
    return should_instrument(false);
}

bool
module_function::should_coverage_instrument() const
{
    // hard constraints
    if(!is_instrumentable()) return false;
    if(!can_instrument_entry()) return false;
    if(is_module_constrained()) return false;
    if(is_routine_constrained()) return false;

    // should be before user selection
    constexpr int absolute_min_instructions = 2;
    if(num_instructions < absolute_min_instructions)
    {
        messages.emplace_back(
            2, "Skipping", "function",
            TIMEMORY_JOIN("-", "less-than", absolute_min_instructions, "instructions"),
            function_name);
        return false;
    }

    // user selection
    if(is_user_excluded()) return false;

    if(is_overlapping_constrained()) return false;
    if(is_entry_trap_constrained()) return false;

    // user selection
    if(!file_restrict.empty() || !func_restrict.empty()) return !is_user_restricted();
    if(is_user_included()) return true;

    if(is_address_range_constrained()) return false;
    if(is_num_instructions_constrained()) return false;

    return true;
}

bool
module_function::should_instrument(bool coverage) const
{
    // hard constraints
    if(!is_instrumentable()) return false;
    if(!can_instrument_entry()) return false;
    if(!coverage && !can_instrument_exit()) return false;
    if(is_module_constrained()) return false;
    if(is_routine_constrained()) return false;

    // should be before user selection
    constexpr int absolute_min_instructions = 2;
    if(num_instructions < absolute_min_instructions)
    {
        messages.emplace_back(
            2, "Skipping", "function",
            TIMEMORY_JOIN("-", "less-than", absolute_min_instructions, "instructions"),
            function_name);
        return false;
    }

    // user selection
    if(is_user_excluded()) return false;

    // should be applied before dynamic-callsite check
    if(is_overlapping_constrained()) return false;
    if(is_entry_trap_constrained()) return false;
    if(!coverage && is_exit_trap_constrained()) return false;

    // needs to be applied before address range and number of instruction constraints
    if(is_dynamic_callsite_forced()) return true;

    // user selection
    if(!file_restrict.empty() || !func_restrict.empty()) return !is_user_restricted();
    if(is_user_included()) return true;

    if(is_address_range_constrained()) return false;
    if(is_num_instructions_constrained()) return false;

    return true;
}

bool
module_function::is_instrumentable() const
{
    if(!function->isInstrumentable())
    {
        messages.emplace_back(2, "Skipping", "module", "not-instrumentable", module_name);
        return false;
    }

    return true;
}

namespace
{
bool
check_regex_restrictions(const std::string& _name, const regexvec_t& _regexes)
{
    // NOLINTNEXTLINE
    for(auto& itr : _regexes)
        if(std::regex_search(_name, itr)) return true;
    return false;
}
}  // namespace

bool
module_function::is_user_restricted() const
{
    if(!file_restrict.empty())
    {
        if(check_regex_restrictions(module_name, file_restrict))
        {
            messages.emplace_back(2, "Forcing", "module", "module-restrict-regex",
                                  module_name);
            return false;
        }
        else
        {
            messages.emplace_back(3, "Skipping", "module", "module-restrict-regex",
                                  module_name);
            return true;
        }
    }

    if(!func_restrict.empty())
    {
        if(check_regex_restrictions(function_name, func_restrict))
        {
            messages.emplace_back(2, "Forcing", "function", "function-restrict-regex",
                                  function_name);
            return false;
        }
        else if(check_regex_restrictions(signature.get(), func_restrict))
        {
            messages.emplace_back(2, "Forcing", "function", "function-restrict-regex",
                                  signature.get());
            return false;
        }
        else
        {
            messages.emplace_back(3, "Skipping", "function", "function-restrict-regex",
                                  function_name);
            return true;
        }
    }

    return false;
}

bool
module_function::is_user_included() const
{
    if(!file_include.empty())
    {
        if(check_regex_restrictions(module_name, file_include))
        {
            messages.emplace_back(2, "Forcing", "module", "module-include-regex",
                                  module_name);
            return true;
        }
    }

    if(!func_include.empty())
    {
        if(check_regex_restrictions(function_name, func_include))
        {
            messages.emplace_back(2, "Forcing", "function", "function-include-regex",
                                  function_name);
            return true;
        }
        else if(check_regex_restrictions(signature.get(), func_include))
        {
            messages.emplace_back(2, "Forcing", "function", "function-include-regex",
                                  signature.get());
            return true;
        }
    }

    return false;
}

bool
module_function::is_user_excluded() const
{
    if(!file_exclude.empty())
    {
        if(check_regex_restrictions(module_name, file_exclude))
        {
            messages.emplace_back(2, "Skipping", "module", "module-exclude-regex",
                                  module_name);
            return true;
        }
    }

    if(!func_exclude.empty())
    {
        if(check_regex_restrictions(function_name, func_exclude))
        {
            messages.emplace_back(2, "Skipping", "function", "function-exclude-regex",
                                  function_name);
            return true;
        }
        else if(check_regex_restrictions(signature.get(), func_exclude))
        {
            messages.emplace_back(2, "Skipping", "function", "function-exclude-regex",
                                  signature.get());
            return true;
        }
    }

    return false;
}

bool
module_function::is_overlapping() const
{
    procedure_vec_t _overlapping{};
    return function->findOverlapping(_overlapping);
}

bool
module_function::is_module_constrained() const
{
    auto regex_opts = std::regex_constants::egrep | std::regex_constants::optimize;
    auto _report    = [&](const string_t& _action, const string_t& _reason, int _lvl) {
        messages.emplace_back(_lvl, _action, "module", _reason, module_name);
        return true;
    };

    if(module->isSystemLib()) return _report("Excluding", "system library", 3);

    // always instrument these modules
    if(module_name == "DEFAULT_MODULE" || module_name == "LIBRARY_MODULE")
        return _report("Skipping", "default module", 2);

    static std::regex ext_regex{ "\\.(s|S)$", regex_opts };
    static std::regex sys_regex{ "^(s|k|e|w)_[A-Za-z_0-9\\-]+\\.(c|C)$", regex_opts };
    static std::regex sys_build_regex{ "^(\\.\\./sysdeps/|/build/)", regex_opts };
    static std::regex dyninst_regex{ "(dyninst|DYNINST|(^|/)RT[[:graph:]]+\\.c$)",
                                     regex_opts };
    static std::regex dependlib_regex{ "^(lib|)(omnitrace|pthread|caliper|gotcha|papi|"
                                       "cupti|TAU|likwid|pfm|nvperf|unwind)",
                                       regex_opts };
    static std::regex core_cmod_regex{
        "^(malloc|(f|)lock|sig|sem)[a-z_]+(|64|_r|_l)\\.c$"
    };
    static std::regex core_lib_regex{
        "^(lib|)(c|dl|dw|pthread|tcmalloc|profiler|"
        "tbbmalloc|tbbmalloc_proxy|malloc|stdc\\+\\+)(-|\\.)",
        regex_opts
    };
    static std::regex prefix_regex{ "^(_|\\.[a-zA-Z0-9])", regex_opts };

    // file extensions that should not be instrumented
    if(std::regex_search(module_name, ext_regex))
        return _report("Excluding", "file extension", 3);

    // system modules that should not be instrumented (wastes time)
    if(std::regex_search(module_name, sys_regex) ||
       std::regex_search(module_name, sys_build_regex))
        return _report("Excluding", "system module", 3);

    // dyninst modules that must not be instrumented
    if(std::regex_search(module_name, dyninst_regex))
        return _report("Excluding", "dyninst module", 3);

    // modules used by omnitrace and dependent libraries
    if(std::regex_search(module_name, core_lib_regex) ||
       std::regex_search(module_name, core_cmod_regex))
        return _report("Excluding", "core module", 3);

    // modules used by omnitrace and dependent libraries
    if(std::regex_search(module_name, dependlib_regex))
        return _report("Excluding", "dependency module", 3);

    // known set of modules whose starting sequence of characters suggest it should not be
    // instrumented (wastes time)
    if(std::regex_search(module_name, prefix_regex))
        return _report("Excluding", "prefix match", 3);

    return false;
}

bool
module_function::is_routine_constrained() const
{
    auto regex_opts = std::regex_constants::egrep | std::regex_constants::optimize;
    auto _report    = [&](const string_t& _action, const string_t& _reason, int _lvl) {
        messages.emplace_back(_lvl, _action, "function", _reason, function_name);
        return true;
    };

    auto npos = std::string::npos;
    if(function_name.find("omnitrace") != npos)
    {
        return _report("Skipping", "omnitrace-function", 1);
    }

    if(function_name.find("FunctionInfo") != npos ||
       function_name.find("_L_lock") != npos || function_name.find("_L_unlock") != npos)
    {
        return _report("Skipping", "function-constraint", 2);
    }

    static std::regex exclude(
        "(omnitrace|tim::|MPI_Init|MPI_Finalize|dyninst|DYNINST|tm_clones)", regex_opts);
    static std::regex exclude_printf("(|v|f)printf$", regex_opts);
    static std::regex exclude_cxx(
        "(std::_Sp_counted_base|std::(use|has)_facet|std::locale|::sentry|^std::_|::_(M|"
        "S)_|::basic_string[a-zA-Z,<>: ]+::_M_create|::__|::_(Alloc|State)|"
        "std::(basic_|)(ifstream|ios|istream|ostream|stream))",
        regex_opts);
    static std::regex leading(
        "^(_|\\.|frame_dummy|transaction clone|virtual thunk|non-virtual thunk|"
        "\\(|targ|kmp_threadprivate_|Kokkos::Profiling::|dlopen|dlsym)",
        regex_opts);
    static std::regex trailing(
        "(_|\\.part\\.[0-9]+|\\.constprop\\.[0-9]+|\\.|\\.[0-9]+)$", regex_opts);
    static strset_t whole = []() {
        auto _v   = get_whole_function_names();
        auto _ret = _v;
        for(std::string _ext : { "64", "_l", "_r" })
            for(const auto& itr : _v)
                _ret.emplace(itr + _ext);
        return _ret;
    }();

    // don't instrument the functions when key is found anywhere in function name
    if(std::regex_search(function_name, exclude) ||
       std::regex_search(function_name, exclude_cxx))
    {
        return _report("Excluding", "critical", 3);
    }

    if(std::regex_search(function_name, exclude_printf))
    {
        return _report("Excluding", "critical-printf", 3);
    }

    if(whole.count(function_name) > 0)
    {
        return _report("Excluding", "critical-whole-match", 3);
    }

    // don't instrument the functions when key is found at the start of the function name
    if(std::regex_search(function_name, leading))
    {
        return _report("Excluding", "recommended-leading-match", 3);
    }

    // don't instrument the functions when key is found at the end of the function name
    if(std::regex_search(function_name, trailing))
    {
        return _report("Excluding", "recommended-trailing-match", 3);
    }

    return false;
}

bool
module_function::is_overlapping_constrained() const
{
    if(!allow_overlapping && is_overlapping())
    {
        messages.emplace_back(2, "Skipping", "function", "overlapping", function_name);
        return true;
    }

    return false;
}

bool
module_function::contains_dynamic_callsites() const
{
    if(flow_graph) return flow_graph->containsDynamicCallsites();

    return false;
}

bool
module_function::is_dynamic_callsite_forced() const
{
    if(instr_dynamic_callsites && contains_dynamic_callsites())
    {
        messages.emplace_back(2, "Forcing", "function", "dynamic-callsites",
                              function_name);
        return true;
    }

    return false;
}

bool
module_function::is_address_range_constrained() const
{
    if(!loop_blocks.empty()) return is_loop_address_range_constrained();

    if(address_range < min_address_range)
    {
        messages.emplace_back(2, "Skipping", "function", "min-address-range",
                              function_name);
        return true;
    }
    return false;
}

bool
module_function::is_loop_address_range_constrained() const
{
    if(loop_blocks.empty()) return false;

    if(address_range < min_loop_address_range)
    {
        messages.emplace_back(2, "Skipping", "function", "min-address-range-loop",
                              function_name);
        return true;
    }

    return false;
}

bool
module_function::is_num_instructions_constrained() const
{
    if(!loop_blocks.empty()) return is_loop_num_instructions_constrained();

    if(num_instructions < min_instructions)
    {
        messages.emplace_back(2, "Skipping", "function", "min-instructions",
                              function_name);
        return true;
    }

    return false;
}

bool
module_function::is_loop_num_instructions_constrained() const
{
    if(loop_blocks.empty()) return false;

    if(num_instructions < min_loop_instructions)
    {
        messages.emplace_back(2, "Skipping", "function", "min-instructions-loop",
                              function_name);
        return true;
    }

    return false;
}

bool
module_function::can_instrument_entry() const
{
    size_t _num_points = 0;
    size_t _num_traps  = 0;

    std::tie(_num_points, _num_traps) = query_instr(function, BPatch_entry);

    if(_num_points == 0)
    {
        messages.emplace_back(3, "Skipping", "function", "no-instrumentable-entry-point",
                              function_name);
        return false;
    }

    return true;
}

bool
module_function::can_instrument_exit() const
{
    size_t _num_points = 0;
    size_t _num_traps  = 0;

    std::tie(_num_points, _num_traps) = query_instr(function, BPatch_exit);

    if(_num_points == 0)
    {
        messages.emplace_back(3, "Skipping", "function", "no-instrumentable-exit-point",
                              function_name);
        return false;
    }

    return true;
}

bool
module_function::is_entry_trap_constrained() const
{
    if(instr_traps) return false;

    size_t _num_points = 0;
    size_t _num_traps  = 0;

    std::tie(_num_points, _num_traps) = query_instr(function, BPatch_entry);

    if(!instr_traps && (_num_points - _num_traps) == 0)
    {
        messages.emplace_back(3, "Skipping", "function",
                              "entry-point-trap-instrumentation", function_name);
        return true;
    }

    return false;
}

bool
module_function::is_exit_trap_constrained() const
{
    if(instr_traps) return false;

    size_t _num_points = 0;
    size_t _num_traps  = 0;

    std::tie(_num_points, _num_traps) = query_instr(function, BPatch_exit);

    if((_num_points - _num_traps) == 0)
    {
        messages.emplace_back(3, "Skipping", "function",
                              "exit-point-trap-instrumentation", function_name);
        return true;
    }

    return false;
}

std::pair<size_t, size_t>
module_function::operator()(address_space_t* _addr_space, procedure_t* _entr_trace,
                            procedure_t* _exit_trace) const
{
    std::pair<size_t, size_t> _count = { 0, 0 };

    auto _name       = signature.get();
    auto _trace_entr = omnitrace_call_expr(_name.c_str());
    auto _trace_exit = omnitrace_call_expr(_name.c_str());
    auto _entr       = _trace_entr.get(_entr_trace);
    auto _exit       = _trace_exit.get(_exit_trace);

    if(insert_instr(_addr_space, function, _entr, BPatch_entry) &&
       insert_instr(_addr_space, function, _exit, BPatch_exit))
    {
        messages.emplace_back(1, "Instrumenting", "function", "no-constraint",
                              function_name);
        ++_count.first;
    }

    for(size_t i = 0; i < loop_blocks.size(); ++i)
    {
        if(!loop_level_instr) continue;

        auto* itr             = loop_blocks.at(i);
        auto  _is_constrained = [this](bool _v, const std::string& _label,
                                      const std::string& _mname) {
            if(_v)
            {
                messages.emplace_back(3, "Skipping", "function-loop", _label, _mname);
                return true;
            }
            return false;
        };

        auto lname =
            get_loop_file_line_info(module, function, flow_graph, itr).set_loop_number(i);
        auto _lname = lname.get();

        size_t _points             = 0;
        size_t _ntraps             = 0;
        std::tie(_points, _ntraps) = query_instr(function, BPatch_entry, flow_graph, itr);

        if(_is_constrained(_points == 0, "no-instrumentable-loop-entry-point", _lname))
            continue;
        if(_is_constrained(!instr_loop_traps && _points == _ntraps,
                           "loop-entry-point-trap-instrumentation", _lname))
            continue;

        std::tie(_points, _ntraps) = query_instr(function, BPatch_exit, flow_graph, itr);

        if(_is_constrained(_points == 0, "no-instrumentable-loop-exit-point", _lname))
            continue;
        if(_is_constrained(!instr_loop_traps && _points == _ntraps,
                           "loop-exit-point-trap-instrumentation", _lname))
            continue;

        auto _ltrace_entr = omnitrace_call_expr(_lname.c_str());
        auto _ltrace_exit = omnitrace_call_expr(_lname.c_str());
        auto _lentr       = _ltrace_entr.get(_entr_trace);
        auto _lexit       = _ltrace_exit.get(_exit_trace);

        if(insert_instr(_addr_space, function, _lentr, BPatch_entry, flow_graph, itr,
                        instr_loop_traps) &&
           insert_instr(_addr_space, function, _lexit, BPatch_exit, flow_graph, itr,
                        instr_loop_traps))
        {
            messages.emplace_back(1, "Loop Instrumenting", "function", "no-constraint",
                                  _lname);
            ++_count.second;
        }
    }

    return _count;
}

void
module_function::register_source(address_space_t* _addr_space, procedure_t* _entr_trace,
                                 const std::vector<point_t*>& _entr_points) const
{
    switch(coverage_mode)
    {
        case CODECOV_FUNCTION:
        {
            auto _name = signature.get_coverage(false);
            auto _trace_entr =
                omnitrace_call_expr(signature.m_file, signature.m_name,
                                    signature.m_row.first, start_address, _name);
            auto _entr = _trace_entr.get(_entr_trace);

            if(insert_instr(_addr_space, _entr_points, _entr, BPatch_entry))
            {
                messages.emplace_back(1, "Code Coverage", "function", "no-constraint",
                                      _name);
            }
            break;
        }
        case CODECOV_BASIC_BLOCK:
        {
            for(auto&& itr : get_basic_block_file_line_info(module, function))
            {
                auto  _start_addr = itr.second.start_address;
                auto& _signature  = itr.second.signature;
                auto  _name       = _signature.get_coverage(true);
                auto  _trace_entr =
                    omnitrace_call_expr(_signature.m_file, _signature.m_name,
                                        _signature.m_row.first, _start_addr, _name);
                auto _entr = _trace_entr.get(_entr_trace);

                if(insert_instr(_addr_space, _entr_points, _entr, BPatch_entry))
                {
                    messages.emplace_back(1, "Code Coverage", "basic_block",
                                          "no-constraint", _name);
                }
            }
            break;
        }
        case CODECOV_NONE: break;
    }
}

std::pair<size_t, size_t>
module_function::register_coverage(address_space_t* _addr_space,
                                   procedure_t*     _entr_trace) const
{
    std::pair<size_t, size_t> _count = { 0, 0 };
    switch(coverage_mode)
    {
        case CODECOV_FUNCTION:
        {
            auto _trace_entr =
                omnitrace_call_expr(signature.m_file, signature.m_name, start_address);
            auto _entr = _trace_entr.get(_entr_trace);

            if(insert_instr(_addr_space, function, _entr, BPatch_entry))
            {
                messages.emplace_back(1, "Code Coverage", "function", "no-constraint",
                                      signature.get_coverage(false));
                ++_count.first;
            }
            break;
        }
        case CODECOV_BASIC_BLOCK:
        {
            for(auto&& itr : get_basic_block_file_line_info(module, function))
            {
                auto  _start_addr = itr.second.start_address;
                auto& _signature  = itr.second.signature;
                auto  _trace_entr = omnitrace_call_expr(_signature.m_file,
                                                       _signature.m_name, _start_addr);
                auto  _entr       = _trace_entr.get(_entr_trace);

                if(insert_instr(_addr_space, _entr, BPatch_entry, itr.first))
                {
                    ++_count.second;
                    messages.emplace_back(1, "Code Coverage", "basic_block",
                                          "no-constraint", _signature.get_coverage(true));
                }
            }
            break;
        }
        case CODECOV_NONE: break;
    }
    return _count;
}