/* $Id: DBGCInternal.h 86105 2020-09-13 08:28:59Z vboxsync $ */ /** @file * DBGC - Debugger Console, Internal Header File. */ /* * Copyright (C) 2006-2020 Oracle Corporation * * This file is part of VirtualBox Open Source Edition (OSE), as * available from http://www.virtualbox.org. This file is free software; * you can redistribute it and/or modify it under the terms of the GNU * General Public License (GPL) as published by the Free Software * Foundation, in version 2 as it comes in the "COPYING" file of the * VirtualBox OSE distribution. VirtualBox OSE is distributed in the * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. */ #ifndef DEBUGGER_INCLUDED_SRC_DBGCInternal_h #define DEBUGGER_INCLUDED_SRC_DBGCInternal_h #ifndef RT_WITHOUT_PRAGMA_ONCE # pragma once #endif /******************************************************************************* * Header Files * *******************************************************************************/ #include #include /******************************************************************************* * Structures and Typedefs * *******************************************************************************/ /** * Debugger console per breakpoint data. */ typedef struct DBGCBP { /** Pointer to the next breakpoint in the list. */ struct DBGCBP *pNext; /** The breakpoint identifier. */ uint32_t iBp; /** The size of the command. */ size_t cchCmd; /** The command to execute when the breakpoint is hit. */ char szCmd[1]; } DBGCBP; /** Pointer to a breakpoint. */ typedef DBGCBP *PDBGCBP; typedef enum DBGCEVTSTATE { kDbgcEvtState_Invalid = 0, kDbgcEvtState_Disabled, kDbgcEvtState_Enabled, kDbgcEvtState_Notify } DBGCEVTSTATE; /** * Debugger console per event configuration. */ typedef struct DBGCEVTCFG { /** The event state. */ DBGCEVTSTATE enmState; /** The size of the command. */ size_t cchCmd; /** The command to execute when the event occurs. */ char szCmd[1]; } DBGCEVTCFG; /** Pointer to a event configuration. */ typedef DBGCEVTCFG *PDBGCEVTCFG; /** Pointer to a const event configuration. */ typedef DBGCEVTCFG const *PCDBGCEVTCFG; /** * Named variable. * * Always allocated from heap in one single block. */ typedef struct DBGCNAMEDVAR { /** The variable. */ DBGCVAR Var; /** Its name. */ char szName[1]; } DBGCNAMEDVAR; /** Pointer to named variable. */ typedef DBGCNAMEDVAR *PDBGCNAMEDVAR; /** * Debugger console status */ typedef enum DBGCSTATUS { /** Normal status, .*/ DBGC_HALTED } DBGCSTATUS; /** * Debugger console instance data. */ typedef struct DBGC { /** Command helpers. */ DBGCCMDHLP CmdHlp; /** Wrappers for DBGF output. */ DBGFINFOHLP DbgfOutputHlp; /** Pointer to backend callback structure. */ PDBGCBACK pBack; /** * Output a bunch of characters. * * @returns VBox status code. * @param pvUser Opaque user data from DBGC::pvOutputUser. * @param pachChars Pointer to an array of utf-8 characters. * @param cbChars Number of bytes in the character array pointed to by pachChars. */ DECLR3CALLBACKMEMBER(int, pfnOutput, (void *pvUser, const char *pachChars, size_t cbChars)); /** Opqaue user data passed to DBGC::pfnOutput. */ void *pvOutputUser; /** Pointer to the current VM. */ PVM pVM; /** The user mode handle of the current VM. */ PUVM pUVM; /** The ID of current virtual CPU. */ VMCPUID idCpu; /** The current address space handle. */ RTDBGAS hDbgAs; /** The current debugger emulation. */ const char *pszEmulation; /** Pointer to the commands for the current debugger emulation. */ PCDBGCCMD paEmulationCmds; /** The number of commands paEmulationCmds points to. */ uint32_t cEmulationCmds; /** Pointer to the functions for the current debugger emulation. */ PCDBGCFUNC paEmulationFuncs; /** The number of functions paEmulationFuncs points to. */ uint32_t cEmulationFuncs; /** Log indicator. (If set we're writing the log to the console.) */ bool fLog; /** Counter use to suppress the printing of the headers. */ uint8_t cPagingHierarchyDumps; /** Indicates whether the register are terse or sparse. */ bool fRegTerse; /** @name Stepping * @{ */ /** Whether to display registers when tracing. */ bool fStepTraceRegs; /** Number of multi-steps left, zero if not multi-stepping. */ uint32_t cMultiStepsLeft; /** The multi-step stride length. */ uint32_t uMultiStepStrideLength; /** The active multi-step command. */ PCDBGCCMD pMultiStepCmd; /** @} */ /** Current disassembler position. */ DBGCVAR DisasmPos; /** The flags that goes with DisasmPos. */ uint32_t fDisasm; /** Current source position. (flat GC) */ DBGCVAR SourcePos; /** Current memory dump position. */ DBGCVAR DumpPos; /** Size of the previous dump element. */ unsigned cbDumpElement; /** Points to DisasmPos, SourcePos or DumpPos depending on which was * used last. */ PCDBGCVAR pLastPos; /** Number of variables in papVars. */ unsigned cVars; /** Array of global variables. * Global variables can be referenced using the $ operator and set * and unset using command with those names. */ PDBGCNAMEDVAR *papVars; /** The list of breakpoints. (singly linked) */ PDBGCBP pFirstBp; /** Software interrupt events. */ PDBGCEVTCFG apSoftInts[256]; /** Hardware interrupt events. */ PDBGCEVTCFG apHardInts[256]; /** Selectable events (first few entries are unused). */ PDBGCEVTCFG apEventCfgs[DBGFEVENT_END]; /** Save search pattern. */ uint8_t abSearch[256]; /** The length of the search pattern. */ uint32_t cbSearch; /** The search unit */ uint32_t cbSearchUnit; /** The max hits. */ uint64_t cMaxSearchHits; /** The address to resume searching from. */ DBGFADDRESS SearchAddr; /** What's left of the original search range. */ RTGCUINTPTR cbSearchRange; /** @name Parsing and Execution * @{ */ /** Input buffer. */ char achInput[2048]; /** To ease debugging. */ unsigned uInputZero; /** Write index in the input buffer. */ unsigned iWrite; /** Read index in the input buffer. */ unsigned iRead; /** The number of lines in the buffer. */ unsigned cInputLines; /** Indicates that we have a buffer overflow condition. * This means that input is ignored up to the next newline. */ bool fInputOverflow; /** Indicates whether or we're ready for input. */ bool fReady; /** Scratch buffer position. */ char *pszScratch; /** Scratch buffer. */ char achScratch[16384]; /** Argument array position. */ unsigned iArg; /** Array of argument variables. */ DBGCVAR aArgs[100]; /** rc from the last dbgcHlpPrintfV(). */ int rcOutput; /** The last character we wrote. */ char chLastOutput; /** rc from the last command. */ int rcCmd; /** @} */ /** The command history file (not yet implemented). */ char *pszHistoryFile; /** The global debugger init script. */ char *pszGlobalInitScript; /** The per VM debugger init script. */ char *pszLocalInitScript; } DBGC; /** Pointer to debugger console instance data. */ typedef DBGC *PDBGC; /** Converts a Command Helper pointer to a pointer to DBGC instance data. */ #define DBGC_CMDHLP2DBGC(pCmdHlp) ( (PDBGC)((uintptr_t)(pCmdHlp) - RT_UOFFSETOF(DBGC, CmdHlp)) ) /** * Chunk of external commands. */ typedef struct DBGCEXTCMDS { /** Number of commands descriptors. */ unsigned cCmds; /** Pointer to array of command descriptors. */ PCDBGCCMD paCmds; /** Pointer to the next chunk. */ struct DBGCEXTCMDS *pNext; } DBGCEXTCMDS; /** Pointer to chunk of external commands. */ typedef DBGCEXTCMDS *PDBGCEXTCMDS; /** * Chunk of external functions. */ typedef struct DBGCEXTFUNCS { /** Number of functions descriptors. */ uint32_t cFuncs; /** Pointer to array of functions descriptors. */ PCDBGCFUNC paFuncs; /** Pointer to the next chunk. */ struct DBGCEXTFUNCS *pNext; } DBGCEXTFUNCS; /** Pointer to chunk of external functions. */ typedef DBGCEXTFUNCS *PDBGCEXTFUNCS; /** * Unary operator handler function. * * @returns 0 on success. * @returns VBox evaluation / parsing error code on failure. * The caller does the bitching. * @param pDbgc Debugger console instance data. * @param pArg The argument. * @param enmCat The desired result category. Can be ignored. * @param pResult Where to store the result. */ typedef DECLCALLBACKTYPE(int, FNDBGCOPUNARY,(PDBGC pDbgc, PCDBGCVAR pArg, DBGCVARCAT enmCat, PDBGCVAR pResult)); /** Pointer to a unary operator handler function. */ typedef FNDBGCOPUNARY *PFNDBGCOPUNARY; /** * Binary operator handler function. * * @returns 0 on success. * @returns VBox evaluation / parsing error code on failure. * The caller does the bitching. * @param pDbgc Debugger console instance data. * @param pArg1 The first argument. * @param pArg2 The 2nd argument. * @param pResult Where to store the result. */ typedef DECLCALLBACKTYPE(int, FNDBGCOPBINARY,(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)); /** Pointer to a binary operator handler function. */ typedef FNDBGCOPBINARY *PFNDBGCOPBINARY; /** * Operator descriptor. */ typedef struct DBGCOP { /** Operator mnemonic. */ char szName[4]; /** Length of name. */ const unsigned cchName; /** Whether or not this is a binary operator. * Unary operators are evaluated right-to-left while binary are left-to-right. */ bool fBinary; /** Precedence level. */ unsigned iPrecedence; /** Unary operator handler. */ PFNDBGCOPUNARY pfnHandlerUnary; /** Binary operator handler. */ PFNDBGCOPBINARY pfnHandlerBinary; /** The category of the 1st argument. * Set to DBGCVAR_CAT_ANY if anything goes. */ DBGCVARCAT enmCatArg1; /** The category of the 2nd argument. * Set to DBGCVAR_CAT_ANY if anything goes. */ DBGCVARCAT enmCatArg2; /** Operator description. */ const char *pszDescription; } DBGCOP; /** Pointer to an operator descriptor. */ typedef DBGCOP *PDBGCOP; /** Pointer to a const operator descriptor. */ typedef const DBGCOP *PCDBGCOP; /** Pointer to symbol descriptor. */ typedef struct DBGCSYM *PDBGCSYM; /** Pointer to const symbol descriptor. */ typedef const struct DBGCSYM *PCDBGCSYM; /** * Get builtin symbol. * * @returns 0 on success. * @returns VBox evaluation / parsing error code on failure. * The caller does the bitching. * @param pSymDesc Pointer to the symbol descriptor. * @param pCmdHlp Pointer to the command callback structure. * @param enmType The result type. * @param pResult Where to store the result. */ typedef DECLCALLBACKTYPE(int, FNDBGCSYMGET,(PCDBGCSYM pSymDesc, PDBGCCMDHLP pCmdHlp, DBGCVARTYPE enmType, PDBGCVAR pResult)); /** Pointer to get function for a builtin symbol. */ typedef FNDBGCSYMGET *PFNDBGCSYMGET; /** * Set builtin symbol. * * @returns 0 on success. * @returns VBox evaluation / parsing error code on failure. * The caller does the bitching. * @param pSymDesc Pointer to the symbol descriptor. * @param pCmdHlp Pointer to the command callback structure. * @param pValue The value to assign the symbol. */ typedef DECLCALLBACKTYPE(int, FNDBGCSYMSET,(PCDBGCSYM pSymDesc, PDBGCCMDHLP pCmdHlp, PCDBGCVAR pValue)); /** Pointer to set function for a builtin symbol. */ typedef FNDBGCSYMSET *PFNDBGCSYMSET; /** * Symbol description (for builtin symbols). */ typedef struct DBGCSYM { /** Symbol name. */ const char *pszName; /** Get function. */ PFNDBGCSYMGET pfnGet; /** Set function. (NULL if readonly) */ PFNDBGCSYMSET pfnSet; /** User data. */ unsigned uUser; } DBGCSYM; /** Selectable debug event kind. */ typedef enum { kDbgcSxEventKind_Plain, kDbgcSxEventKind_Interrupt } DBGCSXEVENTKIND; /** * Selectable debug event name / type lookup table entry. * * This also contains the default setting and an alternative name. */ typedef struct DBGCSXEVT { /** The event type. */ DBGFEVENTTYPE enmType; /** The event name. */ const char *pszName; /** Alternative event name (optional). */ const char *pszAltNm; /** The kind of event. */ DBGCSXEVENTKIND enmKind; /** The default state. */ DBGCEVTSTATE enmDefault; /** Flags, DBGCSXEVT_F_XXX. */ uint32_t fFlags; /** Description for use when reporting the event, optional. */ const char *pszDesc; } DBGCSXEVT; /** Pointer to a constant selectable debug event descriptor. */ typedef DBGCSXEVT const *PCDBGCSXEVT; /** @name DBGCSXEVT_F_XXX * @{ */ #define DBGCSXEVT_F_TAKE_ARG RT_BIT_32(0) /** Windows bugcheck, should take 5 arguments. */ #define DBGCSXEVT_F_BUGCHECK RT_BIT_32(1) /** @} */ /** * Control flow graph basic block dumper state */ typedef struct DBGCFLOWBBDUMP { /** The basic block referenced. */ DBGFFLOWBB hFlowBb; /** Cached start address. */ DBGFADDRESS AddrStart; /** Target address. */ DBGFADDRESS AddrTarget; /** Width of the basic block in chars. */ uint32_t cchWidth; /** Height of the basic block in chars. */ uint32_t cchHeight; /** X coordinate of the start. */ uint32_t uStartX; /** Y coordinate of the start. */ uint32_t uStartY; } DBGCFLOWBBDUMP; /** Pointer to the control flow graph basic block dump state. */ typedef DBGCFLOWBBDUMP *PDBGCFLOWBBDUMP; /** * Control flow graph branch table dumper state. */ typedef struct DBGCFLOWBRANCHTBLDUMP { /** The branch table referenced. */ DBGFFLOWBRANCHTBL hFlowBranchTbl; /** Cached start address. */ DBGFADDRESS AddrStart; /** Width of the branch table in chars. */ uint32_t cchWidth; /** Height of the branch table in chars. */ uint32_t cchHeight; /** X coordinate of the start. */ uint32_t uStartX; /** Y coordinate of the start. */ uint32_t uStartY; } DBGCFLOWBRANCHTBLDUMP; /** Pointer to control flow graph branch table state. */ typedef DBGCFLOWBRANCHTBLDUMP *PDBGCFLOWBRANCHTBLDUMP; /******************************************************************************* * Internal Functions * *******************************************************************************/ int dbgcBpAdd(PDBGC pDbgc, RTUINT iBp, const char *pszCmd); int dbgcBpUpdate(PDBGC pDbgc, RTUINT iBp, const char *pszCmd); int dbgcBpDelete(PDBGC pDbgc, RTUINT iBp); PDBGCBP dbgcBpGet(PDBGC pDbgc, RTUINT iBp); int dbgcBpExec(PDBGC pDbgc, RTUINT iBp); void dbgcEvalInit(void); int dbgcEvalSub(PDBGC pDbgc, char *pszExpr, size_t cchExpr, DBGCVARCAT enmCategory, PDBGCVAR pResult); int dbgcEvalCommand(PDBGC pDbgc, char *pszCmd, size_t cchCmd, bool fNoExecute); int dbgcEvalScript(PDBGC pDbgc, const char *pszFilename, bool fAnnounce); int dbgcSymbolGet(PDBGC pDbgc, const char *pszSymbol, DBGCVARTYPE enmType, PDBGCVAR pResult); PCDBGCSYM dbgcLookupRegisterSymbol(PDBGC pDbgc, const char *pszSymbol); PCDBGCOP dbgcOperatorLookup(PDBGC pDbgc, const char *pszExpr, bool fPreferBinary, char chPrev); PCDBGCCMD dbgcCommandLookup(PDBGC pDbgc, const char *pachName, size_t cchName, bool fExternal); PCDBGCFUNC dbgcFunctionLookup(PDBGC pDbgc, const char *pachName, size_t cchName, bool fExternal); DECLCALLBACK(int) dbgcOpRegister(PDBGC pDbgc, PCDBGCVAR pArg, DBGCVARCAT enmCat, PDBGCVAR pResult); DECLCALLBACK(int) dbgcOpAddrFlat(PDBGC pDbgc, PCDBGCVAR pArg, DBGCVARCAT enmCat, PDBGCVAR pResult); DECLCALLBACK(int) dbgcOpAddrHost(PDBGC pDbgc, PCDBGCVAR pArg, DBGCVARCAT enmCat, PDBGCVAR pResult); DECLCALLBACK(int) dbgcOpAddrPhys(PDBGC pDbgc, PCDBGCVAR pArg, DBGCVARCAT enmCat, PDBGCVAR pResult); DECLCALLBACK(int) dbgcOpAddrHostPhys(PDBGC pDbgc, PCDBGCVAR pArg, DBGCVARCAT enmCat, PDBGCVAR pResult); void dbgcInitCmdHlp(PDBGC pDbgc); void dbgcEventInit(PDBGC pDbgc); void dbgcEventTerm(PDBGC pDbgc); /** Console ASCII screen handle. */ typedef struct DBGCSCREENINT *DBGCSCREEN; /** Pointer to ASCII screen handle. */ typedef DBGCSCREEN *PDBGCSCREEN; /** * ASCII screen blit callback. * * @returns VBox status code. Any non VINF_SUCCESS status code will abort the dumping. * * @param psz The string to dump * @param pvUser Opaque user data. */ typedef DECLCALLBACKTYPE(int, FNDGCSCREENBLIT,(const char *psz, void *pvUser)); /** Pointer to a FNDGCSCREENBLIT. */ typedef FNDGCSCREENBLIT *PFNDGCSCREENBLIT; /** * ASCII screen supported colors. */ typedef enum DBGCSCREENCOLOR { /** Invalid color. */ DBGCSCREENCOLOR_INVALID = 0, /** Default color of the terminal. */ DBGCSCREENCOLOR_DEFAULT, /** Black. */ DBGCSCREENCOLOR_BLACK, DBGCSCREENCOLOR_BLACK_BRIGHT, /** Red. */ DBGCSCREENCOLOR_RED, DBGCSCREENCOLOR_RED_BRIGHT, /** Green. */ DBGCSCREENCOLOR_GREEN, DBGCSCREENCOLOR_GREEN_BRIGHT, /** Yellow. */ DBGCSCREENCOLOR_YELLOW, DBGCSCREENCOLOR_YELLOW_BRIGHT, /** Blue. */ DBGCSCREENCOLOR_BLUE, DBGCSCREENCOLOR_BLUE_BRIGHT, /** Magenta. */ DBGCSCREENCOLOR_MAGENTA, DBGCSCREENCOLOR_MAGENTA_BRIGHT, /** Cyan. */ DBGCSCREENCOLOR_CYAN, DBGCSCREENCOLOR_CYAN_BRIGHT, /** White. */ DBGCSCREENCOLOR_WHITE, DBGCSCREENCOLOR_WHITE_BRIGHT } DBGCSCREENCOLOR; /** Pointer to a screen color. */ typedef DBGCSCREENCOLOR *PDBGCSCREENCOLOR; DECLHIDDEN(int) dbgcScreenAsciiCreate(PDBGCSCREEN phScreen, uint32_t cchWidth, uint32_t cchHeight); DECLHIDDEN(void) dbgcScreenAsciiDestroy(DBGCSCREEN hScreen); DECLHIDDEN(int) dbgcScreenAsciiBlit(DBGCSCREEN hScreen, PFNDGCSCREENBLIT pfnBlit, void *pvUser, bool fAddColors); DECLHIDDEN(int) dbgcScreenAsciiDrawLineVertical(DBGCSCREEN hScreen, uint32_t uX, uint32_t uStartY, uint32_t uEndY, char ch, DBGCSCREENCOLOR enmColor); DECLHIDDEN(int) dbgcScreenAsciiDrawLineHorizontal(DBGCSCREEN hScreen, uint32_t uStartX, uint32_t uEndX, uint32_t uY, char ch, DBGCSCREENCOLOR enmColor); DECLHIDDEN(int) dbgcScreenAsciiDrawCharacter(DBGCSCREEN hScreen, uint32_t uX, uint32_t uY, char ch, DBGCSCREENCOLOR enmColor); DECLHIDDEN(int) dbgcScreenAsciiDrawString(DBGCSCREEN hScreen, uint32_t uX, uint32_t uY, const char *pszText, DBGCSCREENCOLOR enmColor); /* For tstDBGCParser: */ int dbgcCreate(PDBGC *ppDbgc, PDBGCBACK pBack, unsigned fFlags); int dbgcRun(PDBGC pDbgc); int dbgcProcessInput(PDBGC pDbgc, bool fNoExecute); void dbgcDestroy(PDBGC pDbgc); DECLHIDDEN(const char *) dbgcGetEventCtx(DBGFEVENTCTX enmCtx); DECLHIDDEN(PCDBGCSXEVT) dbgcEventLookup(DBGFEVENTTYPE enmType); DECLHIDDEN(int) dbgcGdbStubCreate(PUVM pUVM, PDBGCBACK pBack, unsigned fFlags); DECLHIDDEN(int) dbgcKdStubCreate(PUVM pUVM, PDBGCBACK pBack, unsigned fFlags); /******************************************************************************* * Global Variables * *******************************************************************************/ extern const DBGCCMD g_aDbgcCmds[]; extern const uint32_t g_cDbgcCmds; extern const DBGCFUNC g_aDbgcFuncs[]; extern const uint32_t g_cDbgcFuncs; extern const DBGCCMD g_aCmdsCodeView[]; extern const uint32_t g_cCmdsCodeView; extern const DBGCFUNC g_aFuncsCodeView[]; extern const uint32_t g_cFuncsCodeView; extern const DBGCOP g_aDbgcOps[]; extern const uint32_t g_cDbgcOps; extern const DBGCSXEVT g_aDbgcSxEvents[]; extern const uint32_t g_cDbgcSxEvents; /******************************************************************************* * Defined Constants And Macros * *******************************************************************************/ /** Locks the g_pExtCmdsHead and g_pExtFuncsHead lists for reading. */ #define DBGCEXTLISTS_LOCK_RD() do { } while (0) /** Locks the g_pExtCmdsHead and g_pExtFuncsHead lists for writing. */ #define DBGCEXTLISTS_LOCK_WR() do { } while (0) /** UnLocks the g_pExtCmdsHead and g_pExtFuncsHead lists after reading. */ #define DBGCEXTLISTS_UNLOCK_RD() do { } while (0) /** UnLocks the g_pExtCmdsHead and g_pExtFuncsHead lists after writing. */ #define DBGCEXTLISTS_UNLOCK_WR() do { } while (0) #endif /* !DEBUGGER_INCLUDED_SRC_DBGCInternal_h */