Your IP : 172.28.240.42
// 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 decodemeta
// This package contains APIs and helpers for decoding a single package's
// meta data "blob" emitted by the compiler when coverage instrumentation
// is turned on.
import (
"encoding/binary"
"fmt"
"internal/coverage"
"internal/coverage/slicereader"
"internal/coverage/stringtab"
"io"
"os"
)
// See comments in the encodecovmeta package for details on the format.
type CoverageMetaDataDecoder struct {
r *slicereader.Reader
hdr coverage.MetaSymbolHeader
strtab *stringtab.Reader
tmp []byte
debug bool
}
func NewCoverageMetaDataDecoder(b []byte, readonly bool) (*CoverageMetaDataDecoder, error) {
slr := slicereader.NewReader(b, readonly)
x := &CoverageMetaDataDecoder{
r: slr,
tmp: make([]byte, 0, 256),
}
if err := x.readHeader(); err != nil {
return nil, err
}
if err := x.readStringTable(); err != nil {
return nil, err
}
return x, nil
}
func (d *CoverageMetaDataDecoder) readHeader() error {
if err := binary.Read(d.r, binary.LittleEndian, &d.hdr); err != nil {
return err
}
if d.debug {
fmt.Fprintf(os.Stderr, "=-= after readHeader: %+v\n", d.hdr)
}
return nil
}
func (d *CoverageMetaDataDecoder) readStringTable() error {
// Seek to the correct location to read the string table.
stringTableLocation := int64(coverage.CovMetaHeaderSize + 4*d.hdr.NumFuncs)
if _, err := d.r.Seek(stringTableLocation, io.SeekStart); err != nil {
return err
}
// Read the table itself.
d.strtab = stringtab.NewReader(d.r)
d.strtab.Read()
return nil
}
func (d *CoverageMetaDataDecoder) PackagePath() string {
return d.strtab.Get(d.hdr.PkgPath)
}
func (d *CoverageMetaDataDecoder) PackageName() string {
return d.strtab.Get(d.hdr.PkgName)
}
func (d *CoverageMetaDataDecoder) ModulePath() string {
return d.strtab.Get(d.hdr.ModulePath)
}
func (d *CoverageMetaDataDecoder) NumFuncs() uint32 {
return d.hdr.NumFuncs
}
// ReadFunc reads the coverage meta-data for the function with index
// 'findex', filling it into the FuncDesc pointed to by 'f'.
func (d *CoverageMetaDataDecoder) ReadFunc(fidx uint32, f *coverage.FuncDesc) error {
if fidx >= d.hdr.NumFuncs {
return fmt.Errorf("illegal function index")
}
// Seek to the correct location to read the function offset and read it.
funcOffsetLocation := int64(coverage.CovMetaHeaderSize + 4*fidx)
if _, err := d.r.Seek(funcOffsetLocation, io.SeekStart); err != nil {
return err
}
foff := d.r.ReadUint32()
// Check assumptions
if foff < uint32(funcOffsetLocation) || foff > d.hdr.Length {
return fmt.Errorf("malformed func offset %d", foff)
}
// Seek to the correct location to read the function.
floc := int64(foff)
if _, err := d.r.Seek(floc, io.SeekStart); err != nil {
return err
}
// Preamble containing number of units, file, and function.
numUnits := uint32(d.r.ReadULEB128())
fnameidx := uint32(d.r.ReadULEB128())
fileidx := uint32(d.r.ReadULEB128())
f.Srcfile = d.strtab.Get(fileidx)
f.Funcname = d.strtab.Get(fnameidx)
// Now the units
f.Units = f.Units[:0]
if cap(f.Units) < int(numUnits) {
f.Units = make([]coverage.CoverableUnit, 0, numUnits)
}
for k := uint32(0); k < numUnits; k++ {
f.Units = append(f.Units,
coverage.CoverableUnit{
StLine: uint32(d.r.ReadULEB128()),
StCol: uint32(d.r.ReadULEB128()),
EnLine: uint32(d.r.ReadULEB128()),
EnCol: uint32(d.r.ReadULEB128()),
NxStmts: uint32(d.r.ReadULEB128()),
})
}
lit := d.r.ReadULEB128()
f.Lit = lit != 0
return nil
}