go/src/runtime/pprof/proto.go

// lostProfileEvent is the function to which lost profiling
// events are attributed.
// (The name shows up in the pprof graphs.)
func lostProfileEvent() {}

type profileBuilder

type memMap

type symbolizeFlag

const lookupTried

const lookupFailed

const tagProfile_SampleType

const tagProfile_Sample

const tagProfile_Mapping

const tagProfile_Location

const tagProfile_Function

const tagProfile_StringTable

const tagProfile_DropFrames

const tagProfile_KeepFrames

const tagProfile_TimeNanos

const tagProfile_DurationNanos

const tagProfile_PeriodType

const tagProfile_Period

const tagProfile_Comment

const tagProfile_DefaultSampleType

const tagValueType_Type

const tagValueType_Unit

const tagSample_Location

const tagSample_Value

const tagSample_Label

const tagLabel_Key

const tagLabel_Str

const tagLabel_Num

const tagMapping_ID

const tagMapping_Start

const tagMapping_Limit

const tagMapping_Offset

const tagMapping_Filename

const tagMapping_BuildID

const tagMapping_HasFunctions

const tagMapping_HasFilenames

const tagMapping_HasLineNumbers

const tagMapping_HasInlineFrames

const tagLocation_ID

const tagLocation_MappingID

const tagLocation_Address

const tagLocation_Line

const tagLine_FunctionID

const tagLine_Line

const tagFunction_ID

const tagFunction_Name

const tagFunction_SystemName

const tagFunction_Filename

const tagFunction_StartLine

// stringIndex adds s to the string table if not already present
// and returns the index of s in the string table.
func (b *profileBuilder) stringIndex(s string) int64 {}

func (b *profileBuilder) flush() {}

// pbValueType encodes a ValueType message to b.pb.
func (b *profileBuilder) pbValueType(tag int, typ, unit string) {}

// pbSample encodes a Sample message to b.pb.
func (b *profileBuilder) pbSample(values []int64, locs []uint64, labels func()) {}

// pbLabel encodes a Label message to b.pb.
func (b *profileBuilder) pbLabel(tag int, key, str string, num int64) {}

// pbLine encodes a Line message to b.pb.
func (b *profileBuilder) pbLine(tag int, funcID uint64, line int64) {}

// pbMapping encodes a Mapping message to b.pb.
func (b *profileBuilder) pbMapping(tag int, id, base, limit, offset uint64, file, buildID string, hasFuncs bool) {}

func allFrames(addr uintptr) ([]runtime.Frame, symbolizeFlag) {}

type locInfo

// newProfileBuilder returns a new profileBuilder.
// CPU profiling data obtained from the runtime can be added
// by calling b.addCPUData, and then the eventual profile
// can be obtained by calling b.finish.
func newProfileBuilder(w io.Writer) *profileBuilder {}

// addCPUData adds the CPU profiling data to the profile.
//
// The data must be a whole number of records, as delivered by the runtime.
// len(tags) must be equal to the number of records in data.
func (b *profileBuilder) addCPUData(data []uint64, tags []unsafe.Pointer) error {}

// build completes and returns the constructed profile.
func (b *profileBuilder) build() {}

// appendLocsForStack appends the location IDs for the given stack trace to the given
// location ID slice, locs. The addresses in the stack are return PCs or 1 + the PC of
// an inline marker as the runtime traceback function returns.
//
// It may return an empty slice even if locs is non-empty, for example if locs consists
// solely of runtime.goexit. We still count these empty stacks in profiles in order to
// get the right cumulative sample count.
//
// It may emit to b.pb, so there must be no message encoding in progress.
func (b *profileBuilder) appendLocsForStack(locs []uint64, stk []uintptr) (newLocs []uint64) {}

type pcDeck

func (d *pcDeck) reset() {}

// tryAdd tries to add the pc and Frames expanded from it (most likely one,
// since the stack trace is already fully expanded) and the symbolizeResult
// to the deck. If it fails the caller needs to flush the deck and retry.
func (d *pcDeck) tryAdd(pc uintptr, frames []runtime.Frame, symbolizeResult symbolizeFlag) (success bool) {}

// emitLocation emits the new location and function information recorded in the deck
// and returns the location ID encoded in the profile protobuf.
// It emits to b.pb, so there must be no message encoding in progress.
// It resets the deck.
func (b *profileBuilder) emitLocation() uint64 {}

var space

var newline

func parseProcSelfMaps(data []byte, addMapping func(lo, hi, offset uint64, file, buildID string)) {}

func (b *profileBuilder) addMapping(lo, hi, offset uint64, file, buildID string) {}

func (b *profileBuilder) addMappingEntry(lo, hi, offset uint64, file, buildID string, fake bool) {}