Function parseCovMapFilenames

src/Common/LLVMCoverageMapping.cpp:85–192

Parse all filename tables from the `__llvm_covmap` section. Each block starts with a 16-byte header followed by FilenamesSize bytes of compressed (or uncompressed) filename data. Header layout (all uint32_t, little-endian): NRecords (always 0 for LLVM coverage format V4+) FilenamesSize CoverageSize (always 0 for V4+) Version (3 = V4, 4 = V5, 5 = V6, …) The filename blob format (ULEB128

/// Uncompressed content for V5+ (i.e. format version 4+):
///   For each filename: ULEB128 length followed by that many bytes
std::vector<FilenameTable> parseCovMapFilenames(
    const uint8_t * covmap_data,
    size_t covmap_size)
{
    std::vector<FilenameTable> tables;

    const uint8_t * p = covmap_data;
    const uint8_t * const section_end = covmap_data + covmap_size;

    while (p < section_end)
    {
        /// Align start of each block to 8 bytes within the section.
        {
            const uintptr_t off = static_cast<uintptr_t>(p - covmap_data);
            if (off % 8 != 0)
                p += 8 - (off % 8);
        }
        if (p + 16 > section_end)
            break;

        uint32_t n_records;
        uint32_t filenames_size;
        uint32_t coverage_size;
        uint32_t version;
        memcpy(&n_records, p, 4);
        memcpy(&filenames_size, p + 4, 4);
        memcpy(&coverage_size, p + 8, 4);
        memcpy(&version, p + 12, 4);

        p += 16;

        if (p + filenames_size > section_end)
            break;

        const uint8_t * const fnames_start = p;
        const uint8_t * const fnames_end   = p + filenames_size;
        p = fnames_end;

        /// Compute MD5Hash of the raw filename blob — this is exactly what LLVM stores as FilenamesRef.
        const uint64_t block_hash = computeMD5Hash(fnames_start, filenames_size);

        /// Decode the filename blob.
        const uint8_t * fp = fnames_start;
        bool ok = true;

        const uint64_t num_filenames    = readULEB128(fp, fnames_end, ok);
        const uint64_t uncompressed_len = readULEB128(fp, fnames_end, ok);
        const uint64_t compressed_len   = readULEB128(fp, fnames_end, ok);
        if (!ok || num_filenames == 0)
            continue;

        /// Sanity-check the uncompressed size before allocating to avoid OOM on corrupt data.
        /// 256 MB is a generous upper bound; also require it is not implausibly large
        /// relative to the compressed/raw input (a 16× expansion factor is already very liberal).
        static constexpr uint64_t kMaxUncompressedLen = 256u * 1024u * 1024u;
        if (uncompressed_len > kMaxUncompressedLen
            || uncompressed_len > static_cast<uint64_t>(filenames_size) * 16)
            continue;