prog

type Arg interface {
	Type() Type
	Size() uint64
}

type ArgCommon struct {
	// contains filtered or unexported fields
}

type ArgUsed interface {
	Used() *map[Arg]bool
	Set(map[Arg]bool)
}

type ArgUser interface {
	Uses() *Arg
}

type Args []Arg

type ArrayKind int

type ArrayType struct {
	TypeCommon
	Type       Type
	Kind       ArrayKind
	RangeBegin uint64
	RangeEnd   uint64
}

type BufferKind int

type BufferType struct {
	TypeCommon
	Kind       BufferKind
	RangeBegin uint64   // for BufferBlobRange kind
	RangeEnd   uint64   // for BufferBlobRange kind
	Text       TextKind // for BufferText
	SubKind    string
	Values     []string // possible values for BufferString kind
}

type ByPhysicalAddr struct {
	Args
	Context *execContext
}

type Call struct {
	Meta *Syscall
	Args []Arg
	Ret  Arg
}

type ChoiceTable struct {
	// contains filtered or unexported fields
}

type CompMap map[uint64]uint64Set

type ConstArg struct {
	ArgCommon
	Val uint64
}

type ConstType struct {
	IntTypeCommon
	Val   uint64
	IsPad bool
}

type ConstValue struct {
	Name  string
	Value uint64
}

type CsumChunk struct {
	Kind  CsumChunkKind
	Arg   Arg    // for CsumChunkArg
	Value uint64 // for CsumChunkConst
	Size  uint64 // for CsumChunkConst
}

type CsumChunkKind int

type CsumInfo struct {
	Kind   CsumKind
	Chunks []CsumChunk
}

type CsumKind int

type CsumType struct {
	IntTypeCommon
	Kind     CsumKind
	Buf      string
	Protocol uint64 // for CsumPseudo
}

type DataArg struct {
	ArgCommon
	Data []byte
}

type Dir int

type FlagsType struct {
	IntTypeCommon
	Vals []uint64
}

type Gen struct {
	// contains filtered or unexported fields
}

type GroupArg struct {
	ArgCommon
	Inner []Arg
}

type IntKind int

type IntType struct {
	IntTypeCommon
	Kind       IntKind
	RangeBegin uint64
	RangeEnd   uint64
}

type IntTypeCommon struct {
	TypeCommon
	BitfieldOff uint64
	BitfieldLen uint64
	BigEndian   bool
	BitfieldMdl bool
}

type KeyedStruct struct {
	Key  StructKey
	Desc *StructDesc
}

type LenType struct {
	IntTypeCommon
	ByteSize uint64 // want size in multiple of bytes instead of array size
	Buf      string
}

type LogEntry struct {
	P         *Prog
	Proc      int  // index of parallel proc
	Start     int  // start offset in log
	End       int  // end offset in log
	Fault     bool // program was executed with fault injection in FaultCall/FaultNth
	FaultCall int
	FaultNth  int
}

type PointerArg struct {
	ArgCommon
	PageIndex  uint64
	PageOffset int    // offset within a page
	PagesNum   uint64 // number of available pages
	Res        Arg    // pointee
}

type ProcType struct {
	IntTypeCommon
	ValuesStart   uint64
	ValuesPerProc uint64
}

type Prog struct {
	Target *Target
	Calls  []*Call
}

type PtrType struct {
	TypeCommon
	Type Type
}

type ResourceDesc struct {
	Name   string
	Type   Type
	Kind   []string
	Values []uint64
}

type ResourceType struct {
	TypeCommon
	Desc *ResourceDesc
}

type ResultArg struct {
	ArgCommon
	Res   Arg    // reference to arg which we use
	OpDiv uint64 // divide result (executed before OpAdd)
	OpAdd uint64 // add to result
	Val   uint64 // value used if Res is nil
	// contains filtered or unexported fields
}

type ReturnArg struct {
	ArgCommon
	// contains filtered or unexported fields
}

type StructDesc struct {
	TypeCommon
	Fields    []Type
	AlignAttr uint64
}

type StructKey struct {
	Name string
	Dir  Dir
}

type StructType struct {
	Key     StructKey
	FldName string
	*StructDesc
}

type Syscall struct {
	ID       int
	NR       uint64 // kernel syscall number
	Name     string
	CallName string
	Args     []Type
	Ret      Type
}

type Target struct {
	OS         string
	Arch       string
	Revision   string // unique hash representing revision of the descriptions
	PtrSize    uint64
	PageSize   uint64
	DataOffset uint64

	Syscalls  []*Syscall
	Resources []*ResourceDesc
	Structs   []*KeyedStruct
	Consts    []ConstValue

	// Syscall used by MakeMmap.
	// It has some special meaning because there are usually too many of them.
	MmapSyscall *Syscall

	// MakeMmap creates call that maps [start, start+npages) page range.
	MakeMmap func(start, npages uint64) *Call

	// AnalyzeMmap analyzes the call c regarding mapping/unmapping memory.
	// If it maps/unmaps any memory returns [start, start+npages) range,
	// otherwise returns npages = 0.
	AnalyzeMmap func(c *Call) (start, npages uint64, mapped bool)

	// SanitizeCall neutralizes harmful calls.
	SanitizeCall func(c *Call)

	// SpecialStructs allows target to do custom generation/mutation for some struct types.
	// Map key is struct name for which custom generation/mutation is required.
	// Map value is custom generation/mutation function that will be called
	// for the corresponding structs. g is helper object that allows generate random numbers,
	// allocate memory, etc. typ is the struct type. old is the old value of the struct
	// for mutation, or nil for generation. The function returns a new value of the struct,
	// and optionally any calls that need to be inserted before the arg reference.
	SpecialStructs map[string]func(g *Gen, typ *StructType, old *GroupArg) (Arg, []*Call)

	// Special strings that can matter for the target.
	// Used as fallback when string type does not have own dictionary.
	StringDictionary []string

	// Filled by prog package:
	SyscallMap map[string]*Syscall
	ConstMap   map[string]uint64
	// contains filtered or unexported fields
}

type TextKind int

type Type interface {
	Name() string
	FieldName() string
	Dir() Dir
	Optional() bool
	Default() uint64
	Varlen() bool
	Size() uint64
	BitfieldOffset() uint64
	BitfieldLength() uint64
	BitfieldMiddle() bool // returns true for all but last bitfield in a group
}

type TypeCommon struct {
	TypeName   string
	FldName    string // for struct fields and named args
	TypeSize   uint64 // static size of the type, or 0 for variable size types
	ArgDir     Dir
	IsOptional bool
}

type UnionArg struct {
	ArgCommon
	Option     Arg
	OptionType Type
}

type UnionType struct {
	Key     StructKey
	FldName string
	*StructDesc
}

type VmaType struct {
	TypeCommon
	RangeBegin uint64 // in pages
	RangeEnd   uint64
}