debugger

type Args interface {
	Extract(...any) error
}

type Calling int

type CodeCallback = func(ctx Context, addr, size uint64, data any)

type Context interface {
	Debugger() Debugger
	PC() emulator.Reg
	SP() emulator.Reg
	TaskID() int
	ParentID() int
	TaskFork() (Task, error)
	RegisterContext
	GetArgs(calling Calling) (Args, error)
	ArgExtract(calling Calling, args ...any) error
	ArgWrite(calling Calling, args ...any) error
	RetExtract(val any) error
	RetWrite(val any) error
	Return() error
	Goto(addr uint64) error
	MemoryContext
	StorageContext
}

type ControlCallback = func(ctx Context, data any)

type ControlHandler interface {
	io.Closer
	Addr() uint64
}

type DbgCtor func(emulator.Emulator) (Debugger, error)

type Debugger interface {
	io.Closer
	DebuggerInfo
	MemoryManager
	HookManger
	TaskManager
	ModuleManager
	FileManager
}

type DebuggerInfo interface {
	Emulator() emulator.Emulator
	Arch() emulator.Arch
	PointerSize() uint64
	StackSize() uint64
	StackAlign() uint64
}

type DefaultFileHandler struct {
}

type FileHandler interface {
	OpenFile(name string, flag filesystem.FileFlag, perm fs.FileMode) (filesystem.File, error)
	Stat(name string) (fs.FileInfo, error)
	ReadDir(name string) ([]fs.DirEntry, error)
	Mkdir(name string, perm fs.FileMode) (filesystem.DirFS, error)
	Readlink(name string) (string, error)
	NewSocket(network socket.Network) (socket.Socket, error)
}

type FileManager interface {
	AddFileHandler(handler FileHandler)
	RemoveFileHandler(handler FileHandler)
	CreateFileDescriptor(file filesystem.File) int
	CloseFileDescriptor(fd int) (filesystem.File, error)
	GetFile(fd int) (filesystem.File, error)
	DupFile(fd int) (int, error)
	Dup2File(oldfd, newfd int) error
	GetFS() filesystem.FS
	OpenFile(name string, flag filesystem.FileFlag, perm fs.FileMode) (filesystem.File, error)
	Stat(name string) (fs.FileInfo, error)
	ReadDir(name string) ([]fs.DirEntry, error)
	Mkdir(name string, perm fs.FileMode) (filesystem.DirFS, error)
	Readlink(name string) (string, error)
	NewSocket(network socket.Network) (socket.Socket, error)
}

type HookHandler interface {
	io.Closer
	Type() emulator.HookType
}

type HookManger interface {
	AddHook(typ emulator.HookType, callback any, data any, begin, end uint64) (HookHandler, error)
	AddControl(callback ControlCallback, data any) (ControlHandler, error)
}

type HookResult int

type InterruptCallback = func(ctx Context, intno uint64, data any) HookResult

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

type InvalidCallback = func(ctx Context, data any) HookResult

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

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

type MemoryCallback = func(ctx Context, typ emulator.HookType, addr, size, value uint64, data any) HookResult

type MemoryContext interface {
	ToPointer(addr uint64) emulator.Pointer
}

type MemoryManager interface {
	MemMap(addr, size uint64, prot emulator.MemProt) (emulator.MemRegion, error)
	MemUnmap(addr uint64, size uint64) error
	MemProtect(addr, size uint64, prot emulator.MemProt) error
	MapAlloc(size uint64, prot emulator.MemProt) (emulator.MemRegion, error)
	MapFree(addr uint64, size uint64) error
	MemAlloc(size uint64) (uint64, error)
	MemFree(addr uint64) error
	MemSize(addr uint64) uint64
	ToPointer(addr uint64) emulator.Pointer
	MemImport(val any) ([]uint64, error)
	MemWrite(addr uint64, val any) ([]uint64, error)
	MemExtract(addr uint64, val any) error
	MemBind(p unsafe.Pointer, size uint64) (uint64, error)
	MemUnbind(addr uint64) error
}

type Module interface {
	io.Closer
	Name() string
	Region() (uint64, uint64)
	BaseAddr() uint64
	EntryAddr() uint64
	Init(ctx context.Context) error
	FindSymbol(name string) (uint64, error)
}

type ModuleManager interface {
	Load(module Module)
	Unload(module Module)
	FindModule(name string) (Module, error)
	FindModuleByAddr(addr uint64) (Module, error)
	FindSymbol(name string) (Module, uint64, error)
	GetModule(addr uint64) Module
}

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

type RegisterContext interface {
	StackAlloc(size uint64) (emulator.Pointer, error)
	StackFree(size uint64) error
	emulator.RegisterContext
}

type SimulateException interface {
	error
	Context() Context
}

type StorageContext interface {
	LocalStore(key, val any)
	LocalLoad(key any) (any, bool)
	LocalDelete(key any)
}

type Symbol struct {
	Name  string
	Value uint64
}

type SymbolIter interface {
	Symbols(yield func(Symbol) bool)
}

type Task interface {
	io.Closer
	ID() int
	ParentID() int
	Status() TaskStatus
	Context() Context
	Run() error
	SyncRun() error
	Done() <-chan struct{}
	Err() error
	CancelCause(err error)
	Fork() (Task, error)
}

type TaskManager interface {
	GetMainTask(ctx context.Context) (Task, error)
	CreateTask(ctx context.Context) (Task, error)
	CallTaskOf(task Task, addr uint64) error
}

type TaskStatus int