tools/debug/covargs/report.go - fuchsia - Git at Google

 // Copyright 2020 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 package covargs

 import (
 	"bytes"
 	"compress/zlib"
 	"fmt"
 	"math"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"runtime"
 	"sort"
 	"strconv"
 	"strings"
 	"sync"

 	"github.com/golang/protobuf/jsonpb"
 	"go.fuchsia.dev/fuchsia/tools/debug/covargs/api/llvm"
 	"go.fuchsia.dev/fuchsia/tools/debug/covargs/api/third_party/codecoverage"
 	"golang.org/x/sync/errgroup"
 )

 // DiffMapping represents a source transformation done by a diff (i.e. patch),
 // where for each file it has a mapping from the old line number to the new one.
 type DiffMapping map[string]LineMapping

 // LineMapping maps the old line number to the new one within a single file.
 type LineMapping map[int]int

 type line struct {
 	line, count int
 }
 type lineData []line
 type block struct {
 	first, last int
 }
 type blockData map[int][]block

 func extractData(segments []llvm.Segment) (lineData, blockData) {
 	var ld lineData
 	bd := blockData{}

 	// The most recent segment that starts from a previous line.
 	var w *llvm.Segment

 	var lineSegments []llvm.Segment
 	nextSegmentIndex := 0

 	for i := 1; i <= segments[len(segments)-1].LineNumber; i += 1 {
 		// Calculate the execution count for each line. Follow the logic in llvm-cov:
 		// https://github.com/llvm-mirror/llvm/blob/3b35e17b21e388832d7b560a06a4f9eeaeb35330/lib/ProfileData/Coverage/CoverageMapping.cpp#L686
 		if len(lineSegments) > 0 {
 			w = &lineSegments[len(lineSegments)-1]
 		}

 		lineSegments = nil
 		for nextSegmentIndex < len(segments) && segments[nextSegmentIndex].LineNumber == i {
 			lineSegments = append(lineSegments, segments[nextSegmentIndex])
 			nextSegmentIndex += 1
 		}

 		lineStartsNewRegion := false
 		for _, s := range lineSegments {
 			if s.HasCount && s.IsRegionEntry {
 				lineStartsNewRegion = true
 				break
 			}
 		}
 		startOfSkippedRegion := (len(lineSegments) > 0 && !lineSegments[0].HasCount) && lineSegments[0].IsRegionEntry
 		coverable := !startOfSkippedRegion && ((w != nil && w.HasCount) || lineStartsNewRegion)
 		if !coverable {
 			continue
 		}

 		count := 0
 		if w != nil {
 			count = w.Count
 		}

 		for _, s := range lineSegments {
 			if s.HasCount && s.IsRegionEntry {
 				if s.Count > count {
 					count = s.Count
 				}
 			}
 		}

 		ld = append(ld, line{i, count})

 		// Calculate the uncovered blocks within the current line. Follow the logic in llvm-cov:
 		// https://github.com/llvm-mirror/llvm/blob/993ef0ca960f8ffd107c33bfbf1fd603bcf5c66c/tools/llvm-cov/SourceCoverageViewText.cpp#L114
 		if count == 0 {
 			// Skips calculating uncovered blocks if the whole line is not covered.
 			continue
 		}

 		columnStart := 1
 		isBlockNotCovered := (w != nil && w.HasCount) && w.Count == 0
 		for _, s := range lineSegments {
 			columnEnd := s.ColumnNumber
 			if isBlockNotCovered {
 				bd[s.LineNumber] = append(bd[s.LineNumber], block{columnStart, columnEnd - 1})
 			}
 			isBlockNotCovered = s.HasCount && s.Count == 0
 			columnStart = columnEnd
 		}
 		if isBlockNotCovered {
 			lastSegment := lineSegments[len(lineSegments)-1]
 			bd[lastSegment.LineNumber] = append(bd[lastSegment.LineNumber], block{columnStart, -1})
 		}
 	}

 	return ld, bd
 }

 func rebaseData(lines lineData, blocks blockData, mapping LineMapping) (lineData, blockData) {
 	var ld lineData
 	for _, l := range lines {
 		if _, ok := mapping[l.line]; !ok {
 			continue
 		}
 		ld = append(ld, line{mapping[l.line], l.count})
 	}

 	var bd blockData
 	for i, b := range blocks {
 		if _, ok := mapping[i]; !ok {
 			continue
 		}
 		bd[mapping[i]] = b
 	}

 	return ld, bd
 }

 func compressData(lines lineData, blocks blockData) ([]*codecoverage.LineRange, []*codecoverage.ColumnRanges) {
 	// Aggregate contiguous blocks of lines with the exact same hit count.
 	var lr []*codecoverage.LineRange
 	last := 0
 	for i := 1; i <= len(lines); i++ {
 		isContinuous := i < len(lines) && lines[i].line == lines[i-1].line+1
 		hasSameCount := i < len(lines) && lines[i].count == lines[i-1].count
 		// Merge two lines iff they have continuous line number and exactly the same count, e.g. (101, 10) and (102, 10).
 		if isContinuous && hasSameCount {
 			continue
 		}
 		lr = append(lr, &codecoverage.LineRange{
 			First: int32(lines[last].line),
 			Last:  int32(lines[i-1].line),
 			Count: int64(lines[last].count),
 		})
 		last = i
 	}

 	var cr []*codecoverage.ColumnRanges
 	for i, block := range blocks {
 		var ranges []*codecoverage.ColumnRange
 		for _, b := range block {
 			ranges = append(ranges, &codecoverage.ColumnRange{
 				First: int32(b.first),
 				Last:  int32(b.last),
 			})
 		}
 		cr = append(cr, &codecoverage.ColumnRanges{
 			Line:   int32(i),
 			Ranges: ranges,
 		})
 	}

 	return lr, cr
 }

 func getRevision(path string) (string, int64, error) {
 	if _, err := os.Stat(path); os.IsNotExist(err) {
 		return "", 0, nil
 	}
 	var stdout bytes.Buffer
 	cmd := exec.Command("git", "--literal-pathspecs", "log", "-n", "1", `--pretty=format:%H:%ct`, path)
 	cmd.Dir = filepath.Dir(path)
 	cmd.Stdout = &stdout
 	if err := cmd.Run(); err != nil {
 		return "", 0, fmt.Errorf("failed to obtain revision: %w", err)
 	}
 	out := strings.TrimSpace(stdout.String())
 	if out == "" {
 		return "", 0, nil
 	}
 	parts := strings.Split(out, ":")
 	if len(parts) != 2 {
 		return "", 0, fmt.Errorf("not in hash:timestamp format: %s", out)
 	}
 	hash := parts[0]
 	timestamp, err := strconv.ParseInt(parts[1], 10, 64)
 	if err != nil {
 		return "", 0, fmt.Errorf("invalid timestamp %q: %w", parts[1], err)
 	}
 	return hash, timestamp, nil
 }

 func convertFile(file llvm.File, base string, mapping *DiffMapping) (*codecoverage.File, error) {
 	if file.Segments == nil {
 		return nil, nil
 	}

 	rel, err := filepath.Rel(base, file.Filename)
 	if err != nil {
 		return nil, err
 	}

 	ld, bd := extractData(file.Segments)
 	sort.Slice(ld, func(i, j int) bool {
 		return ld[i].line < ld[j].line
 	})

 	var revision string
 	var timestamp int64
 	if mapping != nil {
 		if _, ok := (*mapping)[rel]; ok {
 			ld, bd = rebaseData(ld, bd, (*mapping)[rel])
 		}
 	} else {
 		revision, timestamp, err = getRevision(file.Filename)
 		if err != nil {
 			return nil, err
 		}
 	}

 	lr, cr := compressData(ld, bd)

 	return &codecoverage.File{
 		Path:            "//" + rel,
 		Lines:           lr,
 		UncoveredBlocks: cr,
 		Summaries: []*codecoverage.Metric{
 			{
 				Name:    "function",
 				Covered: int32(file.Summary.Functions.Covered),
 				Total:   int32(file.Summary.Functions.Count),
 			},
 			{
 				Name:    "region",
 				Covered: int32(file.Summary.Regions.Covered),
 				Total:   int32(file.Summary.Regions.Count),
 			},
 			{
 				Name:    "line",
 				Covered: int32(file.Summary.Lines.Covered),
 				Total:   int32(file.Summary.Lines.Count),
 			},
 		},
 		Revision:  revision,
 		Timestamp: timestamp,
 	}, nil
 }

 func mergeSummaries(summaries ...[]*codecoverage.Metric) []*codecoverage.Metric {
 	s := []*codecoverage.Metric{
 		{
 			Name:    "function",
 			Covered: 0,
 			Total:   0,
 		},
 		{
 			Name:    "region",
 			Covered: 0,
 			Total:   0,
 		},
 		{
 			Name:    "line",
 			Covered: 0,
 			Total:   0,
 		},
 	}
 	d := map[string]int{}
 	for i, m := range s {
 		d[m.Name] = i
 	}
 	for _, m := range summaries {
 		if m != nil {
 			for _, n := range m {
 				s[d[n.Name]].Covered += n.Covered
 				s[d[n.Name]].Total += n.Total
 			}
 		}
 	}
 	return s
 }

 // ComputeSummaries calculates aggregate summaries for all directories.
 func ComputeSummaries(files []*codecoverage.File) ([]*codecoverage.GroupCoverageSummary, []*codecoverage.Metric) {
 	summaries := map[string][]*codecoverage.Metric{}
 	for _, f := range files {
 		// We can't use filepath.Dir and filepath.Base because they normalize '//'.
 		dir, _ := filepath.Split(f.Path)
 		for dir != "//" {
 			// In the coverage data format, dirs end with '/' except for root.
 			summaries[dir] = mergeSummaries(summaries[dir], f.Summaries)
 			dir, _ = filepath.Split(dir[:len(dir)-1])
 		}
 		summaries["//"] = mergeSummaries(summaries["//"], f.Summaries)
 	}

 	fileSummaries := map[string][]*codecoverage.CoverageSummary{}
 	for _, f := range files {
 		dir, file := filepath.Split(f.Path)
 		fileSummaries[dir] = append(fileSummaries[dir], &codecoverage.CoverageSummary{
 			Name:      file,
 			Path:      f.Path,
 			Summaries: f.Summaries,
 		})
 	}

 	dirSummaries := map[string][]*codecoverage.CoverageSummary{}
 	for p, s := range summaries {
 		if p == "//" {
 			continue
 		}
 		// The path already ends with '/' so we have to omit it.
 		dir, file := filepath.Split(p[:len(p)-1])
 		dirSummaries[dir] = append(dirSummaries[dir], &codecoverage.CoverageSummary{
 			Name:      file + "/",
 			Path:      p,
 			Summaries: s,
 		})
 	}

 	var groupSummaries []*codecoverage.GroupCoverageSummary
 	for p, s := range summaries {
 		groupSummaries = append(groupSummaries, &codecoverage.GroupCoverageSummary{
 			Path:      p,
 			Dirs:      dirSummaries[p],
 			Files:     fileSummaries[p],
 			Summaries: s,
 		})
 	}
 	sort.Slice(groupSummaries, func(i, j int) bool {
 		return groupSummaries[i].Path < groupSummaries[j].Path
 	})

 	return groupSummaries, summaries["//"]
 }

 // ConvertFiles converts the data in LLVM coverage JSON format into the
 // compressed coverage format used by Chromium coverage service.
 func ConvertFiles(export *llvm.Export, base string, mapping *DiffMapping) ([]*codecoverage.File, error) {
 	var files []*codecoverage.File
 	var g errgroup.Group
 	var mu sync.Mutex
 	s := make(chan struct{}, runtime.NumCPU())
 	for _, d := range export.Data {
 		for _, f := range d.Files {
 			f := f
 			s <- struct{}{}
 			g.Go(func() error {
 				defer func() { <-s }()
 				file, err := convertFile(f, base, mapping)
 				if err != nil {
 					return err
 				}
 				mu.Lock()
 				files = append(files, file)
 				mu.Unlock()
 				return nil
 			})
 		}
 	}
 	if err := g.Wait(); err != nil {
 		return nil, err
 	}
 	return files, nil
 }

 func saveReport(report *codecoverage.CoverageReport, filename string) error {
 	f, err := os.Create(filename)
 	if err != nil {
 		return fmt.Errorf("cannot open file %q: %v", filename, err)
 	}
 	defer f.Close()
 	w := zlib.NewWriter(f)
 	defer w.Close()
 	m := &jsonpb.Marshaler{
 		OrigName:     true,
 		EmitDefaults: true,
 	}
 	if err := m.Marshal(w, report); err != nil {
 		return fmt.Errorf("cannot marshal report: %w", err)
 	}
 	return nil
 }

 // SaveReport saves compresses coverage data to disk, optionally sharding the
 // data into multiple files each of the same size.
 func SaveReport(files []*codecoverage.File, shardSize int, dir string) (*codecoverage.CoverageReport, error) {
 	dirs, summaries := ComputeSummaries(files)
 	report := &codecoverage.CoverageReport{
 		Dirs:      dirs,
 		Summaries: summaries,
 	}
 	if numFiles := len(files); numFiles > shardSize {
 		const filename = "files%0*d.json.gz"
 		numShards := int(math.Ceil(float64(numFiles) / float64(shardSize)))
 		width := 1 + int(math.Log10(float64(numShards)))
 		fileShards := make([]string, numShards)
 		// TODO(phosek): Use goroutines to process slices in parallel.
 		for i := 0; i < numShards; i++ {
 			from := i * shardSize
 			to := (i + 1) * shardSize
 			if to > numFiles {
 				to = numFiles
 			}
 			report := codecoverage.CoverageReport{Files: files[from:to]}
 			filename := fmt.Sprintf(filename, width, i+1)
 			if err := saveReport(&report, filepath.Join(dir, filename)); err != nil {
 				return nil, fmt.Errorf("failed to save report %q: %w", filename, err)
 			}
 			fileShards[i] = filename
 		}
 		report.FileShards = fileShards
 	} else {
 		report.Files = files
 	}
 	const filename = "all.json.gz"
 	if err := saveReport(report, filepath.Join(dir, filename)); err != nil {
 		return nil, fmt.Errorf("failed to save report %q: %w", filename, err)
 	}
 	return report, nil
 }
	// Copyright 2020 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	package covargs

	import (
	"bytes"
	"compress/zlib"
	"fmt"
	"math"
	"os"
	"os/exec"
	"path/filepath"
	"runtime"
	"sort"
	"strconv"
	"strings"
	"sync"

	"github.com/golang/protobuf/jsonpb"
	"go.fuchsia.dev/fuchsia/tools/debug/covargs/api/llvm"
	"go.fuchsia.dev/fuchsia/tools/debug/covargs/api/third_party/codecoverage"
	"golang.org/x/sync/errgroup"
	)

	// DiffMapping represents a source transformation done by a diff (i.e. patch),
	// where for each file it has a mapping from the old line number to the new one.
	type DiffMapping map[string]LineMapping

	// LineMapping maps the old line number to the new one within a single file.
	type LineMapping map[int]int

	type line struct {
	line, count int
	}
	type lineData []line
	type block struct {
	first, last int
	}
	type blockData map[int][]block

	func extractData(segments []llvm.Segment) (lineData, blockData) {
	var ld lineData
	bd := blockData{}

	// The most recent segment that starts from a previous line.
	var w *llvm.Segment

	var lineSegments []llvm.Segment
	nextSegmentIndex := 0

	for i := 1; i <= segments[len(segments)-1].LineNumber; i += 1 {
	// Calculate the execution count for each line. Follow the logic in llvm-cov:
	// https://github.com/llvm-mirror/llvm/blob/3b35e17b21e388832d7b560a06a4f9eeaeb35330/lib/ProfileData/Coverage/CoverageMapping.cpp#L686
	if len(lineSegments) > 0 {
	w = &lineSegments[len(lineSegments)-1]
	}

	lineSegments = nil
	for nextSegmentIndex < len(segments) && segments[nextSegmentIndex].LineNumber == i {
	lineSegments = append(lineSegments, segments[nextSegmentIndex])
	nextSegmentIndex += 1
	}

	lineStartsNewRegion := false
	for _, s := range lineSegments {
	if s.HasCount && s.IsRegionEntry {
	lineStartsNewRegion = true
	break
	}
	}
	startOfSkippedRegion := (len(lineSegments) > 0 && !lineSegments[0].HasCount) && lineSegments[0].IsRegionEntry
	coverable := !startOfSkippedRegion && ((w != nil && w.HasCount) \|\| lineStartsNewRegion)
	if !coverable {
	continue
	}

	count := 0
	if w != nil {
	count = w.Count
	}

	for _, s := range lineSegments {
	if s.HasCount && s.IsRegionEntry {
	if s.Count > count {
	count = s.Count
	}
	}
	}

	ld = append(ld, line{i, count})

	// Calculate the uncovered blocks within the current line. Follow the logic in llvm-cov:
	// https://github.com/llvm-mirror/llvm/blob/993ef0ca960f8ffd107c33bfbf1fd603bcf5c66c/tools/llvm-cov/SourceCoverageViewText.cpp#L114
	if count == 0 {
	// Skips calculating uncovered blocks if the whole line is not covered.
	continue
	}

	columnStart := 1
	isBlockNotCovered := (w != nil && w.HasCount) && w.Count == 0
	for _, s := range lineSegments {
	columnEnd := s.ColumnNumber
	if isBlockNotCovered {
	bd[s.LineNumber] = append(bd[s.LineNumber], block{columnStart, columnEnd - 1})
	}
	isBlockNotCovered = s.HasCount && s.Count == 0
	columnStart = columnEnd
	}
	if isBlockNotCovered {
	lastSegment := lineSegments[len(lineSegments)-1]
	bd[lastSegment.LineNumber] = append(bd[lastSegment.LineNumber], block{columnStart, -1})
	}
	}

	return ld, bd
	}

	func rebaseData(lines lineData, blocks blockData, mapping LineMapping) (lineData, blockData) {
	var ld lineData
	for _, l := range lines {
	if _, ok := mapping[l.line]; !ok {
	continue
	}
	ld = append(ld, line{mapping[l.line], l.count})
	}

	var bd blockData
	for i, b := range blocks {
	if _, ok := mapping[i]; !ok {
	continue
	}
	bd[mapping[i]] = b
	}

	return ld, bd
	}

	func compressData(lines lineData, blocks blockData) ([]codecoverage.LineRange, []codecoverage.ColumnRanges) {
	// Aggregate contiguous blocks of lines with the exact same hit count.
	var lr []*codecoverage.LineRange
	last := 0
	for i := 1; i <= len(lines); i++ {
	isContinuous := i < len(lines) && lines[i].line == lines[i-1].line+1
	hasSameCount := i < len(lines) && lines[i].count == lines[i-1].count
	// Merge two lines iff they have continuous line number and exactly the same count, e.g. (101, 10) and (102, 10).
	if isContinuous && hasSameCount {
	continue
	}
	lr = append(lr, &codecoverage.LineRange{
	First: int32(lines[last].line),
	Last: int32(lines[i-1].line),
	Count: int64(lines[last].count),
	})
	last = i
	}

	var cr []*codecoverage.ColumnRanges
	for i, block := range blocks {
	var ranges []*codecoverage.ColumnRange
	for _, b := range block {
	ranges = append(ranges, &codecoverage.ColumnRange{
	First: int32(b.first),
	Last: int32(b.last),
	})
	}
	cr = append(cr, &codecoverage.ColumnRanges{
	Line: int32(i),
	Ranges: ranges,
	})
	}

	return lr, cr
	}

	func getRevision(path string) (string, int64, error) {
	if _, err := os.Stat(path); os.IsNotExist(err) {
	return "", 0, nil
	}
	var stdout bytes.Buffer
	cmd := exec.Command("git", "--literal-pathspecs", "log", "-n", "1", `--pretty=format:%H:%ct`, path)
	cmd.Dir = filepath.Dir(path)
	cmd.Stdout = &stdout
	if err := cmd.Run(); err != nil {
	return "", 0, fmt.Errorf("failed to obtain revision: %w", err)
	}
	out := strings.TrimSpace(stdout.String())
	if out == "" {
	return "", 0, nil
	}
	parts := strings.Split(out, ":")
	if len(parts) != 2 {
	return "", 0, fmt.Errorf("not in hash:timestamp format: %s", out)
	}
	hash := parts[0]
	timestamp, err := strconv.ParseInt(parts[1], 10, 64)
	if err != nil {
	return "", 0, fmt.Errorf("invalid timestamp %q: %w", parts[1], err)
	}
	return hash, timestamp, nil
	}

	func convertFile(file llvm.File, base string, mapping DiffMapping) (codecoverage.File, error) {
	if file.Segments == nil {
	return nil, nil
	}

	rel, err := filepath.Rel(base, file.Filename)
	if err != nil {
	return nil, err
	}

	ld, bd := extractData(file.Segments)
	sort.Slice(ld, func(i, j int) bool {
	return ld[i].line < ld[j].line
	})

	var revision string
	var timestamp int64
	if mapping != nil {
	if _, ok := (*mapping)[rel]; ok {
	ld, bd = rebaseData(ld, bd, (*mapping)[rel])
	}
	} else {
	revision, timestamp, err = getRevision(file.Filename)
	if err != nil {
	return nil, err
	}
	}

	lr, cr := compressData(ld, bd)

	return &codecoverage.File{
	Path: "//" + rel,
	Lines: lr,
	UncoveredBlocks: cr,
	Summaries: []*codecoverage.Metric{
	{
	Name: "function",
	Covered: int32(file.Summary.Functions.Covered),
	Total: int32(file.Summary.Functions.Count),
	},
	{
	Name: "region",
	Covered: int32(file.Summary.Regions.Covered),
	Total: int32(file.Summary.Regions.Count),
	},
	{
	Name: "line",
	Covered: int32(file.Summary.Lines.Covered),
	Total: int32(file.Summary.Lines.Count),
	},
	},
	Revision: revision,
	Timestamp: timestamp,
	}, nil
	}

	func mergeSummaries(summaries ...[]codecoverage.Metric) []codecoverage.Metric {
	s := []*codecoverage.Metric{
	{
	Name: "function",
	Covered: 0,
	Total: 0,
	},
	{
	Name: "region",
	Covered: 0,
	Total: 0,
	},
	{
	Name: "line",
	Covered: 0,
	Total: 0,
	},
	}
	d := map[string]int{}
	for i, m := range s {
	d[m.Name] = i
	}
	for _, m := range summaries {
	if m != nil {
	for _, n := range m {
	s[d[n.Name]].Covered += n.Covered
	s[d[n.Name]].Total += n.Total
	}
	}
	}
	return s
	}

	// ComputeSummaries calculates aggregate summaries for all directories.
	func ComputeSummaries(files []codecoverage.File) ([]codecoverage.GroupCoverageSummary, []*codecoverage.Metric) {
	summaries := map[string][]*codecoverage.Metric{}
	for _, f := range files {
	// We can't use filepath.Dir and filepath.Base because they normalize '//'.
	dir, _ := filepath.Split(f.Path)
	for dir != "//" {
	// In the coverage data format, dirs end with '/' except for root.
	summaries[dir] = mergeSummaries(summaries[dir], f.Summaries)
	dir, _ = filepath.Split(dir[:len(dir)-1])
	}
	summaries["//"] = mergeSummaries(summaries["//"], f.Summaries)
	}

	fileSummaries := map[string][]*codecoverage.CoverageSummary{}
	for _, f := range files {
	dir, file := filepath.Split(f.Path)
	fileSummaries[dir] = append(fileSummaries[dir], &codecoverage.CoverageSummary{
	Name: file,
	Path: f.Path,
	Summaries: f.Summaries,
	})
	}

	dirSummaries := map[string][]*codecoverage.CoverageSummary{}
	for p, s := range summaries {
	if p == "//" {
	continue
	}
	// The path already ends with '/' so we have to omit it.
	dir, file := filepath.Split(p[:len(p)-1])
	dirSummaries[dir] = append(dirSummaries[dir], &codecoverage.CoverageSummary{
	Name: file + "/",
	Path: p,
	Summaries: s,
	})
	}

	var groupSummaries []*codecoverage.GroupCoverageSummary
	for p, s := range summaries {
	groupSummaries = append(groupSummaries, &codecoverage.GroupCoverageSummary{
	Path: p,
	Dirs: dirSummaries[p],
	Files: fileSummaries[p],
	Summaries: s,
	})
	}
	sort.Slice(groupSummaries, func(i, j int) bool {
	return groupSummaries[i].Path < groupSummaries[j].Path
	})

	return groupSummaries, summaries["//"]
	}

	// ConvertFiles converts the data in LLVM coverage JSON format into the
	// compressed coverage format used by Chromium coverage service.
	func ConvertFiles(export llvm.Export, base string, mapping DiffMapping) ([]*codecoverage.File, error) {
	var files []*codecoverage.File
	var g errgroup.Group
	var mu sync.Mutex
	s := make(chan struct{}, runtime.NumCPU())
	for _, d := range export.Data {
	for _, f := range d.Files {
	f := f
	s <- struct{}{}
	g.Go(func() error {
	defer func() { <-s }()
	file, err := convertFile(f, base, mapping)
	if err != nil {
	return err
	}
	mu.Lock()
	files = append(files, file)
	mu.Unlock()
	return nil
	})
	}
	}
	if err := g.Wait(); err != nil {
	return nil, err
	}
	return files, nil
	}

	func saveReport(report *codecoverage.CoverageReport, filename string) error {
	f, err := os.Create(filename)
	if err != nil {
	return fmt.Errorf("cannot open file %q: %v", filename, err)
	}
	defer f.Close()
	w := zlib.NewWriter(f)
	defer w.Close()
	m := &jsonpb.Marshaler{
	OrigName: true,
	EmitDefaults: true,
	}
	if err := m.Marshal(w, report); err != nil {
	return fmt.Errorf("cannot marshal report: %w", err)
	}
	return nil
	}

	// SaveReport saves compresses coverage data to disk, optionally sharding the
	// data into multiple files each of the same size.
	func SaveReport(files []codecoverage.File, shardSize int, dir string) (codecoverage.CoverageReport, error) {
	dirs, summaries := ComputeSummaries(files)
	report := &codecoverage.CoverageReport{
	Dirs: dirs,
	Summaries: summaries,
	}
	if numFiles := len(files); numFiles > shardSize {
	const filename = "files%0*d.json.gz"
	numShards := int(math.Ceil(float64(numFiles) / float64(shardSize)))
	width := 1 + int(math.Log10(float64(numShards)))
	fileShards := make([]string, numShards)
	// TODO(phosek): Use goroutines to process slices in parallel.
	for i := 0; i < numShards; i++ {
	from := i * shardSize
	to := (i + 1) * shardSize
	if to > numFiles {
	to = numFiles
	}
	report := codecoverage.CoverageReport{Files: files[from:to]}
	filename := fmt.Sprintf(filename, width, i+1)
	if err := saveReport(&report, filepath.Join(dir, filename)); err != nil {
	return nil, fmt.Errorf("failed to save report %q: %w", filename, err)
	}
	fileShards[i] = filename
	}
	report.FileShards = fileShards
	} else {
	report.Files = files
	}
	const filename = "all.json.gz"
	if err := saveReport(report, filepath.Join(dir, filename)); err != nil {
	return nil, fmt.Errorf("failed to save report %q: %w", filename, err)
	}
	return report, nil
	}