File size: 3,512 Bytes
f7a7bb1 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 | // Copyright 2021 The Go 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 encodemeta
import (
"bufio"
"encoding/binary"
"fmt"
"hash/fnv"
"internal/coverage"
"internal/coverage/stringtab"
"io"
"os"
"unsafe"
)
// This package contains APIs and helpers for writing out a meta-data
// file (composed of a file header, offsets/lengths, and then a series of
// meta-data blobs emitted by the compiler, one per Go package).
type CoverageMetaFileWriter struct {
stab stringtab.Writer
mfname string
w *bufio.Writer
tmp []byte
debug bool
}
func NewCoverageMetaFileWriter(mfname string, w io.Writer) *CoverageMetaFileWriter {
r := &CoverageMetaFileWriter{
mfname: mfname,
w: bufio.NewWriter(w),
tmp: make([]byte, 64),
}
r.stab.InitWriter()
r.stab.Lookup("")
return r
}
func (m *CoverageMetaFileWriter) Write(finalHash [16]byte, blobs [][]byte, mode coverage.CounterMode, granularity coverage.CounterGranularity) error {
mhsz := uint64(unsafe.Sizeof(coverage.MetaFileHeader{}))
stSize := m.stab.Size()
stOffset := mhsz + uint64(16*len(blobs))
preambleLength := stOffset + uint64(stSize)
if m.debug {
fmt.Fprintf(os.Stderr, "=+= sizeof(MetaFileHeader)=%d\n", mhsz)
fmt.Fprintf(os.Stderr, "=+= preambleLength=%d stSize=%d\n", preambleLength, stSize)
}
// Compute total size
tlen := preambleLength
for i := 0; i < len(blobs); i++ {
tlen += uint64(len(blobs[i]))
}
// Emit header
mh := coverage.MetaFileHeader{
Magic: coverage.CovMetaMagic,
Version: coverage.MetaFileVersion,
TotalLength: tlen,
Entries: uint64(len(blobs)),
MetaFileHash: finalHash,
StrTabOffset: uint32(stOffset),
StrTabLength: stSize,
CMode: mode,
CGranularity: granularity,
}
var err error
if err = binary.Write(m.w, binary.LittleEndian, mh); err != nil {
return fmt.Errorf("error writing %s: %v", m.mfname, err)
}
if m.debug {
fmt.Fprintf(os.Stderr, "=+= len(blobs) is %d\n", mh.Entries)
}
// Emit package offsets section followed by package lengths section.
off := preambleLength
off2 := mhsz
buf := make([]byte, 8)
for _, blob := range blobs {
binary.LittleEndian.PutUint64(buf, off)
if _, err = m.w.Write(buf); err != nil {
return fmt.Errorf("error writing %s: %v", m.mfname, err)
}
if m.debug {
fmt.Fprintf(os.Stderr, "=+= pkg offset %d 0x%x\n", off, off)
}
off += uint64(len(blob))
off2 += 8
}
for _, blob := range blobs {
bl := uint64(len(blob))
binary.LittleEndian.PutUint64(buf, bl)
if _, err = m.w.Write(buf); err != nil {
return fmt.Errorf("error writing %s: %v", m.mfname, err)
}
if m.debug {
fmt.Fprintf(os.Stderr, "=+= pkg len %d 0x%x\n", bl, bl)
}
off2 += 8
}
// Emit string table
if err = m.stab.Write(m.w); err != nil {
return err
}
// Now emit blobs themselves.
for k, blob := range blobs {
if m.debug {
h := fnv.New128a()
h.Write(blob)
fmt.Fprintf(os.Stderr, "=+= writing blob %d len %d at off=%d hash %s\n", k, len(blob), off2, fmt.Sprintf("%x", h.Sum(nil)))
}
if _, err = m.w.Write(blob); err != nil {
return fmt.Errorf("error writing %s: %v", m.mfname, err)
}
if m.debug {
fmt.Fprintf(os.Stderr, "=+= wrote package payload of %d bytes\n",
len(blob))
}
off2 += uint64(len(blob))
}
// Flush writer, and we're done.
if err = m.w.Flush(); err != nil {
return fmt.Errorf("error writing %s: %v", m.mfname, err)
}
return nil
}
|