Method buildForModule

src-test/common/coverage/CoverageCatalog.cpp:172–324

bool CoverageCatalog::isSampling() const { return mSampler && mSampler->isRunning(); }

bool CoverageCatalog::buildForModule(ModuleInfo mod) {
    auto symbolProvider   = ISymbolProvider::createDefault();
    auto exportEnumerator = IExportEnumerator::createDefault();
    if (!symbolProvider || !exportEnumerator) {
        return false;
    }

    DiscoveredModule discovered{
        .moduleName      = mod.moduleName,
        .modulePath      = mod.modulePath,
        .baseAddress     = mod.baseAddress,
        .imageSize       = mod.imageSize,
        .hasDebugSymbols = mod.hasPdb,
    };
    symbolProvider->prepareModule(discovered);
    mod.hasPdb = discovered.hasDebugSymbols;

    auto& moduleData = mModules.emplace_back();
    moduleData.info  = std::move(mod);

    auto& funcs   = moduleData.functions;
    auto& lines   = moduleData.lines;
    auto& addrs   = moduleData.instrumentedAddresses;
    auto& addrLns = moduleData.addressToLines;
    auto& addrFns = moduleData.addressToFunctions;
    auto& exports = moduleData.exportedAddresses;

    exports = exportEnumerator->collectExportedAddresses(discovered);

    auto functionRecords = symbolProvider->enumerateFunctions(discovered);
    auto hasLineInfo     = std::ranges::any_of(functionRecords, [](SymbolRecord const& record) {
        return record.hasLineInfo;
    });
    funcs.reserve(functionRecords.size());
    for (auto& record : functionRecords) {
        FunctionInfo info;
        info.name          = std::move(record.name);
        info.demangledName = std::move(record.demangledName);
        info.start         = record.start;
        info.end           = record.end;
        info.sourceFile    = normalizeSourcePath(record.sourceFile);
        info.startLine     = record.startLine;
        info.endLine       = record.endLine;
        info.hasLineInfo   = record.hasLineInfo;
        funcs.push_back(std::move(info));
    }

    std::unordered_map<LineKey, std::vector<uintptr_t>, LineKeyHash> lineAddresses;
    auto lineRecords = symbolProvider->enumerateLines(discovered);
    if (!lineRecords.empty()) {
        hasLineInfo = true;
    }
    if (hasLineInfo) {
        moduleData.info.hasPdb = true;
    }
    for (auto& record : lineRecords) {
        if (!isTargetSourceFile(record.file)) {
            continue;