Function getCurrentCoveredNameRefs

base/base/coverage.cpp:225–289

std::vector<CovCounter> getCurrentCoveredNameRefs()
{
    const LLVMProfileData * begin = __llvm_profile_begin_data(); // NOLINT
    const LLVMProfileData * end   = __llvm_profile_end_data();   // NOLINT

    const uint64_t * const cnts_begin = __llvm_profile_begin_counters(); // NOLINT
    const uint64_t * const cnts_end   = __llvm_profile_end_counters();   // NOLINT

    const std::size_t total = static_cast<std::size_t>(end - begin);

    std::vector<CovCounter> result;
    /// Reserve assuming ~4 non-zero counters per function on average.
    result.reserve(std::min(total * 4, std::size_t{1 << 20}));

    const uint32_t n_profile = static_cast<uint32_t>(end - begin);

    for (uint32_t idx = 0; idx < n_profile; ++idx)
    {
        const LLVMProfileData * data = begin + idx;

        if (!data->NumCounters)
            continue;

        /// CounterPtr is a relative signed offset from the address of the data record.
        const uint64_t * const entry_counter = reinterpret_cast<const uint64_t *>(
            reinterpret_cast<const char *>(data) + reinterpret_cast<intptr_t>(data->CounterPtr));

        /// Validate the entire counter array fits within the counters section.
        if (entry_counter < cnts_begin || entry_counter + data->NumCounters > cnts_end)
            continue;

        /// Skip functions that were never entered — branch counters inside them
        /// would be false positives.
        if (*entry_counter == 0)
            continue;

        /// min_depth: prefer XRay call depth (exact, built via text_addr→profile mapping)
        /// over the call-count proxy.  XRay depth is populated only when the binary is
        /// built with -DCLICKHOUSE_XRAY_INSTRUMENT_COVERAGE=1 and XRay is activated.
        uint8_t min_depth;
#ifdef CLICKHOUSE_XRAY_INSTRUMENT_COVERAGE
        if (g_xray_min_depth && idx < g_xray_depth_size)
        {
            const uint32_t xray_d = g_xray_min_depth[idx].load(std::memory_order_relaxed);
            min_depth = (xray_d < 255u) ? static_cast<uint8_t>(xray_d) : 255u;
        }
        else
#endif
        {
            /// Fallback: raw entry-counter call count (lower = more specific).
            min_depth = static_cast<uint8_t>(std::min<uint64_t>(*entry_counter, 254u));
        }

        /// Emit one entry per non-zero counter.  Counter 0 is the function entry;
        /// counters 1…N are individual basic-block/branch counters that map to
        /// specific statement-level regions in the LLVM coverage mapping.
        for (uint32_t i = 0; i < data->NumCounters; ++i)
        {