// Copyright 2023 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 trace

import (
	
	
	
	

	
	
	
)

// EventKind indicates the kind of event this is.
//
// Use this information to obtain a more specific event that
// allows access to more detailed information.
type EventKind uint16

const (
	EventBad EventKind = iota

	// EventKindSync is an event that indicates a global synchronization
	// point in the trace. At the point of a sync event, the
	// trace reader can be certain that all resources (e.g. threads,
	// goroutines) that have existed until that point have been enumerated.
	EventSync

	// EventMetric is an event that represents the value of a metric at
	// a particular point in time.
	EventMetric

	// EventLabel attaches a label to a resource.
	EventLabel

	// EventStackSample represents an execution sample, indicating what a
	// thread/proc/goroutine was doing at a particular point in time via
	// its backtrace.
	//
	// Note: Samples should be considered a close approximation of
	// what a thread/proc/goroutine was executing at a given point in time.
	// These events may slightly contradict the situation StateTransitions
	// describe, so they should only be treated as a best-effort annotation.
	EventStackSample

	// EventRangeBegin and EventRangeEnd are a pair of generic events representing
	// a special range of time. Ranges are named and scoped to some resource
	// (identified via ResourceKind). A range that has begun but has not ended
	// is considered active.
	//
	// EvRangeBegin and EvRangeEnd will share the same name, and an End will always
	// follow a Begin on the same instance of the resource. The associated
	// resource ID can be obtained from the Event. ResourceNone indicates the
	// range is globally scoped. That is, any goroutine/proc/thread can start or
	// stop, but only one such range may be active at any given time.
	//
	// EventRangeActive is like EventRangeBegin, but indicates that the range was
	// already active. In this case, the resource referenced may not be in the current
	// context.
	EventRangeBegin
	EventRangeActive
	EventRangeEnd

	// EvTaskBegin and EvTaskEnd are a pair of events representing a runtime/trace.Task.
	EventTaskBegin
	EventTaskEnd

	// EventRegionBegin and EventRegionEnd are a pair of events represent a runtime/trace.Region.
	EventRegionBegin
	EventRegionEnd

	// EventLog represents a runtime/trace.Log call.
	EventLog

	// EventStateTransition represents a state change for some resource.
	EventStateTransition

	// EventExperimental is an experimental event that is unvalidated and exposed in a raw form.
	// Users are expected to understand the format and perform their own validation. These events
	// may always be safely ignored.
	EventExperimental
)

// String returns a string form of the EventKind.
func ( EventKind) () string {
	if int() >= len(eventKindStrings) {
		return eventKindStrings[0]
	}
	return eventKindStrings[]
}

var eventKindStrings = [...]string{
	EventBad:             "Bad",
	EventSync:            "Sync",
	EventMetric:          "Metric",
	EventLabel:           "Label",
	EventStackSample:     "StackSample",
	EventRangeBegin:      "RangeBegin",
	EventRangeActive:     "RangeActive",
	EventRangeEnd:        "RangeEnd",
	EventTaskBegin:       "TaskBegin",
	EventTaskEnd:         "TaskEnd",
	EventRegionBegin:     "RegionBegin",
	EventRegionEnd:       "RegionEnd",
	EventLog:             "Log",
	EventStateTransition: "StateTransition",
	EventExperimental:    "Experimental",
}

const maxTime = Time(math.MaxInt64)

// Time is a timestamp in nanoseconds.
//
// It corresponds to the monotonic clock on the platform that the
// trace was taken, and so is possible to correlate with timestamps
// for other traces taken on the same machine using the same clock
// (i.e. no reboots in between).
//
// The actual absolute value of the timestamp is only meaningful in
// relation to other timestamps from the same clock.
//
// BUG: Timestamps coming from traces on Windows platforms are
// only comparable with timestamps from the same trace. Timestamps
// across traces cannot be compared, because the system clock is
// not used as of Go 1.22.
//
// BUG: Traces produced by Go versions 1.21 and earlier cannot be
// compared with timestamps from other traces taken on the same
// machine. This is because the system clock was not used at all
// to collect those timestamps.
type Time int64

// Sub subtracts t0 from t, returning the duration in nanoseconds.
func ( Time) ( Time) time.Duration {
	return time.Duration(int64() - int64())
}

// Metric provides details about a Metric event.
type Metric struct {
	// Name is the name of the sampled metric.
	//
	// Names follow the same convention as metric names in the
	// runtime/metrics package, meaning they include the unit.
	// Names that match with the runtime/metrics package represent
	// the same quantity. Note that this corresponds to the
	// runtime/metrics package for the Go version this trace was
	// collected for.
	Name string

	// Value is the sampled value of the metric.
	//
	// The Value's Kind is tied to the name of the metric, and so is
	// guaranteed to be the same for metric samples for the same metric.
	Value Value
}

// Label provides details about a Label event.
type Label struct {
	// Label is the label applied to some resource.
	Label string

	// Resource is the resource to which this label should be applied.
	Resource ResourceID
}

// Range provides details about a Range event.
type Range struct {
	// Name is a human-readable name for the range.
	//
	// This name can be used to identify the end of the range for the resource
	// its scoped to, because only one of each type of range may be active on
	// a particular resource. The relevant resource should be obtained from the
	// Event that produced these details. The corresponding RangeEnd will have
	// an identical name.
	Name string

	// Scope is the resource that the range is scoped to.
	//
	// For example, a ResourceGoroutine scope means that the same goroutine
	// must have a start and end for the range, and that goroutine can only
	// have one range of a particular name active at any given time. The
	// ID that this range is scoped to may be obtained via Event.Goroutine.
	//
	// The ResourceNone scope means that the range is globally scoped. As a
	// result, any goroutine/proc/thread may start or end the range, and only
	// one such named range may be active globally at any given time.
	//
	// For RangeBegin and RangeEnd events, this will always reference some
	// resource ID in the current execution context. For RangeActive events,
	// this may reference a resource not in the current context. Prefer Scope
	// over the current execution context.
	Scope ResourceID
}

// RangeAttributes provides attributes about a completed Range.
type RangeAttribute struct {
	// Name is the human-readable name for the range.
	Name string

	// Value is the value of the attribute.
	Value Value
}

// TaskID is the internal ID of a task used to disambiguate tasks (even if they
// are of the same type).
type TaskID uint64

const (
	// NoTask indicates the lack of a task.
	NoTask = TaskID(^uint64(0))

	// BackgroundTask is the global task that events are attached to if there was
	// no other task in the context at the point the event was emitted.
	BackgroundTask = TaskID(0)
)

// Task provides details about a Task event.
type Task struct {
	// ID is a unique identifier for the task.
	//
	// This can be used to associate the beginning of a task with its end.
	ID TaskID

	// ParentID is the ID of the parent task.
	Parent TaskID

	// Type is the taskType that was passed to runtime/trace.NewTask.
	//
	// May be "" if a task's TaskBegin event isn't present in the trace.
	Type string
}

// Region provides details about a Region event.
type Region struct {
	// Task is the ID of the task this region is associated with.
	Task TaskID

	// Type is the regionType that was passed to runtime/trace.StartRegion or runtime/trace.WithRegion.
	Type string
}

// Log provides details about a Log event.
type Log struct {
	// Task is the ID of the task this region is associated with.
	Task TaskID

	// Category is the category that was passed to runtime/trace.Log or runtime/trace.Logf.
	Category string

	// Message is the message that was passed to runtime/trace.Log or runtime/trace.Logf.
	Message string
}

// Stack represents a stack. It's really a handle to a stack and it's trivially comparable.
//
// If two Stacks are equal then their Frames are guaranteed to be identical. If they are not
// equal, however, their Frames may still be equal.
type Stack struct {
	table *evTable
	id    stackID
}

// Frames is an iterator over the frames in a Stack.
func ( Stack) ( func( StackFrame) bool) bool {
	if .id == 0 {
		return true
	}
	 := .table.stacks.mustGet(.id)
	for ,  := range .pcs {
		 := .table.pcs[]
		 := StackFrame{
			PC:   .pc,
			Func: .table.strings.mustGet(.funcID),
			File: .table.strings.mustGet(.fileID),
			Line: .line,
		}
		if !() {
			return false
		}
	}
	return true
}

// NoStack is a sentinel value that can be compared against any Stack value, indicating
// a lack of a stack trace.
var NoStack = Stack{}

// StackFrame represents a single frame of a stack.
type StackFrame struct {
	// PC is the program counter of the function call if this
	// is not a leaf frame. If it's a leaf frame, it's the point
	// at which the stack trace was taken.
	PC uint64

	// Func is the name of the function this frame maps to.
	Func string

	// File is the file which contains the source code of Func.
	File string

	// Line is the line number within File which maps to PC.
	Line uint64
}

// ExperimentalEvent presents a raw view of an experimental event's arguments and thier names.
type ExperimentalEvent struct {
	// Name is the name of the event.
	Name string

	// ArgNames is the names of the event's arguments in order.
	// This may refer to a globally shared slice. Copy before mutating.
	ArgNames []string

	// Args contains the event's arguments.
	Args []uint64

	// Data is additional unparsed data that is associated with the experimental event.
	// Data is likely to be shared across many ExperimentalEvents, so callers that parse
	// Data are encouraged to cache the parse result and look it up by the value of Data.
	Data *ExperimentalData
}

// ExperimentalData represents some raw and unparsed sidecar data present in the trace that is
// associated with certain kinds of experimental events. For example, this data may contain
// tables needed to interpret ExperimentalEvent arguments, or the ExperimentEvent could just be
// a placeholder for a differently encoded event that's actually present in the experimental data.
type ExperimentalData struct {
	// Batches contain the actual experimental data, along with metadata about each batch.
	Batches []ExperimentalBatch
}

// ExperimentalBatch represents a packet of unparsed data along with metadata about that packet.
type ExperimentalBatch struct {
	// Thread is the ID of the thread that produced a packet of data.
	Thread ThreadID

	// Data is a packet of unparsed data all produced by one thread.
	Data []byte
}

// Event represents a single event in the trace.
type Event struct {
	table *evTable
	ctx   schedCtx
	base  baseEvent
}

// Kind returns the kind of event that this is.
func ( Event) () EventKind {
	return go122Type2Kind[.base.typ]
}

// Time returns the timestamp of the event.
func ( Event) () Time {
	return .base.time
}

// Goroutine returns the ID of the goroutine that was executing when
// this event happened. It describes part of the execution context
// for this event.
//
// Note that for goroutine state transitions this always refers to the
// state before the transition. For example, if a goroutine is just
// starting to run on this thread and/or proc, then this will return
// NoGoroutine. In this case, the goroutine starting to run will be
// can be found at Event.StateTransition().Resource.
func ( Event) () GoID {
	return .ctx.G
}

// Proc returns the ID of the proc this event event pertains to.
//
// Note that for proc state transitions this always refers to the
// state before the transition. For example, if a proc is just
// starting to run on this thread, then this will return NoProc.
func ( Event) () ProcID {
	return .ctx.P
}

// Thread returns the ID of the thread this event pertains to.
//
// Note that for thread state transitions this always refers to the
// state before the transition. For example, if a thread is just
// starting to run, then this will return NoThread.
//
// Note: tracking thread state is not currently supported, so this
// will always return a valid thread ID. However thread state transitions
// may be tracked in the future, and callers must be robust to this
// possibility.
func ( Event) () ThreadID {
	return .ctx.M
}

// Stack returns a handle to a stack associated with the event.
//
// This represents a stack trace at the current moment in time for
// the current execution context.
func ( Event) () Stack {
	if .base.typ == evSync {
		return NoStack
	}
	if .base.typ == go122.EvCPUSample {
		return Stack{table: .table, id: stackID(.base.args[0])}
	}
	 := go122.Specs()[.base.typ]
	if len(.StackIDs) == 0 {
		return NoStack
	}
	// The stack for the main execution context is always the
	// first stack listed in StackIDs. Subtract one from this
	// because we've peeled away the timestamp argument.
	 := stackID(.base.args[.StackIDs[0]-1])
	if  == 0 {
		return NoStack
	}
	return Stack{table: .table, id: }
}

// Metric returns details about a Metric event.
//
// Panics if Kind != EventMetric.
func ( Event) () Metric {
	if .Kind() != EventMetric {
		panic("Metric called on non-Metric event")
	}
	var  Metric
	switch .base.typ {
	case go122.EvProcsChange:
		.Name = "/sched/gomaxprocs:threads"
		.Value = Value{kind: ValueUint64, scalar: .base.args[0]}
	case go122.EvHeapAlloc:
		.Name = "/memory/classes/heap/objects:bytes"
		.Value = Value{kind: ValueUint64, scalar: .base.args[0]}
	case go122.EvHeapGoal:
		.Name = "/gc/heap/goal:bytes"
		.Value = Value{kind: ValueUint64, scalar: .base.args[0]}
	default:
		panic(fmt.Sprintf("internal error: unexpected event type for Metric kind: %s", go122.EventString(.base.typ)))
	}
	return 
}

// Label returns details about a Label event.
//
// Panics if Kind != EventLabel.
func ( Event) () Label {
	if .Kind() != EventLabel {
		panic("Label called on non-Label event")
	}
	if .base.typ != go122.EvGoLabel {
		panic(fmt.Sprintf("internal error: unexpected event type for Label kind: %s", go122.EventString(.base.typ)))
	}
	return Label{
		Label:    .table.strings.mustGet(stringID(.base.args[0])),
		Resource: ResourceID{Kind: ResourceGoroutine, id: int64(.ctx.G)},
	}
}

// Range returns details about an EventRangeBegin, EventRangeActive, or EventRangeEnd event.
//
// Panics if Kind != EventRangeBegin, Kind != EventRangeActive, and Kind != EventRangeEnd.
func ( Event) () Range {
	if  := .Kind();  != EventRangeBegin &&  != EventRangeActive &&  != EventRangeEnd {
		panic("Range called on non-Range event")
	}
	var  Range
	switch .base.typ {
	case go122.EvSTWBegin, go122.EvSTWEnd:
		// N.B. ordering.advance smuggles in the STW reason as e.base.args[0]
		// for go122.EvSTWEnd (it's already there for Begin).
		.Name = "stop-the-world (" + .table.strings.mustGet(stringID(.base.args[0])) + ")"
		.Scope = ResourceID{Kind: ResourceGoroutine, id: int64(.Goroutine())}
	case go122.EvGCBegin, go122.EvGCActive, go122.EvGCEnd:
		.Name = "GC concurrent mark phase"
		.Scope = ResourceID{Kind: ResourceNone}
	case go122.EvGCSweepBegin, go122.EvGCSweepActive, go122.EvGCSweepEnd:
		.Name = "GC incremental sweep"
		.Scope = ResourceID{Kind: ResourceProc}
		if .base.typ == go122.EvGCSweepActive {
			.Scope.id = int64(.base.args[0])
		} else {
			.Scope.id = int64(.Proc())
		}
		.Scope.id = int64(.Proc())
	case go122.EvGCMarkAssistBegin, go122.EvGCMarkAssistActive, go122.EvGCMarkAssistEnd:
		.Name = "GC mark assist"
		.Scope = ResourceID{Kind: ResourceGoroutine}
		if .base.typ == go122.EvGCMarkAssistActive {
			.Scope.id = int64(.base.args[0])
		} else {
			.Scope.id = int64(.Goroutine())
		}
	default:
		panic(fmt.Sprintf("internal error: unexpected event type for Range kind: %s", go122.EventString(.base.typ)))
	}
	return 
}

// RangeAttributes returns attributes for a completed range.
//
// Panics if Kind != EventRangeEnd.
func ( Event) () []RangeAttribute {
	if .Kind() != EventRangeEnd {
		panic("Range called on non-Range event")
	}
	if .base.typ != go122.EvGCSweepEnd {
		return nil
	}
	return []RangeAttribute{
		{
			Name:  "bytes swept",
			Value: Value{kind: ValueUint64, scalar: .base.args[0]},
		},
		{
			Name:  "bytes reclaimed",
			Value: Value{kind: ValueUint64, scalar: .base.args[1]},
		},
	}
}

// Task returns details about a TaskBegin or TaskEnd event.
//
// Panics if Kind != EventTaskBegin and Kind != EventTaskEnd.
func ( Event) () Task {
	if  := .Kind();  != EventTaskBegin &&  != EventTaskEnd {
		panic("Task called on non-Task event")
	}
	 := NoTask
	var  string
	switch .base.typ {
	case go122.EvUserTaskBegin:
		 = TaskID(.base.args[1])
		 = .table.strings.mustGet(stringID(.base.args[2]))
	case go122.EvUserTaskEnd:
		 = TaskID(.base.extra(version.Go122)[0])
		 = .table.getExtraString(extraStringID(.base.extra(version.Go122)[1]))
	default:
		panic(fmt.Sprintf("internal error: unexpected event type for Task kind: %s", go122.EventString(.base.typ)))
	}
	return Task{
		ID:     TaskID(.base.args[0]),
		Parent: ,
		Type:   ,
	}
}

// Region returns details about a RegionBegin or RegionEnd event.
//
// Panics if Kind != EventRegionBegin and Kind != EventRegionEnd.
func ( Event) () Region {
	if  := .Kind();  != EventRegionBegin &&  != EventRegionEnd {
		panic("Region called on non-Region event")
	}
	if .base.typ != go122.EvUserRegionBegin && .base.typ != go122.EvUserRegionEnd {
		panic(fmt.Sprintf("internal error: unexpected event type for Region kind: %s", go122.EventString(.base.typ)))
	}
	return Region{
		Task: TaskID(.base.args[0]),
		Type: .table.strings.mustGet(stringID(.base.args[1])),
	}
}

// Log returns details about a Log event.
//
// Panics if Kind != EventLog.
func ( Event) () Log {
	if .Kind() != EventLog {
		panic("Log called on non-Log event")
	}
	if .base.typ != go122.EvUserLog {
		panic(fmt.Sprintf("internal error: unexpected event type for Log kind: %s", go122.EventString(.base.typ)))
	}
	return Log{
		Task:     TaskID(.base.args[0]),
		Category: .table.strings.mustGet(stringID(.base.args[1])),
		Message:  .table.strings.mustGet(stringID(.base.args[2])),
	}
}

// StateTransition returns details about a StateTransition event.
//
// Panics if Kind != EventStateTransition.
func ( Event) () StateTransition {
	if .Kind() != EventStateTransition {
		panic("StateTransition called on non-StateTransition event")
	}
	var  StateTransition
	switch .base.typ {
	case go122.EvProcStart:
		 = procStateTransition(ProcID(.base.args[0]), ProcIdle, ProcRunning)
	case go122.EvProcStop:
		 = procStateTransition(.ctx.P, ProcRunning, ProcIdle)
	case go122.EvProcSteal:
		// N.B. ordering.advance populates e.base.extra.
		 := ProcRunning
		if go122.ProcStatus(.base.extra(version.Go122)[0]) == go122.ProcSyscallAbandoned {
			// We've lost information because this ProcSteal advanced on a
			// SyscallAbandoned state. Treat the P as idle because ProcStatus
			// treats SyscallAbandoned as Idle. Otherwise we'll have an invalid
			// transition.
			 = ProcIdle
		}
		 = procStateTransition(ProcID(.base.args[0]), , ProcIdle)
	case go122.EvProcStatus:
		// N.B. ordering.advance populates e.base.extra.
		 = procStateTransition(ProcID(.base.args[0]), ProcState(.base.extra(version.Go122)[0]), go122ProcStatus2ProcState[.base.args[1]])
	case go122.EvGoCreate, go122.EvGoCreateBlocked:
		 := GoRunnable
		if .base.typ == go122.EvGoCreateBlocked {
			 = GoWaiting
		}
		 = goStateTransition(GoID(.base.args[0]), GoNotExist, )
		.Stack = Stack{table: .table, id: stackID(.base.args[1])}
	case go122.EvGoCreateSyscall:
		 = goStateTransition(GoID(.base.args[0]), GoNotExist, GoSyscall)
	case go122.EvGoStart:
		 = goStateTransition(GoID(.base.args[0]), GoRunnable, GoRunning)
	case go122.EvGoDestroy:
		 = goStateTransition(.ctx.G, GoRunning, GoNotExist)
		.Stack = .Stack() // This event references the resource the event happened on.
	case go122.EvGoDestroySyscall:
		 = goStateTransition(.ctx.G, GoSyscall, GoNotExist)
	case go122.EvGoStop:
		 = goStateTransition(.ctx.G, GoRunning, GoRunnable)
		.Reason = .table.strings.mustGet(stringID(.base.args[0]))
		.Stack = .Stack() // This event references the resource the event happened on.
	case go122.EvGoBlock:
		 = goStateTransition(.ctx.G, GoRunning, GoWaiting)
		.Reason = .table.strings.mustGet(stringID(.base.args[0]))
		.Stack = .Stack() // This event references the resource the event happened on.
	case go122.EvGoUnblock, go122.EvGoSwitch, go122.EvGoSwitchDestroy:
		// N.B. GoSwitch and GoSwitchDestroy both emit additional events, but
		// the first thing they both do is unblock the goroutine they name,
		// identically to an unblock event (even their arguments match).
		 = goStateTransition(GoID(.base.args[0]), GoWaiting, GoRunnable)
	case go122.EvGoSyscallBegin:
		 = goStateTransition(.ctx.G, GoRunning, GoSyscall)
		.Stack = .Stack() // This event references the resource the event happened on.
	case go122.EvGoSyscallEnd:
		 = goStateTransition(.ctx.G, GoSyscall, GoRunning)
		.Stack = .Stack() // This event references the resource the event happened on.
	case go122.EvGoSyscallEndBlocked:
		 = goStateTransition(.ctx.G, GoSyscall, GoRunnable)
		.Stack = .Stack() // This event references the resource the event happened on.
	case go122.EvGoStatus, go122.EvGoStatusStack:
		// N.B. ordering.advance populates e.base.extra.
		 = goStateTransition(GoID(.base.args[0]), GoState(.base.extra(version.Go122)[0]), go122GoStatus2GoState[.base.args[2]])
	default:
		panic(fmt.Sprintf("internal error: unexpected event type for StateTransition kind: %s", go122.EventString(.base.typ)))
	}
	return 
}

// Experimental returns a view of the raw event for an experimental event.
//
// Panics if Kind != EventExperimental.
func ( Event) () ExperimentalEvent {
	if .Kind() != EventExperimental {
		panic("Experimental called on non-Experimental event")
	}
	 := go122.Specs()[.base.typ]
	 := .Args[1:] // Skip timestamp; already handled.
	return ExperimentalEvent{
		Name:     .Name,
		ArgNames: ,
		Args:     .base.args[:len()],
		Data:     .table.expData[.Experiment],
	}
}

const evSync = ^event.Type(0)

var go122Type2Kind = [...]EventKind{
	go122.EvCPUSample:           EventStackSample,
	go122.EvProcsChange:         EventMetric,
	go122.EvProcStart:           EventStateTransition,
	go122.EvProcStop:            EventStateTransition,
	go122.EvProcSteal:           EventStateTransition,
	go122.EvProcStatus:          EventStateTransition,
	go122.EvGoCreate:            EventStateTransition,
	go122.EvGoCreateSyscall:     EventStateTransition,
	go122.EvGoStart:             EventStateTransition,
	go122.EvGoDestroy:           EventStateTransition,
	go122.EvGoDestroySyscall:    EventStateTransition,
	go122.EvGoStop:              EventStateTransition,
	go122.EvGoBlock:             EventStateTransition,
	go122.EvGoUnblock:           EventStateTransition,
	go122.EvGoSyscallBegin:      EventStateTransition,
	go122.EvGoSyscallEnd:        EventStateTransition,
	go122.EvGoSyscallEndBlocked: EventStateTransition,
	go122.EvGoStatus:            EventStateTransition,
	go122.EvSTWBegin:            EventRangeBegin,
	go122.EvSTWEnd:              EventRangeEnd,
	go122.EvGCActive:            EventRangeActive,
	go122.EvGCBegin:             EventRangeBegin,
	go122.EvGCEnd:               EventRangeEnd,
	go122.EvGCSweepActive:       EventRangeActive,
	go122.EvGCSweepBegin:        EventRangeBegin,
	go122.EvGCSweepEnd:          EventRangeEnd,
	go122.EvGCMarkAssistActive:  EventRangeActive,
	go122.EvGCMarkAssistBegin:   EventRangeBegin,
	go122.EvGCMarkAssistEnd:     EventRangeEnd,
	go122.EvHeapAlloc:           EventMetric,
	go122.EvHeapGoal:            EventMetric,
	go122.EvGoLabel:             EventLabel,
	go122.EvUserTaskBegin:       EventTaskBegin,
	go122.EvUserTaskEnd:         EventTaskEnd,
	go122.EvUserRegionBegin:     EventRegionBegin,
	go122.EvUserRegionEnd:       EventRegionEnd,
	go122.EvUserLog:             EventLog,
	go122.EvGoSwitch:            EventStateTransition,
	go122.EvGoSwitchDestroy:     EventStateTransition,
	go122.EvGoCreateBlocked:     EventStateTransition,
	go122.EvGoStatusStack:       EventStateTransition,
	go122.EvSpan:                EventExperimental,
	go122.EvSpanAlloc:           EventExperimental,
	go122.EvSpanFree:            EventExperimental,
	go122.EvHeapObject:          EventExperimental,
	go122.EvHeapObjectAlloc:     EventExperimental,
	go122.EvHeapObjectFree:      EventExperimental,
	go122.EvGoroutineStack:      EventExperimental,
	go122.EvGoroutineStackAlloc: EventExperimental,
	go122.EvGoroutineStackFree:  EventExperimental,
	evSync:                      EventSync,
}

var go122GoStatus2GoState = [...]GoState{
	go122.GoRunnable: GoRunnable,
	go122.GoRunning:  GoRunning,
	go122.GoWaiting:  GoWaiting,
	go122.GoSyscall:  GoSyscall,
}

var go122ProcStatus2ProcState = [...]ProcState{
	go122.ProcRunning:          ProcRunning,
	go122.ProcIdle:             ProcIdle,
	go122.ProcSyscall:          ProcRunning,
	go122.ProcSyscallAbandoned: ProcIdle,
}

// String returns the event as a human-readable string.
//
// The format of the string is intended for debugging and is subject to change.
func ( Event) () string {
	var  strings.Builder
	fmt.Fprintf(&, "M=%d P=%d G=%d", .Thread(), .Proc(), .Goroutine())
	fmt.Fprintf(&, " %s Time=%d", .Kind(), .Time())
	// Kind-specific fields.
	switch  := .Kind();  {
	case EventMetric:
		 := .Metric()
		fmt.Fprintf(&, " Name=%q Value=%s", .Name, valueAsString(.Value))
	case EventLabel:
		 := .Label()
		fmt.Fprintf(&, " Label=%q Resource=%s", .Label, .Resource)
	case EventRangeBegin, EventRangeActive, EventRangeEnd:
		 := .Range()
		fmt.Fprintf(&, " Name=%q Scope=%s", .Name, .Scope)
		if  == EventRangeEnd {
			fmt.Fprintf(&, " Attributes=[")
			for ,  := range .RangeAttributes() {
				if  != 0 {
					fmt.Fprintf(&, " ")
				}
				fmt.Fprintf(&, "%q=%s", .Name, valueAsString(.Value))
			}
			fmt.Fprintf(&, "]")
		}
	case EventTaskBegin, EventTaskEnd:
		 := .Task()
		fmt.Fprintf(&, " ID=%d Parent=%d Type=%q", .ID, .Parent, .Type)
	case EventRegionBegin, EventRegionEnd:
		 := .Region()
		fmt.Fprintf(&, " Task=%d Type=%q", .Task, .Type)
	case EventLog:
		 := .Log()
		fmt.Fprintf(&, " Task=%d Category=%q Message=%q", .Task, .Category, .Message)
	case EventStateTransition:
		 := .StateTransition()
		fmt.Fprintf(&, " Resource=%s Reason=%q", .Resource, .Reason)
		switch .Resource.Kind {
		case ResourceGoroutine:
			 := .Resource.Goroutine()
			,  := .Goroutine()
			fmt.Fprintf(&, " GoID=%d %s->%s", , , )
		case ResourceProc:
			 := .Resource.Proc()
			,  := .Proc()
			fmt.Fprintf(&, " ProcID=%d %s->%s", , , )
		}
		if .Stack != NoStack {
			fmt.Fprintln(&)
			fmt.Fprintln(&, "TransitionStack=")
			.Stack.Frames(func( StackFrame) bool {
				fmt.Fprintf(&, "\t%s @ 0x%x\n", .Func, .PC)
				fmt.Fprintf(&, "\t\t%s:%d\n", .File, .Line)
				return true
			})
		}
	case EventExperimental:
		 := .Experimental()
		fmt.Fprintf(&, " Name=%s ArgNames=%v Args=%v", .Name, .ArgNames, .Args)
	}
	if  := .Stack();  != NoStack {
		fmt.Fprintln(&)
		fmt.Fprintln(&, "Stack=")
		.Frames(func( StackFrame) bool {
			fmt.Fprintf(&, "\t%s @ 0x%x\n", .Func, .PC)
			fmt.Fprintf(&, "\t\t%s:%d\n", .File, .Line)
			return true
		})
	}
	return .String()
}

// validateTableIDs checks to make sure lookups in e.table
// will work.
func ( Event) () error {
	if .base.typ == evSync {
		return nil
	}
	 := go122.Specs()[.base.typ]

	// Check stacks.
	for ,  := range .StackIDs {
		 := stackID(.base.args[-1])
		,  := .table.stacks.get()
		if ! {
			return fmt.Errorf("found invalid stack ID %d for event %s", , .Name)
		}
	}
	// N.B. Strings referenced by stack frames are validated
	// early on, when reading the stacks in to begin with.

	// Check strings.
	for ,  := range .StringIDs {
		 := stringID(.base.args[-1])
		,  := .table.strings.get()
		if ! {
			return fmt.Errorf("found invalid string ID %d for event %s", , .Name)
		}
	}
	return nil
}

func syncEvent( *evTable,  Time) Event {
	return Event{
		table: ,
		ctx: schedCtx{
			G: NoGoroutine,
			P: NoProc,
			M: NoThread,
		},
		base: baseEvent{
			typ:  evSync,
			time: ,
		},
	}
}