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 12)

	/* 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 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 CoverFixupConfig (struct)
		CoverFixupConfig contains annotations/notes generated by the
		cmd/cover tool (during instrumentation) to be passed on to the
		compiler when the instrumented code is compiled. The cmd/cover tool
		creates a struct of this type, JSON-encodes it, and emits the
		result to a file, which the Go command then passes to the compiler
		when the instrumented package is built.

		Fields (total 8)
			CounterGranularity string
				Counter granularity (perblock or perfunc).

			CounterMode string
				Counter mode (e.g. set/count/atomic)

			CounterPrefix string
				Prefix assigned to the names of counter variables generated
				during instrumentation by cmd/cover.

			MetaHash string
				Hash computed by cmd/cover of the meta-data.

			MetaLen int
				Length of the meta-data.

			MetaVar string
				Name of the variable (created by cmd/cover) containing the
				encoded meta-data for the package.

			PkgIdVar string
				Name chosen for the package ID variable generated during
				instrumentation.

			Strategy string
				Instrumentation strategy. For now this is always set to
				"normal", but in the future we may add new values (for example,
				if panic paths are instrumented, or if the instrumenter
				eliminates redundant counters).


	 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 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 23)

	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 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

The pages are generated with Golds v0.6.4. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.