Package: internal/coverage

package coverage Import Path internal/coverage (on go.dev) Dependency Relation imports 0 packages, and imported by 8 packages

Involved Source Files cmddefs.go defs.go pkid.go

Package-Level Type Names (total 13)

/* sort by: alphabet | popularity */

type CounterFileFooter (struct) CounterFileFooter appears at the tail end of a counter data file, and stores the number of segments it contains. Fields (total 2) Magic [4]byte NumSegments uint32

type CounterFileHeader (struct) CounterFileHeader stores files header information for a counter-data file. Fields (total 5) BigEndian bool CFlavor CounterFlavor Magic [4]byte MetaHash [16]byte Version uint32

type CounterFlavor uint8 (basic type) CounterFlavor describes how function and counters are stored/represented in the counter section of the file. As Inputs Of (at least one exported) func internal/coverage/encodecounter.NewCoverageDataWriter(w io.Writer, flav CounterFlavor) *encodecounter.CoverageDataWriter As Types Of (total 2) const CtrRaw const CtrULeb128

type CounterGranularity uint8 (basic type) CounterGranularity tracks the granularity of the coverage counters being used in a given coverage-instrumented program. Methods (only one) ( CounterGranularity) String() string Implements (at least 2) CounterGranularity : expvar.Var CounterGranularity : fmt.Stringer As Outputs Of (at least 2) func internal/coverage/cmerge.(*Merger).Granularity() CounterGranularity func internal/coverage/decodemeta.(*CoverageMetaFileReader).CounterGranularity() CounterGranularity As Inputs Of (at least 2) func internal/coverage/cmerge.(*Merger).SetModeAndGranularity(mdf string, cmode CounterMode, cgran CounterGranularity) error func internal/coverage/encodemeta.(*CoverageMetaFileWriter).Write(finalHash [16]byte, blobs [][]byte, mode CounterMode, granularity CounterGranularity) error As Types Of (total 3) const CtrGranularityInvalid const CtrGranularityPerBlock const CtrGranularityPerFunc

type CounterMode uint8 (basic type) CounterMode tracks the "flavor" of the coverage counters being used in a given coverage-instrumented program. Methods (only one) ( CounterMode) String() string Implements (at least 2) CounterMode : expvar.Var CounterMode : fmt.Stringer As Outputs Of (at least 3) func ParseCounterMode(mode string) CounterMode func internal/coverage/cmerge.(*Merger).Mode() CounterMode func internal/coverage/decodemeta.(*CoverageMetaFileReader).CounterMode() CounterMode As Inputs Of (at least 3) func internal/coverage/cformat.NewFormatter(cm CounterMode) *cformat.Formatter func internal/coverage/cmerge.(*Merger).SetModeAndGranularity(mdf string, cmode CounterMode, cgran CounterGranularity) error func internal/coverage/encodemeta.(*CoverageMetaFileWriter).Write(finalHash [16]byte, blobs [][]byte, mode CounterMode, granularity CounterGranularity) error As Types Of (total 6) const CtrModeAtomic const CtrModeCount const CtrModeInvalid const CtrModeRegOnly const CtrModeSet const CtrModeTestMain

type CounterSegmentHeader (struct) CounterSegmentHeader encapsulates information about a specific segment in a counter data file, which at the moment contains counters data from a single execution of a coverage-instrumented program. Following the segment header will be the string table and args table, and then (possibly) padding bytes to bring the byte size of the preamble up to a multiple of 4. Immediately following that will be the counter payloads. The "args" section of a segment is used to store annotations describing where the counter data came from; this section is basically a series of key-value pairs (can be thought of as an encoded 'map[string]string'). At the moment we only write os.Args() data to this section, using pairs of the form "argc=<integer>", "argv0=<os.Args[0]>", "argv1=<os.Args[1]>", and so on. In the future the args table may also include things like GOOS/GOARCH values, and/or tags indicating which tests were run to generate the counter data. Fields (total 3) ArgsLen uint32 FcnEntries uint64 StrTabLen uint32

type CoverableUnit (struct) CoverableUnit describes the source characteristics of a single program unit for which we want to gather coverage info. Coverable units are either "simple" or "intraline"; a "simple" coverable unit corresponds to a basic block (region of straight-line code with no jumps or control transfers). An "intraline" unit corresponds to a logical clause nested within some other simple unit. A simple unit will have a zero Parent value; for an intraline unit NxStmts will be zero and Parent will be set to 1 plus the index of the containing simple statement. Example: L7: q := 1 L8: x := (y == 101 || launch() == false) L9: r := x * 2 For the code above we would have three simple units (one for each line), then an intraline unit describing the "launch() == false" clause in line 8, with Parent pointing to the index of the line 8 unit in the units array. Note: in the initial version of the coverage revamp, only simple units will be in use. Fields (total 6) EnCol uint32 EnLine uint32 NxStmts uint32 Parent uint32 StCol uint32 StLine uint32 As Inputs Of (at least one exported) func internal/coverage/cformat.(*Formatter).AddUnit(file string, fname string, isfnlit bool, unit CoverableUnit, count uint32)

type CoverPkgConfig (struct) CoverPkgConfig is a bundle of information passed from the Go command to the cover command during "go build -cover" runs. The Go command creates and fills in a struct as below, then passes file containing the encoded JSON for the struct to the "cover" tool when instrumenting the source files in a Go package. Fields (total 6) Granularity string Instrumentation granularity: one of "perfunc" or "perblock" (default) Local bool Local mode indicates we're doing a coverage build or test of a package selected via local import path, e.g. "./..." or "./foo/bar" as opposed to a non-relative import path. See the corresponding field in cmd/go's PackageInternal struct for more info. ModulePath string Module path for this package (empty if no go.mod in use) OutConfig string File into which cmd/cover should emit summary info when instrumentation is complete. PkgName string Package name. PkgPath string Import path for the package being instrumented.

type FuncDesc (struct) FuncDesc encapsulates the meta-data definitions for a single Go function. This version assumes that we're looking at a function before inlining; if we want to capture a post-inlining view of the world, the representations of source positions would need to be a good deal more complicated. Fields (total 4) Funcname string Lit bool // true if this is a function literal Srcfile string Units []CoverableUnit As Inputs Of (at least 3) func internal/coverage/decodemeta.(*CoverageMetaDataDecoder).ReadFunc(fidx uint32, f *FuncDesc) error func internal/coverage/encodemeta.HashFuncDesc(f *FuncDesc) [16]byte func internal/coverage/encodemeta.(*CoverageMetaDataBuilder).AddFunc(f FuncDesc) uint

type MetaFileCollection (struct) MetaFilePaths contains information generated by the Go command and the read in by coverage test support functions within an executing "go test -cover" binary. Fields (total 2) ImportPaths []string MetaFileFragments []string

type MetaFileHeader (struct) MetaFileHeader stores file header information for a meta-data file. Fields (total 9) CGranularity CounterGranularity CMode CounterMode Entries uint64 Magic [4]byte MetaFileHash [16]byte StrTabLength uint32 StrTabOffset uint32 TotalLength uint64 Version uint32

type MetaSymbolHeader (struct) MetaSymbolHeader stores header information for a single meta-data blob, e.g. the coverage meta-data payload computed for a given Go package. Fields (total 7) Length uint32 // size of meta-symbol payload in bytes MetaHash [16]byte ModulePath uint32 // string table index NumFiles uint32 NumFuncs uint32 PkgName uint32 // string table index PkgPath uint32 // string table index

Package-Level Functions (total 3)

func HardCodedPkgID(pkgpath string) int HardCodedPkgID returns the hard-coded ID for the specified package path, or -1 if we don't use a hard-coded ID. Hard-coded IDs start at -2 and decrease as we go down the list.

func ParseCounterMode(mode string) CounterMode

func Round4(x int) int

Package-Level Variables (total 2)

var CovCounterMagic [4]byte CovCounterMagic holds the magic string for a coverage counter-data file.

var CovMetaMagic [4]byte CovMetaMagic holds the magic string for a meta-data file.

Package-Level Constants (total 24)

const CounterFilePref = "covcounters" CounterFilePref is the file prefix used when emitting coverage data output files. CounterFileTemplate describes the format of the file name: prefix followed by meta-file hash followed by process ID followed by emit UnixNanoTime.

const CounterFileRegexp = "^%s\\.(\\S+)\\.(\\d+)\\.(\\d+)+$"

const CounterFileTempl = "%s.%x.%d.%d"

const CounterFileVersion = 1 CounterFileVersion stores the most recent counter data file version.

const CovMetaHeaderSize = 44 // keep in sync with above

const CtrGranularityInvalid CounterGranularity = 0

const CtrGranularityPerBlock CounterGranularity = 1

const CtrGranularityPerFunc CounterGranularity = 2

const CtrModeAtomic CounterMode = 3 // "atomic" mode

const CtrModeCount CounterMode = 2 // "count" mode

const CtrModeInvalid CounterMode = 0

const CtrModeRegOnly CounterMode = 4 // registration-only pseudo-mode

const CtrModeSet CounterMode = 1 // "set" mode

const CtrModeTestMain CounterMode = 5 // testmain pseudo-mode

const CtrRaw CounterFlavor = 1 "Raw" representation: all values (pkg ID, func ID, num counters, and counters themselves) are stored as uint32's.

const CtrULeb128 CounterFlavor = 2 "ULeb" representation: all values (pkg ID, func ID, num counters, and counters themselves) are stored with ULEB128 encoding.

const FirstCtrOffset = 3

const FuncIdOffset = 2

const MetaFilePref = "covmeta" MetaFilePref is a prefix used when emitting meta-data files; these files are of the form "covmeta.<hash>", where hash is a hash computed from the hashes of all the package meta-data symbols in the program.

const MetaFilesFileName = "metafiles.txt" Name of file within the "go test -cover" temp coverdir directory containing a list of meta-data files for packages being tested in a "go test -coverpkg=... ..." run. This constant is shared by the Go command and by the coverage runtime.

const MetaFileVersion = 1 MetaFileVersion contains the current (most recent) meta-data file version.

const NotHardCoded = -1 NotHardCoded is a package pseudo-ID indicating that a given package is not part of the runtime and doesn't require a hard-coded ID.

const NumCtrsOffset = 0

const PkgIdOffset = 1