DBGConsole.cpp@ 5574

Last change on this file since 5574 was 5079, checked in by vboxsync, 17 years ago
Fixed two copy & past bugs.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 342.9 KB

Line
1	/** $Id: DBGConsole.cpp 5079 2007-09-27 14:39:05Z vboxsync $ */
2	/** @file
3	* DBGC - Debugger Console.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 innotek GmbH
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License as published by the Free Software Foundation,
13	* in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14	* distribution. VirtualBox OSE is distributed in the hope that it will
15	* be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/** @page pg_dbgc DBGC - The Debug Console
20	*
21	* The debugger console is a first attempt to make some interactive
22	* debugging facilities for the VirtualBox backend (i.e. the VM). At a later
23	* stage we'll make a fancy gui around this, but for the present a telnet (or
24	* serial terminal) will have to suffice.
25	*
26	* The debugger is only built into the VM with debug builds or when
27	* VBOX_WITH_DEBUGGER is defined. There might be need for \#ifdef'ing on this
28	* define to enable special debugger hooks, but the general approach is to
29	* make generic interfaces. The individual components also can register
30	* external commands, and such code must be within \#ifdef.
31	*
32	*
33	* @section sec_dbgc_op Operation (intentions)
34	*
35	* The console will process commands in a manner similar to the OS/2 and
36	* windows kernel debuggers. This means ';' is a command separator and
37	* that when possible we'll use the same command names as these two uses.
38	*
39	*
40	* @subsection sec_dbg_op_numbers Numbers
41	*
42	* Numbers are hexadecimal unless specified with a prefix indicating
43	* elsewise. Prefixes:
44	* - '0x' - hexadecimal.
45	* - '0i' - decimal
46	* - '0t' - octal.
47	* - '0y' - binary.
48	*
49	*
50	* @subsection sec_dbg_op_address Addressing modes
51	*
52	* - Default is flat. For compatability '%' also means flat.
53	* - Segmented addresses are specified selector:offset.
54	* - Physical addresses are specified using '%%'.
55	* - The default target for the addressing is the guest context, the '#'
56	* will override this and set it to the host.
57	*
58	*
59	* @subsection sec_dbg_op_evalution Evaluation
60	*
61	* As time permits support will be implemented support for a subset of the C
62	* binary operators, starting with '+', '-', '*' and '/'. Support for variables
63	* are provided thru commands 'set' and 'unset' and the unary operator '$'. The
64	* unary '@' operator will indicate function calls. The debugger needs a set of
65	* memory read functions, but we might later extend this to allow registration of
66	* external functions too.
67	*
68	* A special command '?' will then be added which evalutates a given expression
69	* and prints it in all the different formats.
70	*
71	*
72	* @subsection sec_dbg_op_registers Registers
73	*
74	* Registers are addressed using their name. Some registers which have several fields
75	* (like gdtr) will have separate names indicating the different fields. The default
76	* register set is the guest one. To access the hypervisor register one have to
77	* prefix the register names with '.'.
78	*
79	*
80	* @subsection sec_dbg_op_commands Commands
81	*
82	* The commands are all lowercase, case sensitive, and starting with a letter. We will
83	* later add some special commands ('?' for evaulation) and perhaps command classes ('.', '!')
84	*
85	*
86	* @section sec_dbg_tasks Tasks
87	*
88	* To implement DBGT and instrument VMM for basic state inspection and log
89	* viewing, the follwing task must be executed:
90	*
91	* -# Basic threading layer in RT.
92	* -# Basic tcpip server abstration in RT.
93	* -# Write DBGC.
94	* -# Write DBCTCP.
95	* -# Integrate with VMM and the rest.
96	* -# Start writing DBGF (VMM).
97	*/
98
99
100
101
102	/*******************************************************************************
103	* Header Files *
104	*******************************************************************************/
105	#define LOG_GROUP LOG_GROUP_DBGC
106	#include <VBox/dbg.h>
107	#include <VBox/dbgf.h>
108	#include <VBox/vm.h>
109	#include <VBox/vmm.h>
110	#include <VBox/mm.h>
111	#include <VBox/pgm.h>
112	#include <VBox/selm.h>
113	#include <VBox/dis.h>
114	#include <VBox/param.h>
115	#include <VBox/err.h>
116	#include <VBox/log.h>
117
118	#include <iprt/alloc.h>
119	#include <iprt/alloca.h>
120	#include <iprt/string.h>
121	#include <iprt/assert.h>
122	#include <iprt/ctype.h>
123
124	#include <stdlib.h>
125	#include <stdio.h>
126
127	/* to err.h! */
128	#define VERR_DBGC_QUIT (-11999)
129	#define VERR_PARSE_FIRST (-11000)
130	#define VERR_PARSE_TOO_FEW_ARGUMENTS (VERR_PARSE_FIRST - 0)
131	#define VERR_PARSE_TOO_MANY_ARGUMENTS (VERR_PARSE_FIRST - 1)
132	#define VERR_PARSE_ARGUMENT_OVERFLOW (VERR_PARSE_FIRST - 2)
133	#define VERR_PARSE_ARGUMENT_TYPE_MISMATCH (VERR_PARSE_FIRST - 3)
134	#define VERR_PARSE_NO_RANGE_ALLOWED (VERR_PARSE_FIRST - 4)
135	#define VERR_PARSE_UNBALANCED_QUOTE (VERR_PARSE_FIRST - 5)
136	#define VERR_PARSE_UNBALANCED_PARENTHESIS (VERR_PARSE_FIRST - 6)
137	#define VERR_PARSE_EMPTY_ARGUMENT (VERR_PARSE_FIRST - 7)
138	#define VERR_PARSE_UNEXPECTED_OPERATOR (VERR_PARSE_FIRST - 8)
139	#define VERR_PARSE_INVALID_NUMBER (VERR_PARSE_FIRST - 9)
140	#define VERR_PARSE_NUMBER_TOO_BIG (VERR_PARSE_FIRST - 10)
141	#define VERR_PARSE_INVALID_OPERATION (VERR_PARSE_FIRST - 11)
142	#define VERR_PARSE_FUNCTION_NOT_FOUND (VERR_PARSE_FIRST - 12)
143	#define VERR_PARSE_NOT_A_FUNCTION (VERR_PARSE_FIRST - 13)
144	#define VERR_PARSE_NO_MEMORY (VERR_PARSE_FIRST - 14)
145	#define VERR_PARSE_INCORRECT_ARG_TYPE (VERR_PARSE_FIRST - 15)
146	#define VERR_PARSE_VARIABLE_NOT_FOUND (VERR_PARSE_FIRST - 16)
147	#define VERR_PARSE_CONVERSION_FAILED (VERR_PARSE_FIRST - 17)
148	#define VERR_PARSE_NOT_IMPLEMENTED (VERR_PARSE_FIRST - 18)
149	#define VERR_PARSE_BAD_RESULT_TYPE (VERR_PARSE_FIRST - 19)
150	#define VERR_PARSE_WRITEONLY_SYMBOL (VERR_PARSE_FIRST - 20)
151	#define VERR_PARSE_NO_ARGUMENT_MATCH (VERR_PARSE_FIRST - 21)
152	#define VERR_PARSE_LAST (VERR_PARSE_FIRST - 30)
153
154	#define VWRN_DBGC_CMD_PENDING 12000
155	#define VWRN_DBGC_ALREADY_REGISTERED 12001
156	#define VERR_DBGC_COMMANDS_NOT_REGISTERED (-12002)
157	#define VERR_DBGC_BP_NOT_FOUND (-12003)
158	#define VERR_DBGC_BP_EXISTS (-12004)
159	#define VINF_DBGC_BP_NO_COMMAND 12005
160
161
162
163	/*******************************************************************************
164	* Defined Constants And Macros *
165	*******************************************************************************/
166	/** Makes a DBGC variable type pair.
167	* Typically used by binary operators. */
168	#define BINARY_TYPE_PAIR(type1, type2) (type1 \| (type2 << 16))
169
170
171	/*******************************************************************************
172	* Structures and Typedefs *
173	*******************************************************************************/
174
175	/**
176	* Debugger console per breakpoint data.
177	*/
178	typedef struct DBGCBP
179	{
180	/** Pointer to the next breakpoint in the list. */
181	struct DBGCBP *pNext;
182	/** The breakpoint identifier. */
183	RTUINT iBp;
184	/** The size of the command. */
185	size_t cchCmd;
186	/** The command to execute when the breakpoint is hit. */
187	char szCmd[1];
188	} DBGCBP;
189	/** Pointer to a breakpoint. */
190	typedef DBGCBP *PDBGCBP;
191
192
193	/**
194	* Named variable.
195	*
196	* Always allocated from heap in one signle block.
197	*/
198	typedef struct DBGCNAMEDVAR
199	{
200	/** The variable. */
201	DBGCVAR Var;
202	/** It's name. */
203	char szName[1];
204	} DBGCNAMEDVAR;
205	/** Pointer to named variable. */
206	typedef DBGCNAMEDVAR *PDBGCNAMEDVAR;
207
208
209	/**
210	* Debugger console status
211	*/
212	typedef enum DBGCSTATUS
213	{
214	/** Normal status, .*/
215	DBGC_HALTED
216
217	} DBGCSTATUS;
218
219
220	/**
221	* Debugger console instance data.
222	*/
223	typedef struct DBGC
224	{
225	/** Command helpers. */
226	DBGCCMDHLP CmdHlp;
227	/** Pointer to backend callback structure. */
228	PDBGCBACK pBack;
229	/** Log indicator. (If set we're writing the log to the console.) */
230	bool fLog;
231	/** Pointer to the current VM. */
232	PVM pVM;
233	/** Indicates whether or we're ready for input. */
234	bool fReady;
235
236	/** Indicates whether we're in guest (true) or hypervisor (false) register context. */
237	bool fRegCtxGuest;
238	/** Indicates whether the register are terse or sparse. */
239	bool fRegTerse;
240
241	/** Input buffer. */
242	char achInput[2048];
243	/** To ease debugging. */
244	unsigned uInputZero;
245	/** Write index in the input buffer. */
246	unsigned iWrite;
247	/** Read index in the input buffer. */
248	unsigned iRead;
249	/** The number of lines in the buffer. */
250	unsigned cInputLines;
251	/** Indicates that we have a buffer overflow condition.
252	* This means that input is ignored up to the next newline. */
253	bool fInputOverflow;
254
255	/** Scratch buffer position. */
256	char *pszScratch;
257	/** Scratch buffer. */
258	char achScratch[16384];
259	/** Argument array position. */
260	unsigned iArg;
261	/** Array of argument variables. */
262	DBGCVAR aArgs[100];
263
264	/** rc from last dbgcHlpPrintfV(). */
265	int rcOutput;
266
267	/** Number of variables in papVars. */
268	unsigned cVars;
269	/** Array of global variables.
270	* Global variables can be referenced using the $ operator and set
271	* and unset using command with those names. */
272	PDBGCNAMEDVAR *papVars;
273
274	/** Current dissassembler position. */
275	DBGCVAR DisasmPos;
276	/** Current source position. (flat GC) */
277	DBGCVAR SourcePos;
278	/** Current memory dump position. */
279	DBGCVAR DumpPos;
280	/** Size of the previous dump element. */
281	unsigned cbDumpElement;
282
283	/** The list of breakpoints. (singly linked) */
284	PDBGCBP pFirstBp;
285	} DBGC;
286	/** Pointer to debugger console instance data. */
287	typedef DBGC *PDBGC;
288
289	/** Converts a Command Helper pointer to a pointer to DBGC instance data. */
290	#define DBGC_CMDHLP2DBGC(pCmdHlp) ( (PDBGC)((uintptr_t)(pCmdHlp) - RT_OFFSETOF(DBGC, CmdHlp)) )
291
292
293	/**
294	* Chunk of external commands.
295	*/
296	typedef struct DBGCEXTCMDS
297	{
298	/** Number of commands descriptors. */
299	unsigned cCmds;
300	/** Pointer to array of command descriptors. */
301	PCDBGCCMD paCmds;
302	/** Pointer to the next chunk. */
303	struct DBGCEXTCMDS *pNext;
304	} DBGCEXTCMDS;
305	/** Pointer to chunk of external commands. */
306	typedef DBGCEXTCMDS *PDBGCEXTCMDS;
307
308
309
310	/**
311	* Unary operator handler function.
312	*
313	* @returns 0 on success.
314	* @returns VBox evaluation / parsing error code on failure.
315	* The caller does the bitching.
316	* @param pDbgc Debugger console instance data.
317	* @param pArg The argument.
318	* @param pResult Where to store the result.
319	*/
320	typedef DECLCALLBACK(int) FNDBGCOPUNARY(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult);
321	/** Pointer to a unary operator handler function. */
322	typedef FNDBGCOPUNARY *PFNDBGCOPUNARY;
323
324
325	/**
326	* Binary operator handler function.
327	*
328	* @returns 0 on success.
329	* @returns VBox evaluation / parsing error code on failure.
330	* The caller does the bitching.
331	* @param pDbgc Debugger console instance data.
332	* @param pArg1 The first argument.
333	* @param pArg2 The 2nd argument.
334	* @param pResult Where to store the result.
335	*/
336	typedef DECLCALLBACK(int) FNDBGCOPBINARY(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
337	/** Pointer to a binary operator handler function. */
338	typedef FNDBGCOPBINARY *PFNDBGCOPBINARY;
339
340
341	/**
342	* Operator descriptor.
343	*/
344	typedef struct DBGCOP
345	{
346	/** Operator mnemonic. */
347	char szName[4];
348	/** Length of name. */
349	const unsigned cchName;
350	/** Whether or not this is a binary operator.
351	* Unary operators are evaluated right-to-left while binary are left-to-right. */
352	bool fBinary;
353	/** Precedence level. */
354	unsigned iPrecedence;
355	/** Unary operator handler. */
356	PFNDBGCOPUNARY pfnHandlerUnary;
357	/** Binary operator handler. */
358	PFNDBGCOPBINARY pfnHandlerBinary;
359	/** Operator description. */
360	const char *pszDescription;
361	} DBGCOP;
362	/** Pointer to an operator descriptor. */
363	typedef DBGCOP *PDBGCOP;
364	/** Pointer to a const operator descriptor. */
365	typedef const DBGCOP *PCDBGCOP;
366
367
368
369	/** Pointer to symbol descriptor. */
370	typedef struct DBGCSYM *PDBGCSYM;
371	/** Pointer to const symbol descriptor. */
372	typedef const struct DBGCSYM *PCDBGCSYM;
373
374	/**
375	* Get builtin symbol.
376	*
377	* @returns 0 on success.
378	* @returns VBox evaluation / parsing error code on failure.
379	* The caller does the bitching.
380	* @param pSymDesc Pointer to the symbol descriptor.
381	* @param pCmdHlp Pointer to the command callback structure.
382	* @param enmType The result type.
383	* @param pResult Where to store the result.
384	*/
385	typedef DECLCALLBACK(int) FNDBGCSYMGET(PCDBGCSYM pSymDesc, PDBGCCMDHLP pCmdHlp, DBGCVARTYPE enmType, PDBGCVAR pResult);
386	/** Pointer to get function for a builtin symbol. */
387	typedef FNDBGCSYMGET *PFNDBGCSYMGET;
388
389	/**
390	* Set builtin symbol.
391	*
392	* @returns 0 on success.
393	* @returns VBox evaluation / parsing error code on failure.
394	* The caller does the bitching.
395	* @param pSymDesc Pointer to the symbol descriptor.
396	* @param pCmdHlp Pointer to the command callback structure.
397	* @param pValue The value to assign the symbol.
398	*/
399	typedef DECLCALLBACK(int) FNDBGCSYMSET(PCDBGCSYM pSymDesc, PDBGCCMDHLP pCmdHlp, PCDBGCVAR pValue);
400	/** Pointer to set function for a builtin symbol. */
401	typedef FNDBGCSYMSET *PFNDBGCSYMSET;
402
403
404	/**
405	* Symbol description (for builtin symbols).
406	*/
407	typedef struct DBGCSYM
408	{
409	/** Symbol name. */
410	const char *pszName;
411	/** Get function. */
412	PFNDBGCSYMGET pfnGet;
413	/** Set function. (NULL if readonly) */
414	PFNDBGCSYMSET pfnSet;
415	/** User data. */
416	unsigned uUser;
417	} DBGCSYM;
418
419
420	/*******************************************************************************
421	* Internal Functions *
422	*******************************************************************************/
423	static DECLCALLBACK(int) dbgcCmdBrkAccess(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
424	static DECLCALLBACK(int) dbgcCmdBrkClear(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
425	static DECLCALLBACK(int) dbgcCmdBrkDisable(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
426	static DECLCALLBACK(int) dbgcCmdBrkEnable(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
427	static DECLCALLBACK(int) dbgcCmdBrkList(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
428	static DECLCALLBACK(int) dbgcCmdBrkSet(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
429	static DECLCALLBACK(int) dbgcCmdBrkREM(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
430	static DECLCALLBACK(int) dbgcCmdHelp(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
431	static DECLCALLBACK(int) dbgcCmdQuit(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
432	static DECLCALLBACK(int) dbgcCmdGo(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
433	static DECLCALLBACK(int) dbgcCmdStop(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
434	static DECLCALLBACK(int) dbgcCmdDisasm(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
435	static DECLCALLBACK(int) dbgcCmdSource(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
436	static DECLCALLBACK(int) dbgcCmdReg(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
437	static DECLCALLBACK(int) dbgcCmdRegGuest(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
438	static DECLCALLBACK(int) dbgcCmdRegHyper(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
439	static DECLCALLBACK(int) dbgcCmdRegTerse(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
440	static DECLCALLBACK(int) dbgcCmdTrace(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
441	static DECLCALLBACK(int) dbgcCmdStack(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
442	static DECLCALLBACK(int) dbgcCmdDumpDT(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
443	static DECLCALLBACK(int) dbgcCmdDumpIDT(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
444	static DECLCALLBACK(int) dbgcCmdDumpMem(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
445	static DECLCALLBACK(int) dbgcCmdDumpPageDir(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
446	static DECLCALLBACK(int) dbgcCmdDumpPageDirBoth(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
447	static DECLCALLBACK(int) dbgcCmdDumpPageTable(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
448	static DECLCALLBACK(int) dbgcCmdDumpPageTableBoth(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
449	static DECLCALLBACK(int) dbgcCmdDumpTSS(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
450	static DECLCALLBACK(int) dbgcCmdInfo(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
451	static DECLCALLBACK(int) dbgcCmdLog(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
452	static DECLCALLBACK(int) dbgcCmdLogDest(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
453	static DECLCALLBACK(int) dbgcCmdLogFlags(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
454	static DECLCALLBACK(int) dbgcCmdMemoryInfo(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
455	static DECLCALLBACK(int) dbgcCmdFormat(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
456	static DECLCALLBACK(int) dbgcCmdListNear(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
457	static DECLCALLBACK(int) dbgcCmdLoadSyms(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
458	static DECLCALLBACK(int) dbgcCmdSet(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
459	static DECLCALLBACK(int) dbgcCmdUnset(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
460	static DECLCALLBACK(int) dbgcCmdLoadVars(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
461	static DECLCALLBACK(int) dbgcCmdShowVars(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
462	static DECLCALLBACK(int) dbgcCmdHarakiri(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
463	static DECLCALLBACK(int) dbgcCmdEcho(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
464	static DECLCALLBACK(int) dbgcCmdRunScript(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
465
466	static DECLCALLBACK(int) dbgcOpMinus(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult);
467	static DECLCALLBACK(int) dbgcOpPluss(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult);
468	static DECLCALLBACK(int) dbgcOpBooleanNot(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult);
469	static DECLCALLBACK(int) dbgcOpBitwiseNot(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult);
470	static DECLCALLBACK(int) dbgcOpAddrFlat(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult);
471	static DECLCALLBACK(int) dbgcOpAddrPhys(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult);
472	static DECLCALLBACK(int) dbgcOpAddrHost(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult);
473	static DECLCALLBACK(int) dbgcOpAddrHostPhys(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult);
474	static DECLCALLBACK(int) dbgcOpVar(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult);
475
476	static DECLCALLBACK(int) dbgcOpAddrFar(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
477	static DECLCALLBACK(int) dbgcOpMult(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
478	static DECLCALLBACK(int) dbgcOpDiv(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
479	static DECLCALLBACK(int) dbgcOpMod(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
480	static DECLCALLBACK(int) dbgcOpAdd(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
481	static DECLCALLBACK(int) dbgcOpSub(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
482	static DECLCALLBACK(int) dbgcOpBitwiseShiftLeft(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
483	static DECLCALLBACK(int) dbgcOpBitwiseShiftRight(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
484	static DECLCALLBACK(int) dbgcOpBitwiseAnd(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
485	static DECLCALLBACK(int) dbgcOpBitwiseXor(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
486	static DECLCALLBACK(int) dbgcOpBitwiseOr(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
487	static DECLCALLBACK(int) dbgcOpBooleanAnd(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
488	static DECLCALLBACK(int) dbgcOpBooleanOr(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
489	static DECLCALLBACK(int) dbgcOpRangeLength(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
490	static DECLCALLBACK(int) dbgcOpRangeLengthBytes(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
491	static DECLCALLBACK(int) dbgcOpRangeTo(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
492
493	static DECLCALLBACK(int) dbgcSymGetReg(PCDBGCSYM pSymDesc, PDBGCCMDHLP pCmdHlp, DBGCVARTYPE enmType, PDBGCVAR pResult);
494	static DECLCALLBACK(int) dbgcSymSetReg(PCDBGCSYM pSymDesc, PDBGCCMDHLP pCmdHlp, PCDBGCVAR pValue);
495
496	static void dbgcVarSetGCFlat(PDBGCVAR pVar, RTGCPTR GCFlat);
497	static void dbgcVarSetGCFlatByteRange(PDBGCVAR pVar, RTGCPTR GCFlat, uint64_t cb);
498	static void dbgcVarSetVar(PDBGCVAR pVar, PCDBGCVAR pVar2);
499	static void dbgcVarSetNoRange(PDBGCVAR pVar);
500	static void dbgcVarSetByteRange(PDBGCVAR pVar, uint64_t cb);
501	static int dbgcVarToDbgfAddr(PDBGC pDbgc, PCDBGCVAR pVar, PDBGFADDRESS pAddress);
502
503	static int dbgcBpAdd(PDBGC pDbgc, RTUINT iBp, const char *pszCmd);
504	static int dbgcBpUpdate(PDBGC pDbgc, RTUINT iBp, const char *pszCmd);
505	static int dbgcBpDelete(PDBGC pDbgc, RTUINT iBp);
506	static PDBGCBP dbgcBpGet(PDBGC pDbgc, RTUINT iBp);
507	static int dbgcBpExec(PDBGC pDbgc, RTUINT iBp);
508
509	static PCDBGCSYM dbgcLookupRegisterSymbol(PDBGC pDbgc, const char *pszSymbol);
510	static int dbgcSymbolGet(PDBGC pDbgc, const char *pszSymbol, DBGCVARTYPE enmType, PDBGCVAR pResult);
511	static int dbgcEvalSub(PDBGC pDbgc, char *pszExpr, size_t cchExpr, PDBGCVAR pResult);
512	static int dbgcProcessCommand(PDBGC pDbgc, char *pszCmd, size_t cchCmd);
513
514
515	/*******************************************************************************
516	* Global Variables *
517	*******************************************************************************/
518	/**
519	* Pointer to head of the list of external commands.
520	*/
521	static PDBGCEXTCMDS g_pExtCmdsHead; /** @todo rw protect g_pExtCmdsHead! */
522	/** Locks the g_pExtCmdsHead list for reading. */
523	#define DBGCEXTCMDS_LOCK_RD() do { } while (0)
524	/** Locks the g_pExtCmdsHead list for writing. */
525	#define DBGCEXTCMDS_LOCK_WR() do { } while (0)
526	/** UnLocks the g_pExtCmdsHead list after reading. */
527	#define DBGCEXTCMDS_UNLOCK_RD() do { } while (0)
528	/** UnLocks the g_pExtCmdsHead list after writing. */
529	#define DBGCEXTCMDS_UNLOCK_WR() do { } while (0)
530
531
532	/** One argument of any kind. */
533	static const DBGCVARDESC g_aArgAny[] =
534	{
535	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
536	{ 0, 1, DBGCVAR_CAT_ANY, 0, "var", "Any type of argument." },
537	};
538
539	/** Multiple string arguments (min 1). */
540	static const DBGCVARDESC g_aArgMultiStr[] =
541	{
542	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
543	{ 1, ~0, DBGCVAR_CAT_STRING, 0, "strings", "One or more strings." },
544	};
545
546	/** Filename string. */
547	static const DBGCVARDESC g_aArgFilename[] =
548	{
549	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
550	{ 1, 1, DBGCVAR_CAT_STRING, 0, "path", "Filename string." },
551	};
552
553
554	/** 'ba' arguments. */
555	static const DBGCVARDESC g_aArgBrkAcc[] =
556	{
557	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
558	{ 1, 1, DBGCVAR_CAT_STRING, 0, "access", "The access type: x=execute, rw=read/write (alias r), w=write, i=not implemented." },
559	{ 1, 1, DBGCVAR_CAT_NUMBER, 0, "size", "The access size: 1, 2, 4, or 8. 'x' access requires 1, and 8 requires amd64 long mode." },
560	{ 1, 1, DBGCVAR_CAT_GC_POINTER, 0, "address", "The address." },
561	{ 0, 1, DBGCVAR_CAT_NUMBER, 0, "passes", "The number of passes before we trigger the breakpoint. (0 is default)" },
562	{ 0, 1, DBGCVAR_CAT_NUMBER, DBGCVD_FLAGS_DEP_PREV, "max passes", "The number of passes after which we stop triggering the breakpoint. (~0 is default)" },
563	{ 0, 1, DBGCVAR_CAT_STRING, 0, "cmds", "String of commands to be executed when the breakpoint is hit. Quote it!" },
564	};
565
566
567	/** 'bc', 'bd', 'be' arguments. */
568	static const DBGCVARDESC g_aArgBrks[] =
569	{
570	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
571	{ 0, ~0, DBGCVAR_CAT_NUMBER, 0, "#bp", "Breakpoint number." },
572	{ 0, 1, DBGCVAR_CAT_STRING, 0, "all", "All breakpoints." },
573	};
574
575
576	/** 'bp' arguments. */
577	static const DBGCVARDESC g_aArgBrkSet[] =
578	{
579	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
580	{ 1, 1, DBGCVAR_CAT_GC_POINTER, 0, "address", "The address." },
581	{ 0, 1, DBGCVAR_CAT_NUMBER, 0, "passes", "The number of passes before we trigger the breakpoint. (0 is default)" },
582	{ 0, 1, DBGCVAR_CAT_NUMBER, DBGCVD_FLAGS_DEP_PREV, "max passes", "The number of passes after which we stop triggering the breakpoint. (~0 is default)" },
583	{ 0, 1, DBGCVAR_CAT_STRING, 0, "cmds", "String of commands to be executed when the breakpoint is hit. Quote it!" },
584	};
585
586
587	/** 'br' arguments. */
588	static const DBGCVARDESC g_aArgBrkREM[] =
589	{
590	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
591	{ 1, 1, DBGCVAR_CAT_GC_POINTER, 0, "address", "The address." },
592	{ 0, 1, DBGCVAR_CAT_NUMBER, 0, "passes", "The number of passes before we trigger the breakpoint. (0 is default)" },
593	{ 0, 1, DBGCVAR_CAT_NUMBER, DBGCVD_FLAGS_DEP_PREV, "max passes", "The number of passes after which we stop triggering the breakpoint. (~0 is default)" },
594	{ 0, 1, DBGCVAR_CAT_STRING, 0, "cmds", "String of commands to be executed when the breakpoint is hit. Quote it!" },
595	};
596
597
598	/** 'd?' arguments. */
599	static const DBGCVARDESC g_aArgDumpMem[] =
600	{
601	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
602	{ 0, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address where to start dumping memory." },
603	};
604
605
606	/** 'dg', 'dga', 'dl', 'dla' arguments. */
607	static const DBGCVARDESC g_aArgDumpDT[] =
608	{
609	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
610	{ 0, ~0, DBGCVAR_CAT_NUMBER, 0, "sel", "Selector or selector range." },
611	{ 0, ~0, DBGCVAR_CAT_POINTER, 0, "address", "Far address which selector should be dumped." },
612	};
613
614
615	/** 'di', 'dia' arguments. */
616	static const DBGCVARDESC g_aArgDumpIDT[] =
617	{
618	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
619	{ 0, ~0, DBGCVAR_CAT_NUMBER, 0, "int", "The interrupt vector or interrupt vector range." },
620	};
621
622
623	/** 'dpd' arguments. /
624	static const DBGCVARDESC g_aArgDumpPD[] =
625	{
626	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
627	{ 0, 1, DBGCVAR_CAT_NUMBER, 0, "index", "Index into the page directory." },
628	{ 0, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address which page directory entry to start dumping from. Range is applied to the page directory." },
629	};
630
631
632	/** 'dpda' arguments. */
633	static const DBGCVARDESC g_aArgDumpPDAddr[] =
634	{
635	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
636	{ 0, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address of the page directory entry to start dumping from." },
637	};
638
639
640	/** 'dpt?' arguments. */
641	static const DBGCVARDESC g_aArgDumpPT[] =
642	{
643	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
644	{ 1, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address which page directory entry to start dumping from." },
645	};
646
647
648	/** 'dpta' arguments. */
649	static const DBGCVARDESC g_aArgDumpPTAddr[] =
650	{
651	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
652	{ 1, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address of the page table entry to start dumping from." },
653	};
654
655
656	/** 'dt' arguments. */
657	static const DBGCVARDESC g_aArgDumpTSS[] =
658	{
659	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
660	{ 0, 1, DBGCVAR_CAT_NUMBER, 0, "tss", "TSS selector number." },
661	{ 0, 1, DBGCVAR_CAT_POINTER, 0, "tss:ign\|addr", "TSS address. If the selector is a TSS selector, the offset will be ignored." }
662	};
663
664
665	/** 'help' arguments. */
666	static const DBGCVARDESC g_aArgHelp[] =
667	{
668	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
669	{ 0, ~0, DBGCVAR_CAT_STRING, 0, "cmd/op", "Zero or more command or operator names." },
670	};
671
672
673	/** 'info' arguments. */
674	static const DBGCVARDESC g_aArgInfo[] =
675	{
676	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
677	{ 1, 1, DBGCVAR_CAT_STRING, 0, "info", "The name of the info to display." },
678	{ 0, 1, DBGCVAR_CAT_STRING, 0, "args", "String arguments to the handler." },
679	};
680
681
682
683	/** 'ln' arguments. */
684	static const DBGCVARDESC g_aArgListNear[] =
685	{
686	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
687	{ 0, ~0, DBGCVAR_CAT_POINTER, 0, "address", "Address of the symbol to look up." },
688	{ 0, ~0, DBGCVAR_CAT_SYMBOL, 0, "symbol", "Symbol to lookup." },
689	};
690
691	/** 'ln' return. */
692	static const DBGCVARDESC g_RetListNear =
693	{
694	1, 1, DBGCVAR_CAT_POINTER, 0, "address", "The last resolved symbol/address with adjusted range."
695	};
696
697
698	/** loadsyms arguments. */
699	static const DBGCVARDESC g_aArgLoadSyms[] =
700	{
701	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
702	{ 1, 1, DBGCVAR_CAT_STRING, 0, "path", "Filename string." },
703	{ 0, 1, DBGCVAR_CAT_NUMBER, 0, "delta", "Delta to add to the loaded symbols. (optional)" },
704	{ 0, 1, DBGCVAR_CAT_STRING, 0, "module name", "Module name." },
705	{ 0, 1, DBGCVAR_CAT_POINTER, DBGCVD_FLAGS_DEP_PREV, "module address", "Module address." },
706	{ 0, 1, DBGCVAR_CAT_NUMBER, 0, "module size", "The module size. (optional)" },
707	};
708
709
710	/** log arguments. */
711	static const DBGCVARDESC g_aArgLog[] =
712	{
713	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
714	{ 1, 1, DBGCVAR_CAT_STRING, 0, "groups", "Group modifier string (quote it!)." }
715	};
716
717
718	/** logdest arguments. */
719	static const DBGCVARDESC g_aArgLogDest[] =
720	{
721	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
722	{ 1, 1, DBGCVAR_CAT_STRING, 0, "dests", "Destination modifier string (quote it!)." }
723	};
724
725
726	/** logflags arguments. */
727	static const DBGCVARDESC g_aArgLogFlags[] =
728	{
729	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
730	{ 1, 1, DBGCVAR_CAT_STRING, 0, "flags", "Flag modifier string (quote it!)." }
731	};
732
733
734	/** 'm' argument. */
735	static const DBGCVARDESC g_aArgMemoryInfo[] =
736	{
737	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
738	{ 1, 1, DBGCVAR_CAT_POINTER, 0, "address", "Pointer to obtain info about." },
739	};
740
741
742	/** 'r' arguments. */
743	static const DBGCVARDESC g_aArgReg[] =
744	{
745	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
746	{ 0, 1, DBGCVAR_CAT_SYMBOL, 0, "register", "Register to show or set." },
747	{ 0, 1, DBGCVAR_CAT_NUMBER_NO_RANGE, DBGCVD_FLAGS_DEP_PREV, "value", "New register value." },
748	};
749
750
751	/** 's' arguments. */
752	static const DBGCVARDESC g_aArgSource[] =
753	{
754	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
755	{ 0, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address where to start looking for source lines." },
756	};
757
758
759	/** 'set' arguments */
760	static const DBGCVARDESC g_aArgSet[] =
761	{
762	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
763	{ 1, 1, DBGCVAR_CAT_STRING, 0, "var", "Variable name." },
764	{ 1, 1, DBGCVAR_CAT_ANY, 0, "value", "Value to assign to the variable." },
765	};
766
767
768	/** 'u' arguments. */
769	static const DBGCVARDESC g_aArgDisasm[] =
770	{
771	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
772	{ 0, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address where to start disassembling." },
773	};
774
775
776
777
778
779	/** Command descriptors. */
780	static const DBGCCMD g_aCmds[] =
781	{
782	/* pszCmd, cArgsMin, cArgsMax, paArgDescs, cArgDescs, pResultDesc, fFlags, pfnHandler pszSyntax, ....pszDescription */
783	{ "ba", 3, 6, &g_aArgBrkAcc[0], ELEMENTS(g_aArgBrkAcc), NULL, 0, dbgcCmdBrkAccess, "<access> <size> <address> [passes [max passes]] [cmds]",
784	"Sets a data access breakpoint." },
785	{ "bc", 1, ~0, &g_aArgBrks[0], ELEMENTS(g_aArgBrks), NULL, 0, dbgcCmdBrkClear, "all \| <bp#> [bp# []]", "Enabled a set of breakpoints." },
786	{ "bd", 1, ~0, &g_aArgBrks[0], ELEMENTS(g_aArgBrks), NULL, 0, dbgcCmdBrkDisable, "all \| <bp#> [bp# []]", "Disables a set of breakpoints." },
787	{ "be", 1, ~0, &g_aArgBrks[0], ELEMENTS(g_aArgBrks), NULL, 0, dbgcCmdBrkEnable, "all \| <bp#> [bp# []]", "Enabled a set of breakpoints." },
788	{ "bl", 0, 0, NULL, 0, NULL, 0, dbgcCmdBrkList, "", "Lists all the breakpoints." },
789	{ "bp", 1, 4, &g_aArgBrkSet[0], ELEMENTS(g_aArgBrkSet), NULL, 0, dbgcCmdBrkSet, "<address> [passes [max passes]] [cmds]",
790	"Sets a breakpoint (int 3)." },
791	{ "br", 1, 4, &g_aArgBrkREM[0], ELEMENTS(g_aArgBrkREM), NULL, 0, dbgcCmdBrkREM, "<address> [passes [max passes]] [cmds]",
792	"Sets a recompiler specific breakpoint." },
793	{ "bye", 0, 0, NULL, 0, NULL, 0, dbgcCmdQuit, "", "Exits the debugger." },
794	{ "d", 0, 1, &g_aArgDumpMem[0], ELEMENTS(g_aArgDumpMem), NULL, 0, dbgcCmdDumpMem, "[addr]", "Dump memory using last element size." },
795	{ "da", 0, 1, &g_aArgDumpMem[0], ELEMENTS(g_aArgDumpMem), NULL, 0, dbgcCmdDumpMem, "[addr]", "Dump memory as ascii string." },
796	{ "db", 0, 1, &g_aArgDumpMem[0], ELEMENTS(g_aArgDumpMem), NULL, 0, dbgcCmdDumpMem, "[addr]", "Dump memory in bytes." },
797	{ "dd", 0, 1, &g_aArgDumpMem[0], ELEMENTS(g_aArgDumpMem), NULL, 0, dbgcCmdDumpMem, "[addr]", "Dump memory in double words." },
798	{ "dg", 0, ~0, &g_aArgDumpDT[0], ELEMENTS(g_aArgDumpDT), NULL, 0, dbgcCmdDumpDT, "[sel [..]]", "Dump the global descriptor table (GDT)." },
799	{ "dga", 0, ~0, &g_aArgDumpDT[0], ELEMENTS(g_aArgDumpDT), NULL, 0, dbgcCmdDumpDT, "[sel [..]]", "Dump the global descriptor table (GDT) including not-present entries." },
800	{ "di", 0, ~0, &g_aArgDumpIDT[0], ELEMENTS(g_aArgDumpIDT), NULL, 0, dbgcCmdDumpIDT, "[int [..]]", "Dump the interrupt descriptor table (IDT)." },
801	{ "dia", 0, ~0, &g_aArgDumpIDT[0], ELEMENTS(g_aArgDumpIDT), NULL, 0, dbgcCmdDumpIDT, "[int [..]]", "Dump the interrupt descriptor table (IDT) including not-present entries." },
802	{ "dl", 0, ~0, &g_aArgDumpDT[0], ELEMENTS(g_aArgDumpDT), NULL, 0, dbgcCmdDumpDT, "[sel [..]]", "Dump the local descriptor table (LDT)." },
803	{ "dla", 0, ~0, &g_aArgDumpDT[0], ELEMENTS(g_aArgDumpDT), NULL, 0, dbgcCmdDumpDT, "[sel [..]]", "Dump the local descriptor table (LDT) including not-present entries." },
804	{ "dpd", 0, 1, &g_aArgDumpPD[0], ELEMENTS(g_aArgDumpPD), NULL, 0, dbgcCmdDumpPageDir, "[addr] [index]", "Dumps page directory entries of the default context." },
805	{ "dpda", 0, 1, &g_aArgDumpPDAddr[0],ELEMENTS(g_aArgDumpPDAddr),NULL, 0, dbgcCmdDumpPageDir, "[addr]", "Dumps specified page directory." },
806	{ "dpdb", 1, 1, &g_aArgDumpPD[0], ELEMENTS(g_aArgDumpPD), NULL, 0, dbgcCmdDumpPageDirBoth, "[addr] [index]", "Dumps page directory entries of the guest and the hypervisor. " },
807	{ "dpdg", 0, 1, &g_aArgDumpPD[0], ELEMENTS(g_aArgDumpPD), NULL, 0, dbgcCmdDumpPageDir, "[addr] [index]", "Dumps page directory entries of the guest." },
808	{ "dpdh", 0, 1, &g_aArgDumpPD[0], ELEMENTS(g_aArgDumpPD), NULL, 0, dbgcCmdDumpPageDir, "[addr] [index]", "Dumps page directory entries of the hypervisor. " },
809	{ "dpt", 1, 1, &g_aArgDumpPT[0], ELEMENTS(g_aArgDumpPT), NULL, 0, dbgcCmdDumpPageTable,"<addr>", "Dumps page table entries of the default context." },
810	{ "dpta", 1, 1, &g_aArgDumpPTAddr[0],ELEMENTS(g_aArgDumpPTAddr), NULL, 0, dbgcCmdDumpPageTable,"<addr>", "Dumps specified page table." },
811	{ "dptb", 1, 1, &g_aArgDumpPT[0], ELEMENTS(g_aArgDumpPT), NULL, 0, dbgcCmdDumpPageTableBoth,"<addr>", "Dumps page table entries of the guest and the hypervisor." },
812	{ "dptg", 1, 1, &g_aArgDumpPT[0], ELEMENTS(g_aArgDumpPT), NULL, 0, dbgcCmdDumpPageTable,"<addr>", "Dumps page table entries of the guest." },
813	{ "dpth", 1, 1, &g_aArgDumpPT[0], ELEMENTS(g_aArgDumpPT), NULL, 0, dbgcCmdDumpPageTable,"<addr>", "Dumps page table entries of the hypervisor." },
814	{ "dq", 0, 1, &g_aArgDumpMem[0], ELEMENTS(g_aArgDumpMem), NULL, 0, dbgcCmdDumpMem, "[addr]", "Dump memory in quad words." },
815	{ "dt", 0, 1, &g_aArgDumpTSS[0], ELEMENTS(g_aArgDumpTSS), NULL, 0, dbgcCmdDumpTSS, "[tss\|tss:ign\|addr]", "Dump the task state segment (TSS)." },
816	{ "dw", 0, 1, &g_aArgDumpMem[0], ELEMENTS(g_aArgDumpMem), NULL, 0, dbgcCmdDumpMem, "[addr]", "Dump memory in words." },
817	{ "echo", 1, ~0, &g_aArgMultiStr[0], ELEMENTS(g_aArgMultiStr), NULL, 0, dbgcCmdEcho, "<str1> [str2..[strN]]", "Displays the strings separated by one blank space and the last one followed by a newline." },
818	{ "exit", 0, 0, NULL, 0, NULL, 0, dbgcCmdQuit, "", "Exits the debugger." },
819	{ "format", 1, 1, &g_aArgAny[0], ELEMENTS(g_aArgAny), NULL, 0, dbgcCmdFormat, "", "Evaluates an expression and formats it." },
820	{ "g", 0, 0, NULL, 0, NULL, 0, dbgcCmdGo, "", "Continue execution." },
821	{ "harakiri", 0, 0, NULL, 0, NULL, 0, dbgcCmdHarakiri, "", "Kills debugger process." },
822	{ "help", 0, ~0, &g_aArgHelp[0], ELEMENTS(g_aArgHelp), NULL, 0, dbgcCmdHelp, "[cmd/op [..]]", "Display help. For help about info items try 'info help'." },
823	{ "info", 1, 2, &g_aArgInfo[0], ELEMENTS(g_aArgInfo), NULL, 0, dbgcCmdInfo, "<info> [args]", "Display info register in the DBGF. For a list of info items try 'info help'." },
824	{ "k", 0, 0, NULL, 0, NULL, 0, dbgcCmdStack, "", "Callstack." },
825	{ "kg", 0, 0, NULL, 0, NULL, 0, dbgcCmdStack, "", "Callstack - guest." },
826	{ "kh", 0, 0, NULL, 0, NULL, 0, dbgcCmdStack, "", "Callstack - hypervisor." },
827	{ "ln", 0, ~0, &g_aArgListNear[0], ELEMENTS(g_aArgListNear), &g_RetListNear, 0, dbgcCmdListNear, "[addr/sym [..]]", "List symbols near to the address. Default address is CS:EIP." },
828	{ "loadsyms", 1, 5, &g_aArgLoadSyms[0], ELEMENTS(g_aArgLoadSyms), NULL, 0, dbgcCmdLoadSyms, "<filename> [delta] [module] [module address]", "Loads symbols from a text file. Optionally giving a delta and a module." },
829	{ "loadvars", 1, 1, &g_aArgFilename[0], ELEMENTS(g_aArgFilename), NULL, 0, dbgcCmdLoadVars, "<filename>", "Load variables from file. One per line, same as the args to the set command." },
830	{ "log", 1, 1, &g_aArgLog[0], ELEMENTS(g_aArgLog), NULL, 0, dbgcCmdLog, "<group string>", "Modifies the logging group settings (VBOX_LOG)" },
831	{ "logdest", 1, 1, &g_aArgLogDest[0], ELEMENTS(g_aArgLogDest), NULL, 0, dbgcCmdLogDest, "<dest string>", "Modifies the logging destination (VBOX_LOG_DEST)." },
832	{ "logflags", 1, 1, &g_aArgLogFlags[0], ELEMENTS(g_aArgLogFlags), NULL, 0, dbgcCmdLogFlags, "<flags string>", "Modifies the logging flags (VBOX_LOG_FLAGS)." },
833	{ "m", 1, 1, &g_aArgMemoryInfo[0],ELEMENTS(g_aArgMemoryInfo),NULL, 0, dbgcCmdMemoryInfo, "<addr>", "Display information about that piece of memory." },
834	{ "quit", 0, 0, NULL, 0, NULL, 0, dbgcCmdQuit, "", "Exits the debugger." },
835	{ "r", 0, 2, &g_aArgReg[0], ELEMENTS(g_aArgReg), NULL, 0, dbgcCmdReg, "[reg [newval]]", "Show or set register(s) - active reg set." },
836	{ "rg", 0, 2, &g_aArgReg[0], ELEMENTS(g_aArgReg), NULL, 0, dbgcCmdRegGuest, "[reg [newval]]", "Show or set register(s) - guest reg set." },
837	{ "rh", 0, 2, &g_aArgReg[0], ELEMENTS(g_aArgReg), NULL, 0, dbgcCmdRegHyper, "[reg [newval]]", "Show or set register(s) - hypervisor reg set." },
838	{ "rt", 0, 0, NULL, 0, NULL, 0, dbgcCmdRegTerse, "", "Toggles terse / verbose register info." },
839	{ "runscript", 1, 1, &g_aArgFilename[0], ELEMENTS(g_aArgFilename), NULL, 0, dbgcCmdRunScript, "<filename>", "Runs the command listed in the script. Lines starting with '#' (after removing blanks) are comment. blank lines are ignored. Stops on failure." },
840	{ "s", 0, 1, &g_aArgSource[0], ELEMENTS(g_aArgSource), NULL, 0, dbgcCmdSource, "[addr]", "Source." },
841	{ "set", 2, 2, &g_aArgSet[0], ELEMENTS(g_aArgSet), NULL, 0, dbgcCmdSet, "<var> <value>", "Sets a global variable." },
842	{ "showvars", 0, 0, NULL, 0, NULL, 0, dbgcCmdShowVars, "", "List all the defined variables." },
843	{ "stop", 0, 0, NULL, 0, NULL, 0, dbgcCmdStop, "", "Stop execution." },
844	{ "t", 0, 0, NULL, 0, NULL, 0, dbgcCmdTrace, "", "Instruction trace (step into)." },
845	{ "u", 0, 1, &g_aArgDisasm[0], ELEMENTS(g_aArgDisasm), NULL, 0, dbgcCmdDisasm, "[addr]", "Disassemble." },
846	{ "unset", 1, ~0, &g_aArgMultiStr[0], ELEMENTS(g_aArgMultiStr), NULL, 0, dbgcCmdUnset, "<var1> [var1..[varN]]", "Unsets (delete) one or more global variables." },
847	};
848
849
850	/** Operators. */
851	static const DBGCOP g_aOps[] =
852	{
853	/* szName is initialized as a 4 char array because of M$C elsewise optimizing it away in /Ox mode (the 'const char' vs 'char' problem). */
854	/* szName, cchName, fBinary, iPrecedence, pfnHandlerUnary, pfnHandlerBitwise */
855	{ {'-'}, 1, false, 1, dbgcOpMinus, NULL, "Unary minus." },
856	{ {'+'}, 1, false, 1, dbgcOpPluss, NULL, "Unary pluss." },
857	{ {'!'}, 1, false, 1, dbgcOpBooleanNot, NULL, "Boolean not." },
858	{ {'~'}, 1, false, 1, dbgcOpBitwiseNot, NULL, "Bitwise complement." },
859	{ {':'}, 1, true, 2, NULL, dbgcOpAddrFar, "Far pointer." },
860	{ {'%'}, 1, false, 3, dbgcOpAddrFlat, NULL, "Flat address." },
861	{ {'%','%'}, 2, false, 3, dbgcOpAddrPhys, NULL, "Physical address." },
862	{ {'#'}, 1, false, 3, dbgcOpAddrHost, NULL, "Flat host address." },
863	{ {'#','%','%'}, 3, false, 3, dbgcOpAddrHostPhys, NULL, "Physical host address." },
864	{ {'$'}, 1, false, 3, dbgcOpVar, NULL, "Reference a variable." },
865	{ {'*'}, 1, true, 10, NULL, dbgcOpMult, "Multiplication." },
866	{ {'/'}, 1, true, 11, NULL, dbgcOpDiv, "Division." },
867	{ {'%'}, 1, true, 12, NULL, dbgcOpMod, "Modulus." },
868	{ {'+'}, 1, true, 13, NULL, dbgcOpAdd, "Addition." },
869	{ {'-'}, 1, true, 14, NULL, dbgcOpSub, "Subtraction." },
870	{ {'<','<'}, 2, true, 15, NULL, dbgcOpBitwiseShiftLeft, "Bitwise left shift." },
871	{ {'>','>'}, 2, true, 16, NULL, dbgcOpBitwiseShiftRight, "Bitwise right shift." },
872	{ {'&'}, 1, true, 17, NULL, dbgcOpBitwiseAnd, "Bitwise and." },
873	{ {'^'}, 1, true, 18, NULL, dbgcOpBitwiseXor, "Bitwise exclusiv or." },
874	{ {'\|'}, 1, true, 19, NULL, dbgcOpBitwiseOr, "Bitwise inclusive or." },
875	{ {'&','&'}, 2, true, 20, NULL, dbgcOpBooleanAnd, "Boolean and." },
876	{ {'\|','\|'}, 2, true, 21, NULL, dbgcOpBooleanOr, "Boolean or." },
877	{ {'L'}, 1, true, 22, NULL, dbgcOpRangeLength, "Range elements." },
878	{ {'L','B'}, 2, true, 23, NULL, dbgcOpRangeLengthBytes, "Range bytes." },
879	{ {'T'}, 1, true, 24, NULL, dbgcOpRangeTo, "Range to." }
880	};
881
882	/** Bitmap where set bits indicates the characters the may start an operator name. */
883	static uint32_t g_bmOperatorChars[256 / (4*8)];
884
885	/** Register symbol uUser value.
886	* @{
887	*/
888	/** If set the register set is the hypervisor and not the guest one. */
889	#define SYMREG_FLAGS_HYPER BIT(20)
890	/** If set a far conversion of the value will use the high 16 bit for the selector.
891	* If clear the low 16 bit will be used. */
892	#define SYMREG_FLAGS_HIGH_SEL BIT(21)
893	/** The shift value to calc the size of a register symbol from the uUser value. */
894	#define SYMREG_SIZE_SHIFT (24)
895	/** Get the offset */
896	#define SYMREG_OFFSET(uUser) (uUser & ((1 << 20) - 1))
897	/** Get the size. */
898	#define SYMREG_SIZE(uUser) ((uUser >> SYMREG_SIZE_SHIFT) & 0xff)
899	/** 1 byte. */
900	#define SYMREG_SIZE_1 ( 1 << SYMREG_SIZE_SHIFT)
901	/** 2 byte. */
902	#define SYMREG_SIZE_2 ( 2 << SYMREG_SIZE_SHIFT)
903	/** 4 byte. */
904	#define SYMREG_SIZE_4 ( 4 << SYMREG_SIZE_SHIFT)
905	/** 6 byte. */
906	#define SYMREG_SIZE_6 ( 6 << SYMREG_SIZE_SHIFT)
907	/** 8 byte. */
908	#define SYMREG_SIZE_8 ( 8 << SYMREG_SIZE_SHIFT)
909	/** 12 byte. */
910	#define SYMREG_SIZE_12 (12 << SYMREG_SIZE_SHIFT)
911	/** 16 byte. */
912	#define SYMREG_SIZE_16 (16 << SYMREG_SIZE_SHIFT)
913	/** @} */
914
915	/** Builtin Symbols.
916	* ASSUMES little endian register representation!
917	*/
918	static const DBGCSYM g_aSyms[] =
919	{
920	{ "eax", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eax) \| SYMREG_SIZE_4 },
921	{ "ax", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eax) \| SYMREG_SIZE_2 },
922	{ "al", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eax) \| SYMREG_SIZE_1 },
923	{ "ah", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eax) + 1 \| SYMREG_SIZE_1 },
924
925	{ "ebx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebx) \| SYMREG_SIZE_4 },
926	{ "bx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebx) \| SYMREG_SIZE_2 },
927	{ "bl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebx) \| SYMREG_SIZE_1 },
928	{ "bh", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebx) + 1 \| SYMREG_SIZE_1 },
929
930	{ "ecx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ecx) \| SYMREG_SIZE_4 },
931	{ "cx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ecx) \| SYMREG_SIZE_2 },
932	{ "cl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ecx) \| SYMREG_SIZE_1 },
933	{ "ch", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ecx) + 1 \| SYMREG_SIZE_1 },
934
935	{ "edx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edx) \| SYMREG_SIZE_4 },
936	{ "dx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edx) \| SYMREG_SIZE_2 },
937	{ "dl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edx) \| SYMREG_SIZE_1 },
938	{ "dh", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edx) + 1 \| SYMREG_SIZE_1 },
939
940	{ "edi", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edi) \| SYMREG_SIZE_4 },
941	{ "di", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edi) \| SYMREG_SIZE_2 },
942
943	{ "esi", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, esi) \| SYMREG_SIZE_4 },
944	{ "si", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, esi) \| SYMREG_SIZE_2 },
945
946	{ "ebp", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebp) \| SYMREG_SIZE_4 },
947	{ "bp", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebp) \| SYMREG_SIZE_2 },
948
949	{ "esp", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, esp) \| SYMREG_SIZE_4 },
950	{ "sp", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, esp) \| SYMREG_SIZE_2 },
951
952	{ "eip", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eip) \| SYMREG_SIZE_4 },
953	{ "ip", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eip) \| SYMREG_SIZE_2 },
954
955	{ "efl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eflags) \| SYMREG_SIZE_4 },
956	{ "eflags", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eflags) \| SYMREG_SIZE_4 },
957	{ "fl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eflags) \| SYMREG_SIZE_2 },
958	{ "flags", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eflags) \| SYMREG_SIZE_2 },
959
960	{ "cs", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, cs) \| SYMREG_SIZE_2 },
961	{ "ds", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ds) \| SYMREG_SIZE_2 },
962	{ "es", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, es) \| SYMREG_SIZE_2 },
963	{ "fs", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, fs) \| SYMREG_SIZE_2 },
964	{ "gs", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, gs) \| SYMREG_SIZE_2 },
965	{ "ss", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ss) \| SYMREG_SIZE_2 },
966
967	{ "cr0", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, cr0) \| SYMREG_SIZE_4 },
968	{ "cr2", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, cr2) \| SYMREG_SIZE_4 },
969	{ "cr3", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, cr3) \| SYMREG_SIZE_4 },
970	{ "cr4", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, cr4) \| SYMREG_SIZE_4 },
971
972	{ "tr", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, tr) \| SYMREG_SIZE_2 },
973	{ "ldtr", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ldtr) \| SYMREG_SIZE_2 },
974
975	{ "gdtr", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, gdtr) \| SYMREG_SIZE_6 },
976	{ "gdtr.limit", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, gdtr.cbGdt)\| SYMREG_SIZE_2 },
977	{ "gdtr.base", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, gdtr.pGdt)\| SYMREG_SIZE_4 },
978
979	{ "idtr", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, idtr) \| SYMREG_SIZE_6 },
980	{ "idtr.limit", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, idtr.cbIdt)\| SYMREG_SIZE_2 },
981	{ "idtr.base", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, idtr.pIdt)\| SYMREG_SIZE_4 },
982
983	/* hypervisor */
984
985	{".eax", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eax) \| SYMREG_SIZE_4 \| SYMREG_FLAGS_HYPER },
986	{".ax", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eax) \| SYMREG_SIZE_2 \| SYMREG_FLAGS_HYPER },
987	{".al", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eax) \| SYMREG_SIZE_1 \| SYMREG_FLAGS_HYPER },
988	{".ah", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eax) + 1 \| SYMREG_SIZE_1 \| SYMREG_FLAGS_HYPER },
989
990	{".ebx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebx) \| SYMREG_SIZE_4 \| SYMREG_FLAGS_HYPER },
991	{".bx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebx) \| SYMREG_SIZE_2 \| SYMREG_FLAGS_HYPER },
992	{".bl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebx) \| SYMREG_SIZE_1 \| SYMREG_FLAGS_HYPER },
993	{".bh", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebx) + 1 \| SYMREG_SIZE_1 \| SYMREG_FLAGS_HYPER },
994
995	{".ecx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ecx) \| SYMREG_SIZE_4 \| SYMREG_FLAGS_HYPER },
996	{".cx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ecx) \| SYMREG_SIZE_2 \| SYMREG_FLAGS_HYPER },
997	{".cl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ecx) \| SYMREG_SIZE_1 \| SYMREG_FLAGS_HYPER },
998	{".ch", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ecx) + 1 \| SYMREG_SIZE_1 \| SYMREG_FLAGS_HYPER },
999
1000	{".edx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edx) \| SYMREG_SIZE_4 \| SYMREG_FLAGS_HYPER },
1001	{".dx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edx) \| SYMREG_SIZE_2 \| SYMREG_FLAGS_HYPER },
1002	{".dl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edx) \| SYMREG_SIZE_1 \| SYMREG_FLAGS_HYPER },
1003	{".dh", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edx) + 1 \| SYMREG_SIZE_1 \| SYMREG_FLAGS_HYPER },
1004
1005	{".edi", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edi) \| SYMREG_SIZE_4 \| SYMREG_FLAGS_HYPER },
1006	{".di", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edi) \| SYMREG_SIZE_2 \| SYMREG_FLAGS_HYPER },
1007
1008	{".esi", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, esi) \| SYMREG_SIZE_4 \| SYMREG_FLAGS_HYPER },
1009	{".si", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, esi) \| SYMREG_SIZE_2 \| SYMREG_FLAGS_HYPER },
1010
1011	{".ebp", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebp) \| SYMREG_SIZE_4 \| SYMREG_FLAGS_HYPER },
1012	{".bp", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebp) \| SYMREG_SIZE_2 \| SYMREG_FLAGS_HYPER },
1013
1014	{".esp", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, esp) \| SYMREG_SIZE_4 \| SYMREG_FLAGS_HYPER },
1015	{".sp", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, esp) \| SYMREG_SIZE_2 \| SYMREG_FLAGS_HYPER },
1016
1017	{".eip", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eip) \| SYMREG_SIZE_4 \| SYMREG_FLAGS_HYPER },
1018	{".ip", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eip) \| SYMREG_SIZE_2 \| SYMREG_FLAGS_HYPER },
1019
1020	{".efl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eflags) \| SYMREG_SIZE_4 \| SYMREG_FLAGS_HYPER },
1021	{".eflags", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eflags) \| SYMREG_SIZE_4 \| SYMREG_FLAGS_HYPER },
1022	{".fl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eflags) \| SYMREG_SIZE_2 \| SYMREG_FLAGS_HYPER },
1023	{".flags", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eflags) \| SYMREG_SIZE_2 \| SYMREG_FLAGS_HYPER },
1024
1025	{".cs", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, cs) \| SYMREG_SIZE_2 \| SYMREG_FLAGS_HYPER },
1026	{".ds", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ds) \| SYMREG_SIZE_2 \| SYMREG_FLAGS_HYPER },
1027	{".es", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, es) \| SYMREG_SIZE_2 \| SYMREG_FLAGS_HYPER },
1028	{".fs", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, fs) \| SYMREG_SIZE_2 \| SYMREG_FLAGS_HYPER },
1029	{".gs", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, gs) \| SYMREG_SIZE_2 \| SYMREG_FLAGS_HYPER },
1030	{".ss", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ss) \| SYMREG_SIZE_2 \| SYMREG_FLAGS_HYPER },
1031
1032	{".cr0", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, cr0) \| SYMREG_SIZE_4 \| SYMREG_FLAGS_HYPER },
1033	{".cr2", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, cr2) \| SYMREG_SIZE_4 \| SYMREG_FLAGS_HYPER },
1034	{".cr3", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, cr3) \| SYMREG_SIZE_4 \| SYMREG_FLAGS_HYPER },
1035	{".cr4", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, cr4) \| SYMREG_SIZE_4 \| SYMREG_FLAGS_HYPER },
1036
1037	{".tr", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, tr) \| SYMREG_SIZE_2 \| SYMREG_FLAGS_HYPER },
1038	{".ldtr", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ldtr) \| SYMREG_SIZE_2 \| SYMREG_FLAGS_HYPER },
1039
1040	{".gdtr", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, gdtr) \| SYMREG_SIZE_6 \| SYMREG_FLAGS_HYPER },
1041	{".gdtr.limit", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, gdtr.cbGdt)\| SYMREG_SIZE_2\| SYMREG_FLAGS_HYPER },
1042	{".gdtr.base", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, gdtr.pGdt)\| SYMREG_SIZE_4 \| SYMREG_FLAGS_HYPER },
1043
1044	{".idtr", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, idtr) \| SYMREG_SIZE_6 \| SYMREG_FLAGS_HYPER },
1045	{".idtr.limit", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, idtr.cbIdt)\| SYMREG_SIZE_2\| SYMREG_FLAGS_HYPER },
1046	{".idtr.base", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, idtr.pIdt)\| SYMREG_SIZE_4 \| SYMREG_FLAGS_HYPER },
1047
1048	};
1049
1050
1051	/**
1052	* Prints full command help.
1053	*/
1054	static int dbgcPrintHelp(PDBGCCMDHLP pCmdHlp, PCDBGCCMD pCmd, bool fExternal)
1055	{
1056	int rc;
1057
1058	/* the command */
1059	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
1060	"%s%-*s %-30s %s",
1061	fExternal ? "." : "",
1062	fExternal ? 10 : 11,
1063	pCmd->pszCmd,
1064	pCmd->pszSyntax,
1065	pCmd->pszDescription);
1066	if (!pCmd->cArgsMin && pCmd->cArgsMin == pCmd->cArgsMax)
1067	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " <no args>\n");
1068	else if (pCmd->cArgsMin == pCmd->cArgsMax)
1069	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " <%u args>\n", pCmd->cArgsMin);
1070	else if (pCmd->cArgsMax == ~0U)
1071	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " <%u+ args>\n", pCmd->cArgsMin);
1072	else
1073	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " <%u to %u args>\n", pCmd->cArgsMin, pCmd->cArgsMax);
1074
1075	/* argument descriptions. */
1076	for (unsigned i = 0; i < pCmd->cArgDescs; i++)
1077	{
1078	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
1079	" %-12s %s",
1080	pCmd->paArgDescs[i].pszName,
1081	pCmd->paArgDescs[i].pszDescription);
1082	if (!pCmd->paArgDescs[i].cTimesMin)
1083	{
1084	if (pCmd->paArgDescs[i].cTimesMax == ~0U)
1085	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " <optional+>\n");
1086	else
1087	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " <optional-%u>\n", pCmd->paArgDescs[i].cTimesMax);
1088	}
1089	else
1090	{
1091	if (pCmd->paArgDescs[i].cTimesMax == ~0U)
1092	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " <%u+>\n", pCmd->paArgDescs[i].cTimesMin);
1093	else
1094	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " <%u-%u>\n", pCmd->paArgDescs[i].cTimesMin, pCmd->paArgDescs[i].cTimesMax);
1095	}
1096	}
1097	return rc;
1098	}
1099
1100	/**
1101	* The 'help' command.
1102	*
1103	* @returns VBox status.
1104	* @param pCmd Pointer to the command descriptor (as registered).
1105	* @param pCmdHlp Pointer to command helper functions.
1106	* @param pVM Pointer to the current VM (if any).
1107	* @param paArgs Pointer to (readonly) array of arguments.
1108	* @param cArgs Number of arguments in the array.
1109	*/
1110	static DECLCALLBACK(int) dbgcCmdHelp(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
1111	{
1112	int rc = VINF_SUCCESS;
1113	unsigned i;
1114	if (!cArgs)
1115	{
1116	/*
1117	* All the stuff.
1118	*/
1119	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
1120	"VirtualBox Debugger\n"
1121	"-------------------\n"
1122	"\n"
1123	"Commands and Functions:\n");
1124	for (i = 0; i < ELEMENTS(g_aCmds); i++)
1125	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
1126	"%-11s %-30s %s\n",
1127	g_aCmds[i].pszCmd,
1128	g_aCmds[i].pszSyntax,
1129	g_aCmds[i].pszDescription);
1130
1131	if (g_pExtCmdsHead)
1132	{
1133	DBGCEXTCMDS_LOCK_RD();
1134	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
1135	"\n"
1136	"External Commands and Functions:\n");
1137	for (PDBGCEXTCMDS pExtCmd = g_pExtCmdsHead; pExtCmd; pExtCmd = pExtCmd->pNext)
1138	for (i = 0; i < pExtCmd->cCmds; i++)
1139	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
1140	".%-10s %-30s %s\n",
1141	pExtCmd->paCmds[i].pszCmd,
1142	pExtCmd->paCmds[i].pszSyntax,
1143	pExtCmd->paCmds[i].pszDescription);
1144	DBGCEXTCMDS_UNLOCK_RD();
1145	}
1146
1147	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
1148	"\n"
1149	"Operators:\n");
1150	unsigned iPrecedence = 0;
1151	unsigned cLeft = ELEMENTS(g_aOps);
1152	while (cLeft > 0)
1153	{
1154	for (i = 0; i < ELEMENTS(g_aOps); i++)
1155	if (g_aOps[i].iPrecedence == iPrecedence)
1156	{
1157	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
1158	"%-10s %s %s\n",
1159	g_aOps[i].szName,
1160	g_aOps[i].fBinary ? "Binary" : "Unary ",
1161	g_aOps[i].pszDescription);
1162	cLeft--;
1163	}
1164	iPrecedence++;
1165	}
1166	}
1167	else
1168	{
1169	/*
1170	* Search for the arguments (strings).
1171	*/
1172	for (unsigned iArg = 0; iArg < cArgs; iArg++)
1173	{
1174	Assert(paArgs[iArg].enmType == DBGCVAR_TYPE_STRING);
1175
1176	/* lookup in the command list */
1177	bool fFound = false;
1178	for (i = 0; i < ELEMENTS(g_aCmds); i++)
1179	if (!strcmp(g_aCmds[i].pszCmd, paArgs[iArg].u.pszString))
1180	{
1181	rc = dbgcPrintHelp(pCmdHlp, &g_aCmds[i], false);
1182	fFound = true;
1183	break;
1184	}
1185
1186	/* external commands */
1187	if ( !fFound
1188	&& g_pExtCmdsHead
1189	&& paArgs[iArg].u.pszString[0] == '.')
1190	{
1191	DBGCEXTCMDS_LOCK_RD();
1192	for (PDBGCEXTCMDS pExtCmd = g_pExtCmdsHead; pExtCmd; pExtCmd = pExtCmd->pNext)
1193	for (i = 0; i < pExtCmd->cCmds; i++)
1194	if (!strcmp(pExtCmd->paCmds[i].pszCmd, paArgs[iArg].u.pszString + 1))
1195	{
1196	rc = dbgcPrintHelp(pCmdHlp, &g_aCmds[i], true);
1197	fFound = true;
1198	break;
1199	}
1200	DBGCEXTCMDS_UNLOCK_RD();
1201	}
1202
1203	/* operators */
1204	if (!fFound && strlen(paArgs[iArg].u.pszString) < sizeof(g_aOps[i].szName))
1205	{
1206	for (i = 0; i < ELEMENTS(g_aOps); i++)
1207	if (!strcmp(g_aOps[i].szName, paArgs[iArg].u.pszString))
1208	{
1209	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
1210	"%-10s %s %s\n",
1211	g_aOps[i].szName,
1212	g_aOps[i].fBinary ? "Binary" : "Unary ",
1213	g_aOps[i].pszDescription);
1214	fFound = true;
1215	break;
1216	}
1217	}
1218
1219	/* found? */
1220	if (!fFound)
1221	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
1222	"error: '%s' was not found!\n",
1223	paArgs[iArg].u.pszString);
1224	} /* foreach argument */
1225	}
1226
1227	NOREF(pCmd);
1228	NOREF(pVM);
1229	NOREF(pResult);
1230	return rc;
1231	}
1232
1233
1234	/**
1235	* The 'quit', 'exit' and 'bye' commands.
1236	*
1237	* @returns VBox status.
1238	* @param pCmd Pointer to the command descriptor (as registered).
1239	* @param pCmdHlp Pointer to command helper functions.
1240	* @param pVM Pointer to the current VM (if any).
1241	* @param paArgs Pointer to (readonly) array of arguments.
1242	* @param cArgs Number of arguments in the array.
1243	*/
1244	static DECLCALLBACK(int) dbgcCmdQuit(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
1245	{
1246	pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Quitting console...\n");
1247	NOREF(pCmd);
1248	NOREF(pVM);
1249	NOREF(paArgs);
1250	NOREF(cArgs);
1251	NOREF(pResult);
1252	return VERR_DBGC_QUIT;
1253	}
1254
1255
1256	/**
1257	* The 'go' command.
1258	*
1259	* @returns VBox status.
1260	* @param pCmd Pointer to the command descriptor (as registered).
1261	* @param pCmdHlp Pointer to command helper functions.
1262	* @param pVM Pointer to the current VM (if any).
1263	* @param paArgs Pointer to (readonly) array of arguments.
1264	* @param cArgs Number of arguments in the array.
1265	*/
1266	static DECLCALLBACK(int) dbgcCmdGo(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
1267	{
1268	/*
1269	* Check if the VM is halted or not before trying to resume it.
1270	*/
1271	if (!DBGFR3IsHalted(pVM))
1272	pCmdHlp->pfnPrintf(pCmdHlp, NULL, "warning: The VM is already running...\n");
1273	else
1274	{
1275	int rc = DBGFR3Resume(pVM);
1276	if (VBOX_FAILURE(rc))
1277	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Executing DBGFR3Resume().");
1278	}
1279
1280	NOREF(pCmd);
1281	NOREF(paArgs);
1282	NOREF(cArgs);
1283	NOREF(pResult);
1284	return 0;
1285	}
1286
1287	/**
1288	* The 'stop' command.
1289	*
1290	* @returns VBox status.
1291	* @param pCmd Pointer to the command descriptor (as registered).
1292	* @param pCmdHlp Pointer to command helper functions.
1293	* @param pVM Pointer to the current VM (if any).
1294	* @param paArgs Pointer to (readonly) array of arguments.
1295	* @param cArgs Number of arguments in the array.
1296	*/
1297	static DECLCALLBACK(int) dbgcCmdStop(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
1298	{
1299	/*
1300	* Check if the VM is halted or not before trying to halt it.
1301	*/
1302	int rc;
1303	if (DBGFR3IsHalted(pVM))
1304	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "warning: The VM is already halted...\n");
1305	else
1306	{
1307	rc = DBGFR3Halt(pVM);
1308	if (VBOX_SUCCESS(rc))
1309	rc = VWRN_DBGC_CMD_PENDING;
1310	else
1311	rc = pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Executing DBGFR3Halt().");
1312	}
1313
1314	NOREF(pCmd); NOREF(paArgs); NOREF(cArgs); NOREF(pResult);
1315	return rc;
1316	}
1317
1318
1319	/**
1320	* The 'ba' command.
1321	*
1322	* @returns VBox status.
1323	* @param pCmd Pointer to the command descriptor (as registered).
1324	* @param pCmdHlp Pointer to command helper functions.
1325	* @param pVM Pointer to the current VM (if any).
1326	* @param paArgs Pointer to (readonly) array of arguments.
1327	* @param cArgs Number of arguments in the array.
1328	*/
1329	static DECLCALLBACK(int) dbgcCmdBrkAccess(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR /pResult/)
1330	{
1331	/*
1332	* Interpret access type.
1333	*/
1334	if ( !strchr("xrwi", paArgs[0].u.pszString[0])
1335	\|\| paArgs[0].u.pszString[1])
1336	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Invalid access type '%s' for '%s'. Valid types are 'e', 'r', 'w' and 'i'.\n",
1337	paArgs[0].u.pszString, pCmd->pszCmd);
1338	uint8_t fType = 0;
1339	switch (paArgs[0].u.pszString[0])
1340	{
1341	case 'x': fType = X86_DR7_RW_EO; break;
1342	case 'r': fType = X86_DR7_RW_RW; break;
1343	case 'w': fType = X86_DR7_RW_WO; break;
1344	case 'i': fType = X86_DR7_RW_IO; break;
1345	}
1346
1347	/*
1348	* Validate size.
1349	*/
1350	if (fType == X86_DR7_RW_EO && paArgs[1].u.u64Number != 1)
1351	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Invalid access size %RX64 for '%s'. 'x' access type requires size 1!\n",
1352	paArgs[1].u.u64Number, pCmd->pszCmd);
1353	switch (paArgs[1].u.u64Number)
1354	{
1355	case 1:
1356	case 2:
1357	case 4:
1358	break;
1359	/case 8: - later/
1360	default:
1361	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Invalid access size %RX64 for '%s'. 1, 2 or 4!\n",
1362	paArgs[1].u.u64Number, pCmd->pszCmd);
1363	}
1364	uint8_t cb = (uint8_t)paArgs[1].u.u64Number;
1365
1366	/*
1367	* Convert the pointer to a DBGF address.
1368	*/
1369	DBGFADDRESS Address;
1370	int rc = pCmdHlp->pfnVarToDbgfAddr(pCmdHlp, &paArgs[2], &Address);
1371	if (VBOX_FAILURE(rc))
1372	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Couldn't convert '%DV' to a DBGF address, rc=%Vrc.\n", &paArgs[2], rc);
1373
1374	/*
1375	* Pick out the optional arguments.
1376	*/
1377	uint64_t iHitTrigger = 0;
1378	uint64_t iHitDisable = ~0;
1379	const char *pszCmds = NULL;
1380	unsigned iArg = 3;
1381	if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_NUMBER)
1382	{
1383	iHitTrigger = paArgs[iArg].u.u64Number;
1384	iArg++;
1385	if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_NUMBER)
1386	{
1387	iHitDisable = paArgs[iArg].u.u64Number;
1388	iArg++;
1389	}
1390	}
1391	if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_STRING)
1392	{
1393	pszCmds = paArgs[iArg].u.pszString;
1394	iArg++;
1395	}
1396
1397	/*
1398	* Try set the breakpoint.
1399	*/
1400	RTUINT iBp;
1401	rc = DBGFR3BpSetReg(pVM, &Address, iHitTrigger, iHitDisable, fType, cb, &iBp);
1402	if (VBOX_SUCCESS(rc))
1403	{
1404	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1405	rc = dbgcBpAdd(pDbgc, iBp, pszCmds);
1406	if (VBOX_SUCCESS(rc))
1407	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Set access breakpoint %u at %VGv\n", iBp, Address.FlatPtr);
1408	if (rc == VERR_DBGC_BP_EXISTS)
1409	{
1410	rc = dbgcBpUpdate(pDbgc, iBp, pszCmds);
1411	if (VBOX_SUCCESS(rc))
1412	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Updated access breakpoint %u at %VGv\n", iBp, Address.FlatPtr);
1413	}
1414	int rc2 = DBGFR3BpClear(pDbgc->pVM, iBp);
1415	AssertRC(rc2);
1416	}
1417	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Failed to set access breakpoint at %VGv, rc=%Vrc.\n", Address.FlatPtr, rc);
1418	}
1419
1420
1421	/**
1422	* The 'bc' command.
1423	*
1424	* @returns VBox status.
1425	* @param pCmd Pointer to the command descriptor (as registered).
1426	* @param pCmdHlp Pointer to command helper functions.
1427	* @param pVM Pointer to the current VM (if any).
1428	* @param paArgs Pointer to (readonly) array of arguments.
1429	* @param cArgs Number of arguments in the array.
1430	*/
1431	static DECLCALLBACK(int) dbgcCmdBrkClear(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR /pResult/)
1432	{
1433	/*
1434	* Enumerate the arguments.
1435	*/
1436	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1437	int rc = VINF_SUCCESS;
1438	for (unsigned iArg = 0; iArg < cArgs && VBOX_SUCCESS(rc); iArg++)
1439	{
1440	if (paArgs[iArg].enmType != DBGCVAR_TYPE_STRING)
1441	{
1442	/* one */
1443	RTUINT iBp = (RTUINT)paArgs[iArg].u.u64Number;
1444	if (iBp != paArgs[iArg].u.u64Number)
1445	{
1446	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Breakpoint id %RX64 is too large!\n", paArgs[iArg].u.u64Number);
1447	break;
1448	}
1449	int rc2 = DBGFR3BpClear(pVM, iBp);
1450	if (VBOX_FAILURE(rc2))
1451	rc = pCmdHlp->pfnVBoxError(pCmdHlp, rc2, "DBGFR3BpClear failed for breakpoint %u!\n", iBp);
1452	if (VBOX_SUCCESS(rc2) \|\| rc2 == VERR_DBGF_BP_NOT_FOUND)
1453	dbgcBpDelete(pDbgc, iBp);
1454	}
1455	else if (!strcmp(paArgs[iArg].u.pszString, "all"))
1456	{
1457	/* all */
1458	PDBGCBP pBp = pDbgc->pFirstBp;
1459	while (pBp)
1460	{
1461	RTUINT iBp = pBp->iBp;
1462	pBp = pBp->pNext;
1463
1464	int rc2 = DBGFR3BpClear(pVM, iBp);
1465	if (VBOX_FAILURE(rc2))
1466	rc = pCmdHlp->pfnVBoxError(pCmdHlp, rc2, "DBGFR3BpClear failed for breakpoint %u!\n", iBp);
1467	if (VBOX_SUCCESS(rc2) \|\| rc2 == VERR_DBGF_BP_NOT_FOUND)
1468	dbgcBpDelete(pDbgc, iBp);
1469	}
1470	}
1471	else
1472	{
1473	/* invalid parameter */
1474	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Invalid argument '%s' to '%s'!\n", paArgs[iArg].u.pszString, pCmd->pszCmd);
1475	break;
1476	}
1477	}
1478	return rc;
1479	}
1480
1481
1482	/**
1483	* The 'bd' command.
1484	*
1485	* @returns VBox status.
1486	* @param pCmd Pointer to the command descriptor (as registered).
1487	* @param pCmdHlp Pointer to command helper functions.
1488	* @param pVM Pointer to the current VM (if any).
1489	* @param paArgs Pointer to (readonly) array of arguments.
1490	* @param cArgs Number of arguments in the array.
1491	*/
1492	static DECLCALLBACK(int) dbgcCmdBrkDisable(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR /pResult/)
1493	{
1494	/*
1495	* Enumerate the arguments.
1496	*/
1497	int rc = VINF_SUCCESS;
1498	for (unsigned iArg = 0; iArg < cArgs && VBOX_SUCCESS(rc); iArg++)
1499	{
1500	if (paArgs[iArg].enmType != DBGCVAR_TYPE_STRING)
1501	{
1502	/* one */
1503	RTUINT iBp = (RTUINT)paArgs[iArg].u.u64Number;
1504	if (iBp != paArgs[iArg].u.u64Number)
1505	{
1506	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Breakpoint id %RX64 is too large!\n", paArgs[iArg].u.u64Number);
1507	break;
1508	}
1509	rc = DBGFR3BpDisable(pVM, iBp);
1510	if (VBOX_FAILURE(rc))
1511	rc = pCmdHlp->pfnVBoxError(pCmdHlp, rc, "DBGFR3BpDisable failed for breakpoint %u!\n", iBp);
1512	}
1513	else if (!strcmp(paArgs[iArg].u.pszString, "all"))
1514	{
1515	/* all */
1516	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1517	for (PDBGCBP pBp = pDbgc->pFirstBp; pBp; pBp = pBp->pNext)
1518	{
1519	rc = DBGFR3BpDisable(pVM, pBp->iBp);
1520	if (VBOX_FAILURE(rc))
1521	rc = pCmdHlp->pfnVBoxError(pCmdHlp, rc, "DBGFR3BpDisable failed for breakpoint %u!\n", pBp->iBp);
1522	}
1523	}
1524	else
1525	{
1526	/* invalid parameter */
1527	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Invalid argument '%s' to '%s'!\n", paArgs[iArg].u.pszString, pCmd->pszCmd);
1528	break;
1529	}
1530	}
1531	return rc;
1532	}
1533
1534
1535	/**
1536	* The 'be' command.
1537	*
1538	* @returns VBox status.
1539	* @param pCmd Pointer to the command descriptor (as registered).
1540	* @param pCmdHlp Pointer to command helper functions.
1541	* @param pVM Pointer to the current VM (if any).
1542	* @param paArgs Pointer to (readonly) array of arguments.
1543	* @param cArgs Number of arguments in the array.
1544	*/
1545	static DECLCALLBACK(int) dbgcCmdBrkEnable(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR /pResult/)
1546	{
1547	/*
1548	* Enumerate the arguments.
1549	*/
1550	int rc = VINF_SUCCESS;
1551	for (unsigned iArg = 0; iArg < cArgs && VBOX_SUCCESS(rc); iArg++)
1552	{
1553	if (paArgs[iArg].enmType != DBGCVAR_TYPE_STRING)
1554	{
1555	/* one */
1556	RTUINT iBp = (RTUINT)paArgs[iArg].u.u64Number;
1557	if (iBp != paArgs[iArg].u.u64Number)
1558	{
1559	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Breakpoint id %RX64 is too large!\n", paArgs[iArg].u.u64Number);
1560	break;
1561	}
1562	rc = DBGFR3BpEnable(pVM, iBp);
1563	if (VBOX_FAILURE(rc))
1564	rc = pCmdHlp->pfnVBoxError(pCmdHlp, rc, "DBGFR3BpEnable failed for breakpoint %u!\n", iBp);
1565	}
1566	else if (!strcmp(paArgs[iArg].u.pszString, "all"))
1567	{
1568	/* all */
1569	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1570	for (PDBGCBP pBp = pDbgc->pFirstBp; pBp; pBp = pBp->pNext)
1571	{
1572	rc = DBGFR3BpEnable(pVM, pBp->iBp);
1573	if (VBOX_FAILURE(rc))
1574	rc = pCmdHlp->pfnVBoxError(pCmdHlp, rc, "DBGFR3BpEnable failed for breakpoint %u!\n", pBp->iBp);
1575	}
1576	}
1577	else
1578	{
1579	/* invalid parameter */
1580	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Invalid argument '%s' to '%s'!\n", paArgs[iArg].u.pszString, pCmd->pszCmd);
1581	break;
1582	}
1583	}
1584	return rc;
1585	}
1586
1587
1588	/**
1589	* Breakpoint enumeration callback function.
1590	*
1591	* @returns VBox status code. Any failure will stop the enumeration.
1592	* @param pVM The VM handle.
1593	* @param pvUser The user argument.
1594	* @param pBp Pointer to the breakpoint information. (readonly)
1595	*/
1596	static DECLCALLBACK(int) dbgcEnumBreakpointsCallback(PVM pVM, void *pvUser, PCDBGFBP pBp)
1597	{
1598	PDBGC pDbgc = (PDBGC)pvUser;
1599	PDBGCBP pDbgcBp = dbgcBpGet(pDbgc, pBp->iBp);
1600
1601	/*
1602	* BP type and size.
1603	*/
1604	char chType;
1605	char cb = 1;
1606	switch (pBp->enmType)
1607	{
1608	case DBGFBPTYPE_INT3:
1609	chType = 'p';
1610	break;
1611	case DBGFBPTYPE_REG:
1612	switch (pBp->u.Reg.fType)
1613	{
1614	case X86_DR7_RW_EO: chType = 'x'; break;
1615	case X86_DR7_RW_WO: chType = 'w'; break;
1616	case X86_DR7_RW_IO: chType = 'i'; break;
1617	case X86_DR7_RW_RW: chType = 'r'; break;
1618	default: chType = '?'; break;
1619
1620	}
1621	cb = pBp->u.Reg.cb;
1622	break;
1623	case DBGFBPTYPE_REM:
1624	chType = 'r';
1625	break;
1626	default:
1627	chType = '?';
1628	break;
1629	}
1630
1631	pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "%2u %c %d %c %VGv %04RX64 (%04RX64 to ",
1632	pBp->iBp, pBp->fEnabled ? 'e' : 'd', cb, chType,
1633	pBp->GCPtr, pBp->cHits, pBp->iHitTrigger);
1634	if (pBp->iHitDisable == ~(uint64_t)0)
1635	pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "~0) ");
1636	else
1637	pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "%04RX64)");
1638
1639	/*
1640	* Try resolve the address.
1641	*/
1642	DBGFSYMBOL Sym;
1643	RTGCINTPTR off;
1644	int rc = DBGFR3SymbolByAddr(pVM, pBp->GCPtr, &off, &Sym);
1645	if (VBOX_SUCCESS(rc))
1646	{
1647	if (!off)
1648	pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "%s", Sym.szName);
1649	else if (off > 0)
1650	pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "%s+%VGv", Sym.szName, off);
1651	else
1652	pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "%s+%VGv", Sym.szName, -off);
1653	}
1654
1655	/*
1656	* The commands.
1657	*/
1658	if (pDbgcBp)
1659	{
1660	if (pDbgcBp->cchCmd)
1661	pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\n cmds: '%s'\n",
1662	pDbgcBp->szCmd);
1663	else
1664	pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\n");
1665	}
1666	else
1667	pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, " [unknown bp]\n");
1668
1669	return VINF_SUCCESS;
1670	}
1671
1672
1673	/**
1674	* The 'bl' command.
1675	*
1676	* @returns VBox status.
1677	* @param pCmd Pointer to the command descriptor (as registered).
1678	* @param pCmdHlp Pointer to command helper functions.
1679	* @param pVM Pointer to the current VM (if any).
1680	* @param paArgs Pointer to (readonly) array of arguments.
1681	* @param cArgs Number of arguments in the array.
1682	*/
1683	static DECLCALLBACK(int) dbgcCmdBrkList(PCDBGCCMD /pCmd/, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR /paArgs/, unsigned /cArgs/, PDBGCVAR /pResult/)
1684	{
1685	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1686
1687	/*
1688	* Enumerate the breakpoints.
1689	*/
1690	int rc = DBGFR3BpEnum(pVM, dbgcEnumBreakpointsCallback, pDbgc);
1691	if (VBOX_FAILURE(rc))
1692	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "DBGFR3BpEnum failed.\n");
1693	return rc;
1694	}
1695
1696
1697	/**
1698	* The 'bp' command.
1699	*
1700	* @returns VBox status.
1701	* @param pCmd Pointer to the command descriptor (as registered).
1702	* @param pCmdHlp Pointer to command helper functions.
1703	* @param pVM Pointer to the current VM (if any).
1704	* @param paArgs Pointer to (readonly) array of arguments.
1705	* @param cArgs Number of arguments in the array.
1706	*/
1707	static DECLCALLBACK(int) dbgcCmdBrkSet(PCDBGCCMD /pCmd/, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR /pResult/)
1708	{
1709	/*
1710	* Convert the pointer to a DBGF address.
1711	*/
1712	DBGFADDRESS Address;
1713	int rc = pCmdHlp->pfnVarToDbgfAddr(pCmdHlp, &paArgs[0], &Address);
1714	if (VBOX_FAILURE(rc))
1715	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Couldn't convert '%DV' to a DBGF address, rc=%Vrc.\n", &paArgs[0], rc);
1716
1717	/*
1718	* Pick out the optional arguments.
1719	*/
1720	uint64_t iHitTrigger = 0;
1721	uint64_t iHitDisable = ~0;
1722	const char *pszCmds = NULL;
1723	unsigned iArg = 1;
1724	if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_NUMBER)
1725	{
1726	iHitTrigger = paArgs[iArg].u.u64Number;
1727	iArg++;
1728	if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_NUMBER)
1729	{
1730	iHitDisable = paArgs[iArg].u.u64Number;
1731	iArg++;
1732	}
1733	}
1734	if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_STRING)
1735	{
1736	pszCmds = paArgs[iArg].u.pszString;
1737	iArg++;
1738	}
1739
1740	/*
1741	* Try set the breakpoint.
1742	*/
1743	RTUINT iBp;
1744	rc = DBGFR3BpSet(pVM, &Address, iHitTrigger, iHitDisable, &iBp);
1745	if (VBOX_SUCCESS(rc))
1746	{
1747	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1748	rc = dbgcBpAdd(pDbgc, iBp, pszCmds);
1749	if (VBOX_SUCCESS(rc))
1750	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Set breakpoint %u at %VGv\n", iBp, Address.FlatPtr);
1751	if (rc == VERR_DBGC_BP_EXISTS)
1752	{
1753	rc = dbgcBpUpdate(pDbgc, iBp, pszCmds);
1754	if (VBOX_SUCCESS(rc))
1755	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Updated breakpoint %u at %VGv\n", iBp, Address.FlatPtr);
1756	}
1757	int rc2 = DBGFR3BpClear(pDbgc->pVM, iBp);
1758	AssertRC(rc2);
1759	}
1760	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Failed to set breakpoint at %VGv, rc=%Vrc.\n", Address.FlatPtr, rc);
1761	}
1762
1763
1764	/**
1765	* The 'br' command.
1766	*
1767	* @returns VBox status.
1768	* @param pCmd Pointer to the command descriptor (as registered).
1769	* @param pCmdHlp Pointer to command helper functions.
1770	* @param pVM Pointer to the current VM (if any).
1771	* @param paArgs Pointer to (readonly) array of arguments.
1772	* @param cArgs Number of arguments in the array.
1773	*/
1774	static DECLCALLBACK(int) dbgcCmdBrkREM(PCDBGCCMD /pCmd/, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR /pResult/)
1775	{
1776	/*
1777	* Convert the pointer to a DBGF address.
1778	*/
1779	DBGFADDRESS Address;
1780	int rc = pCmdHlp->pfnVarToDbgfAddr(pCmdHlp, &paArgs[0], &Address);
1781	if (VBOX_FAILURE(rc))
1782	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Couldn't convert '%DV' to a DBGF address, rc=%Vrc.\n", &paArgs[0], rc);
1783
1784	/*
1785	* Pick out the optional arguments.
1786	*/
1787	uint64_t iHitTrigger = 0;
1788	uint64_t iHitDisable = ~0;
1789	const char *pszCmds = NULL;
1790	unsigned iArg = 1;
1791	if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_NUMBER)
1792	{
1793	iHitTrigger = paArgs[iArg].u.u64Number;
1794	iArg++;
1795	if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_NUMBER)
1796	{
1797	iHitDisable = paArgs[iArg].u.u64Number;
1798	iArg++;
1799	}
1800	}
1801	if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_STRING)
1802	{
1803	pszCmds = paArgs[iArg].u.pszString;
1804	iArg++;
1805	}
1806
1807	/*
1808	* Try set the breakpoint.
1809	*/
1810	RTUINT iBp;
1811	rc = DBGFR3BpSetREM(pVM, &Address, iHitTrigger, iHitDisable, &iBp);
1812	if (VBOX_SUCCESS(rc))
1813	{
1814	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1815	rc = dbgcBpAdd(pDbgc, iBp, pszCmds);
1816	if (VBOX_SUCCESS(rc))
1817	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Set REM breakpoint %u at %VGv\n", iBp, Address.FlatPtr);
1818	if (rc == VERR_DBGC_BP_EXISTS)
1819	{
1820	rc = dbgcBpUpdate(pDbgc, iBp, pszCmds);
1821	if (VBOX_SUCCESS(rc))
1822	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Updated REM breakpoint %u at %VGv\n", iBp, Address.FlatPtr);
1823	}
1824	int rc2 = DBGFR3BpClear(pDbgc->pVM, iBp);
1825	AssertRC(rc2);
1826	}
1827	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Failed to set REM breakpoint at %VGv, rc=%Vrc.\n", Address.FlatPtr, rc);
1828	}
1829
1830
1831	/**
1832	* The 'u' command.
1833	*
1834	* @returns VBox status.
1835	* @param pCmd Pointer to the command descriptor (as registered).
1836	* @param pCmdHlp Pointer to command helper functions.
1837	* @param pVM Pointer to the current VM (if any).
1838	* @param paArgs Pointer to (readonly) array of arguments.
1839	* @param cArgs Number of arguments in the array.
1840	*/
1841	static DECLCALLBACK(int) dbgcCmdDisasm(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
1842	{
1843	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1844
1845	/*
1846	* Validate input.
1847	*/
1848	if ( cArgs > 1
1849	\|\| (cArgs == 1 && !DBGCVAR_ISPOINTER(paArgs[0].enmType)))
1850	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "internal error: The parser doesn't do its job properly yet.. It might help to use the '%%' operator.\n");
1851	if (!pVM && !cArgs && !DBGCVAR_ISPOINTER(pDbgc->DisasmPos.enmType))
1852	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Don't know where to start disassembling...\n");
1853	if (!pVM && cArgs && DBGCVAR_ISGCPOINTER(paArgs[0].enmType))
1854	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: GC address but no VM.\n");
1855
1856	/*
1857	* Find address.
1858	*/
1859	unsigned fFlags = DBGF_DISAS_FLAGS_NO_ADDRESS;
1860	if (!cArgs)
1861	{
1862	if (!DBGCVAR_ISPOINTER(pDbgc->DisasmPos.enmType))
1863	{
1864	pDbgc->DisasmPos.enmType = DBGCVAR_TYPE_GC_FAR;
1865	pDbgc->SourcePos.u.GCFar.off = pDbgc->fRegCtxGuest ? CPUMGetGuestEIP(pVM) : CPUMGetHyperEIP(pVM);
1866	pDbgc->SourcePos.u.GCFar.sel = pDbgc->fRegCtxGuest ? CPUMGetGuestCS(pVM) : CPUMGetHyperCS(pVM);
1867	if (pDbgc->fRegCtxGuest)
1868	fFlags \|= DBGF_DISAS_FLAGS_CURRENT_GUEST;
1869	else
1870	fFlags \|= DBGF_DISAS_FLAGS_CURRENT_HYPER;
1871	}
1872	pDbgc->DisasmPos.enmRangeType = DBGCVAR_RANGE_NONE;
1873	}
1874	else
1875	pDbgc->DisasmPos = paArgs[0];
1876
1877	/*
1878	* Range.
1879	*/
1880	switch (pDbgc->DisasmPos.enmRangeType)
1881	{
1882	case DBGCVAR_RANGE_NONE:
1883	pDbgc->DisasmPos.enmRangeType = DBGCVAR_RANGE_ELEMENTS;
1884	pDbgc->DisasmPos.u64Range = 10;
1885	break;
1886
1887	case DBGCVAR_RANGE_ELEMENTS:
1888	if (pDbgc->DisasmPos.u64Range > 2048)
1889	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Too many lines requested. Max is 2048 lines.\n");
1890	break;
1891
1892	case DBGCVAR_RANGE_BYTES:
1893	if (pDbgc->DisasmPos.u64Range > 65536)
1894	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: The requested range is too big. Max is 64KB.\n");
1895	break;
1896
1897	default:
1898	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "internal error: Unknown range type %d.\n", pDbgc->DisasmPos.enmRangeType);
1899	}
1900
1901	/*
1902	* Convert physical and host addresses to guest addresses.
1903	*/
1904	int rc;
1905	switch (pDbgc->DisasmPos.enmType)
1906	{
1907	case DBGCVAR_TYPE_GC_FLAT:
1908	case DBGCVAR_TYPE_GC_FAR:
1909	break;
1910	case DBGCVAR_TYPE_GC_PHYS:
1911	case DBGCVAR_TYPE_HC_FLAT:
1912	case DBGCVAR_TYPE_HC_PHYS:
1913	case DBGCVAR_TYPE_HC_FAR:
1914	{
1915	DBGCVAR VarTmp;
1916	rc = pCmdHlp->pfnEval(pCmdHlp, &VarTmp, "%%(%Dv)", &pDbgc->DisasmPos);
1917	if (VBOX_FAILURE(rc))
1918	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: failed to evaluate '%%(%Dv)' -> %Vrc .\n", pDbgc->DisasmPos, rc);
1919	pDbgc->DisasmPos = VarTmp;
1920	break;
1921	}
1922	default: AssertFailed(); break;
1923	}
1924
1925	/*
1926	* Print address.
1927	* todo: Change to list near.
1928	*/
1929	#if 0
1930	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%DV:\n", &pDbgc->DisasmPos);
1931	if (VBOX_FAILURE(rc))
1932	return rc;
1933	#endif
1934
1935	/*
1936	* Do the disassembling.
1937	*/
1938	unsigned cTries = 32;
1939	int iRangeLeft = (int)pDbgc->DisasmPos.u64Range;
1940	if (iRangeLeft == 0) /* klugde for 'r'. */
1941	iRangeLeft = -1;
1942	for (;;)
1943	{
1944	/*
1945	* Disassemble the instruction.
1946	*/
1947	char szDis[256];
1948	uint32_t cbInstr = 1;
1949	if (pDbgc->DisasmPos.enmType == DBGCVAR_TYPE_GC_FLAT)
1950	rc = DBGFR3DisasInstrEx(pVM, DBGF_SEL_FLAT, pDbgc->DisasmPos.u.GCFlat, fFlags, &szDis[0], sizeof(szDis), &cbInstr);
1951	else
1952	rc = DBGFR3DisasInstrEx(pVM, pDbgc->DisasmPos.u.GCFar.sel, pDbgc->DisasmPos.u.GCFar.off, fFlags, &szDis[0], sizeof(szDis), &cbInstr);
1953	if (VBOX_SUCCESS(rc))
1954	{
1955	/* print it */
1956	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%-16DV %s\n", &pDbgc->DisasmPos, &szDis[0]);
1957	if (VBOX_FAILURE(rc))
1958	return rc;
1959	}
1960	else
1961	{
1962	/* bitch. */
1963	int rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Failed to disassemble instruction, skipping one byte.\n");
1964	if (VBOX_FAILURE(rc))
1965	return rc;
1966	if (cTries-- > 0)
1967	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Too many disassembly failures. Giving up.\n");
1968	cbInstr = 1;
1969	}
1970
1971	/* advance */
1972	if (iRangeLeft < 0) /* 'r' */
1973	break;
1974	if (pDbgc->DisasmPos.enmRangeType == DBGCVAR_RANGE_ELEMENTS)
1975	iRangeLeft--;
1976	else
1977	iRangeLeft -= cbInstr;
1978	rc = pCmdHlp->pfnEval(pCmdHlp, &pDbgc->DisasmPos, "(%Dv) + %x", &pDbgc->DisasmPos, cbInstr);
1979	if (VBOX_FAILURE(rc))
1980	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Expression: (%Dv) + %x\n", &pDbgc->DisasmPos, cbInstr);
1981	if (iRangeLeft <= 0)
1982	break;
1983	fFlags &= ~(DBGF_DISAS_FLAGS_CURRENT_GUEST \| DBGF_DISAS_FLAGS_CURRENT_HYPER);
1984	}
1985
1986	NOREF(pCmd); NOREF(pResult);
1987	return 0;
1988	}
1989
1990
1991	/**
1992	* The 's' command.
1993	*
1994	* @returns VBox status.
1995	* @param pCmd Pointer to the command descriptor (as registered).
1996	* @param pCmdHlp Pointer to command helper functions.
1997	* @param pVM Pointer to the current VM (if any).
1998	* @param paArgs Pointer to (readonly) array of arguments.
1999	* @param cArgs Number of arguments in the array.
2000	*/
2001	static DECLCALLBACK(int) dbgcCmdSource(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
2002	{
2003	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2004
2005	/*
2006	* Validate input.
2007	*/
2008	if ( cArgs > 1
2009	\|\| (cArgs == 1 && !DBGCVAR_ISPOINTER(paArgs[0].enmType)))
2010	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "internal error: The parser doesn't do its job properly yet.. It might help to use the '%%' operator.\n");
2011	if (!pVM && !cArgs && !DBGCVAR_ISPOINTER(pDbgc->SourcePos.enmType))
2012	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Don't know where to start disassembling...\n");
2013	if (!pVM && cArgs && DBGCVAR_ISGCPOINTER(paArgs[0].enmType))
2014	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: GC address but no VM.\n");
2015
2016	/*
2017	* Find address.
2018	*/
2019	if (!cArgs)
2020	{
2021	if (!DBGCVAR_ISPOINTER(pDbgc->SourcePos.enmType))
2022	{
2023	pDbgc->SourcePos.enmType = DBGCVAR_TYPE_GC_FAR;
2024	pDbgc->SourcePos.u.GCFar.off = pDbgc->fRegCtxGuest ? CPUMGetGuestEIP(pVM) : CPUMGetHyperEIP(pVM);
2025	pDbgc->SourcePos.u.GCFar.sel = pDbgc->fRegCtxGuest ? CPUMGetGuestCS(pVM) : CPUMGetHyperCS(pVM);
2026	}
2027	pDbgc->SourcePos.enmRangeType = DBGCVAR_RANGE_NONE;
2028	}
2029	else
2030	pDbgc->SourcePos = paArgs[0];
2031
2032	/*
2033	* Ensure the the source address is flat GC.
2034	*/
2035	switch (pDbgc->SourcePos.enmType)
2036	{
2037	case DBGCVAR_TYPE_GC_FLAT:
2038	break;
2039	case DBGCVAR_TYPE_GC_PHYS:
2040	case DBGCVAR_TYPE_GC_FAR:
2041	case DBGCVAR_TYPE_HC_FLAT:
2042	case DBGCVAR_TYPE_HC_PHYS:
2043	case DBGCVAR_TYPE_HC_FAR:
2044	{
2045	int rc = pCmdHlp->pfnEval(pCmdHlp, &pDbgc->SourcePos, "%%(%Dv)", &pDbgc->SourcePos);
2046	if (VBOX_FAILURE(rc))
2047	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Invalid address or address type. (rc=%d)\n", rc);
2048	break;
2049	}
2050	default: AssertFailed(); break;
2051	}
2052
2053	/*
2054	* Range.
2055	*/
2056	switch (pDbgc->SourcePos.enmRangeType)
2057	{
2058	case DBGCVAR_RANGE_NONE:
2059	pDbgc->SourcePos.enmRangeType = DBGCVAR_RANGE_ELEMENTS;
2060	pDbgc->SourcePos.u64Range = 10;
2061	break;
2062
2063	case DBGCVAR_RANGE_ELEMENTS:
2064	if (pDbgc->SourcePos.u64Range > 2048)
2065	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Too many lines requested. Max is 2048 lines.\n");
2066	break;
2067
2068	case DBGCVAR_RANGE_BYTES:
2069	if (pDbgc->SourcePos.u64Range > 65536)
2070	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: The requested range is too big. Max is 64KB.\n");
2071	break;
2072
2073	default:
2074	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "internal error: Unknown range type %d.\n", pDbgc->SourcePos.enmRangeType);
2075	}
2076
2077	/*
2078	* Do the disassembling.
2079	*/
2080	bool fFirst = 1;
2081	DBGFLINE LinePrev = { 0, 0, "" };
2082	int iRangeLeft = (int)pDbgc->SourcePos.u64Range;
2083	if (iRangeLeft == 0) /* klugde for 'r'. */
2084	iRangeLeft = -1;
2085	for (;;)
2086	{
2087	/*
2088	* Get line info.
2089	*/
2090	DBGFLINE Line;
2091	RTGCINTPTR off;
2092	int rc = DBGFR3LineByAddr(pVM, pDbgc->SourcePos.u.GCFlat, &off, &Line);
2093	if (VBOX_FAILURE(rc))
2094	return VINF_SUCCESS;
2095
2096	unsigned cLines = 0;
2097	if (memcmp(&Line, &LinePrev, sizeof(Line)))
2098	{
2099	/*
2100	* Print filenamename
2101	*/
2102	if (!fFirst && strcmp(Line.szFilename, LinePrev.szFilename))
2103	fFirst = true;
2104	if (fFirst)
2105	{
2106	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "[%s @ %d]\n", Line.szFilename, Line.uLineNo);
2107	if (VBOX_FAILURE(rc))
2108	return rc;
2109	}
2110
2111	/*
2112	* Try open the file and read the line.
2113	*/
2114	FILE *phFile = fopen(Line.szFilename, "r");
2115	if (phFile)
2116	{
2117	/* Skip ahead to the desired line. */
2118	char szLine[4096];
2119	unsigned cBefore = fFirst ? RT_MIN(2, Line.uLineNo - 1) : Line.uLineNo - LinePrev.uLineNo - 1;
2120	if (cBefore > 7)
2121	cBefore = 0;
2122	unsigned cLeft = Line.uLineNo - cBefore;
2123	while (cLeft > 0)
2124	{
2125	szLine[0] = '\0';
2126	if (!fgets(szLine, sizeof(szLine), phFile))
2127	break;
2128	cLeft--;
2129	}
2130	if (!cLeft)
2131	{
2132	/* print the before lines */
2133	for (;;)
2134	{
2135	size_t cch = strlen(szLine);
2136	while (cch > 0 && (szLine[cch - 1] == '\r' \|\| szLine[cch - 1] == '\n' \|\| isspace(szLine[cch - 1])) )
2137	szLine[--cch] = '\0';
2138	if (cBefore-- <= 0)
2139	break;
2140
2141	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " %4d: %s\n", Line.uLineNo - cBefore - 1, szLine);
2142	szLine[0] = '\0';
2143	fgets(szLine, sizeof(szLine), phFile);
2144	cLines++;
2145	}
2146	/* print the actual line */
2147	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%08llx %4d: %s\n", Line.Address, Line.uLineNo, szLine);
2148	}
2149	fclose(phFile);
2150	if (VBOX_FAILURE(rc))
2151	return rc;
2152	fFirst = false;
2153	}
2154	else
2155	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Warning: couldn't open source file '%s'\n", Line.szFilename);
2156
2157	LinePrev = Line;
2158	}
2159
2160
2161	/*
2162	* Advance
2163	*/
2164	if (iRangeLeft < 0) /* 'r' */
2165	break;
2166	if (pDbgc->SourcePos.enmRangeType == DBGCVAR_RANGE_ELEMENTS)
2167	iRangeLeft -= cLines;
2168	else
2169	iRangeLeft -= 1;
2170	rc = pCmdHlp->pfnEval(pCmdHlp, &pDbgc->SourcePos, "(%Dv) + %x", &pDbgc->SourcePos, 1);
2171	if (VBOX_FAILURE(rc))
2172	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Expression: (%Dv) + %x\n", &pDbgc->SourcePos, 1);
2173	if (iRangeLeft <= 0)
2174	break;
2175	}
2176
2177	NOREF(pCmd); NOREF(pResult);
2178	return 0;
2179	}
2180
2181
2182	/**
2183	* The 'r' command.
2184	*
2185	* @returns VBox status.
2186	* @param pCmd Pointer to the command descriptor (as registered).
2187	* @param pCmdHlp Pointer to command helper functions.
2188	* @param pVM Pointer to the current VM (if any).
2189	* @param paArgs Pointer to (readonly) array of arguments.
2190	* @param cArgs Number of arguments in the array.
2191	*/
2192	static DECLCALLBACK(int) dbgcCmdReg(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
2193	{
2194	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2195
2196	if (pDbgc->fRegCtxGuest)
2197	return dbgcCmdRegGuest(pCmd, pCmdHlp, pVM, paArgs, cArgs, pResult);
2198	else
2199	return dbgcCmdRegHyper(pCmd, pCmdHlp, pVM, paArgs, cArgs, pResult);
2200	}
2201
2202
2203	/**
2204	* Common worker for the dbgcCmdReg*() commands.
2205	*
2206	* @returns VBox status.
2207	* @param pCmd Pointer to the command descriptor (as registered).
2208	* @param pCmdHlp Pointer to command helper functions.
2209	* @param pVM Pointer to the current VM (if any).
2210	* @param paArgs Pointer to (readonly) array of arguments.
2211	* @param cArgs Number of arguments in the array.
2212	* @param pszPrefix The symbol prefix.
2213	*/
2214	static DECLCALLBACK(int) dbgcCmdRegCommon(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult, const char *pszPrefix)
2215	{
2216	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2217
2218	/*
2219	* cArgs == 0: Show all
2220	*/
2221	if (cArgs == 0)
2222	{
2223	/*
2224	* Get register context.
2225	*/
2226	int rc;
2227	PCPUMCTX pCtx;
2228	PCCPUMCTXCORE pCtxCore;
2229	if (!*pszPrefix)
2230	{
2231	rc = CPUMQueryGuestCtxPtr(pVM, &pCtx);
2232	pCtxCore = CPUMGetGuestCtxCore(pVM);
2233	}
2234	else
2235	{
2236	rc = CPUMQueryHyperCtxPtr(pVM, &pCtx);
2237	pCtxCore = CPUMGetHyperCtxCore(pVM);
2238	}
2239	if (VBOX_FAILURE(rc))
2240	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Getting register context\n");
2241
2242	/*
2243	* Format the flags.
2244	*/
2245	static struct
2246	{
2247	const char pszSet; const char pszClear; uint32_t fFlag;
2248	} aFlags[] =
2249	{
2250	{ "vip",NULL, X86_EFL_VIP },
2251	{ "vif",NULL, X86_EFL_VIF },
2252	{ "ac", NULL, X86_EFL_AC },
2253	{ "vm", NULL, X86_EFL_VM },
2254	{ "rf", NULL, X86_EFL_RF },
2255	{ "nt", NULL, X86_EFL_NT },
2256	{ "ov", "nv", X86_EFL_OF },
2257	{ "dn", "up", X86_EFL_DF },
2258	{ "ei", "di", X86_EFL_IF },
2259	{ "tf", NULL, X86_EFL_TF },
2260	{ "nt", "pl", X86_EFL_SF },
2261	{ "nz", "zr", X86_EFL_ZF },
2262	{ "ac", "na", X86_EFL_AF },
2263	{ "po", "pe", X86_EFL_PF },
2264	{ "cy", "nc", X86_EFL_CF },
2265	};
2266	char szEFlags[80];
2267	char *psz = szEFlags;
2268	uint32_t efl = pCtxCore->eflags.u32;
2269	for (unsigned i = 0; i < ELEMENTS(aFlags); i++)
2270	{
2271	const char *pszAdd = aFlags[i].fFlag & efl ? aFlags[i].pszSet : aFlags[i].pszClear;
2272	if (pszAdd)
2273	{
2274	strcpy(psz, pszAdd);
2275	psz += strlen(pszAdd);
2276	*psz++ = ' ';
2277	}
2278	}
2279	psz[-1] = '\0';
2280
2281
2282	/*
2283	* Format the registers.
2284	*/
2285	if (pDbgc->fRegTerse)
2286	{
2287	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
2288	"%seax=%08x %sebx=%08x %secx=%08x %sedx=%08x %sesi=%08x %sedi=%08x\n"
2289	"%seip=%08x %sesp=%08x %sebp=%08x %siopl=%d %*s\n"
2290	"%scs=%04x %sds=%04x %ses=%04x %sfs=%04x %sgs=%04x %sss=%04x %seflags=%08x\n",
2291	pszPrefix, pCtxCore->eax, pszPrefix, pCtxCore->ebx, pszPrefix, pCtxCore->ecx, pszPrefix, pCtxCore->edx, pszPrefix, pCtxCore->esi, pszPrefix, pCtxCore->edi,
2292	pszPrefix, pCtxCore->eip, pszPrefix, pCtxCore->esp, pszPrefix, pCtxCore->ebp, pszPrefix, X86_EFL_GET_IOPL(efl), *pszPrefix ? 34 : 31, szEFlags,
2293	pszPrefix, (RTSEL)pCtxCore->cs, pszPrefix, (RTSEL)pCtxCore->ds, pszPrefix, (RTSEL)pCtxCore->es,
2294	pszPrefix, (RTSEL)pCtxCore->fs, pszPrefix, (RTSEL)pCtxCore->gs, pszPrefix, (RTSEL)pCtxCore->ss, pszPrefix, efl);
2295	}
2296	else
2297	{
2298	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
2299	"%seax=%08x %sebx=%08x %secx=%08x %sedx=%08x %sesi=%08x %sedi=%08x\n"
2300	"%seip=%08x %sesp=%08x %sebp=%08x %siopl=%d %*s\n"
2301	"%scs={%04x base=%08x limit=%08x flags=%08x} %sdr0=%08x %sdr1=%08x\n"
2302	"%sds={%04x base=%08x limit=%08x flags=%08x} %sdr2=%08x %sdr3=%08x\n"
2303	"%ses={%04x base=%08x limit=%08x flags=%08x} %sdr4=%08x %sdr5=%08x\n"
2304	"%sfs={%04x base=%08x limit=%08x flags=%08x} %sdr6=%08x %sdr7=%08x\n"
2305	"%sgs={%04x base=%08x limit=%08x flags=%08x} %scr0=%08x %scr2=%08x\n"
2306	"%sss={%04x base=%08x limit=%08x flags=%08x} %scr3=%08x %scr4=%08x\n"
2307	"%sgdtr=%08x:%04x %sidtr=%08x:%04x %seflags=%08x\n"
2308	"%sldtr={%04x base=%08x limit=%08x flags=%08x}\n"
2309	"%str ={%04x base=%08x limit=%08x flags=%08x}\n"
2310	"%sSysEnter={cs=%04llx eip=%08llx esp=%08llx}\n"
2311	"%sFCW=%04x %sFSW=%04x %sFTW=%04x\n"
2312	,
2313	pszPrefix, pCtxCore->eax, pszPrefix, pCtxCore->ebx, pszPrefix, pCtxCore->ecx, pszPrefix, pCtxCore->edx, pszPrefix, pCtxCore->esi, pszPrefix, pCtxCore->edi,
2314	pszPrefix, pCtxCore->eip, pszPrefix, pCtxCore->esp, pszPrefix, pCtxCore->ebp, pszPrefix, X86_EFL_GET_IOPL(efl), *pszPrefix ? 33 : 31, szEFlags,
2315	pszPrefix, (RTSEL)pCtxCore->cs, pCtx->csHid.u32Base, pCtx->csHid.u32Limit, pCtx->csHid.Attr.u, pszPrefix, pCtx->dr0, pszPrefix, pCtx->dr1,
2316	pszPrefix, (RTSEL)pCtxCore->ds, pCtx->dsHid.u32Base, pCtx->dsHid.u32Limit, pCtx->dsHid.Attr.u, pszPrefix, pCtx->dr2, pszPrefix, pCtx->dr3,
2317	pszPrefix, (RTSEL)pCtxCore->es, pCtx->esHid.u32Base, pCtx->esHid.u32Limit, pCtx->esHid.Attr.u, pszPrefix, pCtx->dr4, pszPrefix, pCtx->dr5,
2318	pszPrefix, (RTSEL)pCtxCore->fs, pCtx->fsHid.u32Base, pCtx->fsHid.u32Limit, pCtx->fsHid.Attr.u, pszPrefix, pCtx->dr6, pszPrefix, pCtx->dr7,
2319	pszPrefix, (RTSEL)pCtxCore->gs, pCtx->gsHid.u32Base, pCtx->gsHid.u32Limit, pCtx->gsHid.Attr.u, pszPrefix, pCtx->cr0, pszPrefix, pCtx->cr2,
2320	pszPrefix, (RTSEL)pCtxCore->ss, pCtx->ssHid.u32Base, pCtx->ssHid.u32Limit, pCtx->ssHid.Attr.u, pszPrefix, pCtx->cr3, pszPrefix, pCtx->cr4,
2321	pszPrefix, pCtx->gdtr.pGdt,pCtx->gdtr.cbGdt, pszPrefix, pCtx->idtr.pIdt, pCtx->idtr.cbIdt, pszPrefix, pCtxCore->eflags,
2322	pszPrefix, (RTSEL)pCtx->ldtr, pCtx->ldtrHid.u32Base, pCtx->ldtrHid.u32Limit, pCtx->ldtrHid.Attr.u,
2323	pszPrefix, (RTSEL)pCtx->tr, pCtx->trHid.u32Base, pCtx->trHid.u32Limit, pCtx->trHid.Attr.u,
2324	pszPrefix, pCtx->SysEnter.cs, pCtx->SysEnter.eip, pCtx->SysEnter.esp,
2325	pszPrefix, pCtx->fpu.FCW, pszPrefix, pCtx->fpu.FSW, pszPrefix, pCtx->fpu.FTW);
2326	}
2327
2328	/*
2329	* Disassemble one instruction at cs:eip.
2330	*/
2331	return pCmdHlp->pfnExec(pCmdHlp, "u %04x:%08x L 0", pCtx->cs, pCtx->eip);
2332	}
2333
2334	/*
2335	* cArgs == 1: Show the register.
2336	* cArgs == 2: Modify the register.
2337	*/
2338	if ( cArgs == 1
2339	\|\| cArgs == 2)
2340	{
2341	/* locate the register symbol. */
2342	const char *pszReg = paArgs[0].u.pszString;
2343	if ( *pszPrefix
2344	&& pszReg[0] != *pszPrefix)
2345	{
2346	/* prepend the prefix. */
2347	char psz = (char )alloca(strlen(pszReg) + 2);
2348	psz[0] = *pszPrefix;
2349	strcpy(psz + 1, paArgs[0].u.pszString);
2350	pszReg = psz;
2351	}
2352	PCDBGCSYM pSym = dbgcLookupRegisterSymbol(pDbgc, pszReg);
2353	if (!pSym)
2354	return pCmdHlp->pfnVBoxError(pCmdHlp, VERR_INVALID_PARAMETER /* VERR_DBGC_INVALID_REGISTER */, "Invalid register name '%s'.\n", pszReg);
2355
2356	/* show the register */
2357	if (cArgs == 1)
2358	{
2359	DBGCVAR Var;
2360	memset(&Var, 0, sizeof(Var));
2361	int rc = pSym->pfnGet(pSym, pCmdHlp, DBGCVAR_TYPE_NUMBER, &Var);
2362	if (VBOX_FAILURE(rc))
2363	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Failed getting value for register '%s'.\n", pszReg);
2364	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%s=%Dv\n", pszReg, &Var);
2365	}
2366
2367	/* change the register */
2368	int rc = pSym->pfnSet(pSym, pCmdHlp, &paArgs[1]);
2369	if (VBOX_FAILURE(rc))
2370	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Failed setting value for register '%s'.\n", pszReg);
2371	return VINF_SUCCESS;
2372	}
2373
2374
2375	NOREF(pCmd); NOREF(paArgs); NOREF(pResult);
2376	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Huh? cArgs=%d Expected 0, 1 or 2!\n", cArgs);
2377	}
2378
2379
2380	/**
2381	* The 'rg' command.
2382	*
2383	* @returns VBox status.
2384	* @param pCmd Pointer to the command descriptor (as registered).
2385	* @param pCmdHlp Pointer to command helper functions.
2386	* @param pVM Pointer to the current VM (if any).
2387	* @param paArgs Pointer to (readonly) array of arguments.
2388	* @param cArgs Number of arguments in the array.
2389	*/
2390	static DECLCALLBACK(int) dbgcCmdRegGuest(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
2391	{
2392	return dbgcCmdRegCommon(pCmd, pCmdHlp, pVM, paArgs, cArgs, pResult, "");
2393	}
2394
2395
2396	/**
2397	* The 'rh' command.
2398	*
2399	* @returns VBox status.
2400	* @param pCmd Pointer to the command descriptor (as registered).
2401	* @param pCmdHlp Pointer to command helper functions.
2402	* @param pVM Pointer to the current VM (if any).
2403	* @param paArgs Pointer to (readonly) array of arguments.
2404	* @param cArgs Number of arguments in the array.
2405	*/
2406	static DECLCALLBACK(int) dbgcCmdRegHyper(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
2407	{
2408	return dbgcCmdRegCommon(pCmd, pCmdHlp, pVM, paArgs, cArgs, pResult, ".");
2409	}
2410
2411
2412	/**
2413	* The 'rt' command.
2414	*
2415	* @returns VBox status.
2416	* @param pCmd Pointer to the command descriptor (as registered).
2417	* @param pCmdHlp Pointer to command helper functions.
2418	* @param pVM Pointer to the current VM (if any).
2419	* @param paArgs Pointer to (readonly) array of arguments.
2420	* @param cArgs Number of arguments in the array.
2421	*/
2422	static DECLCALLBACK(int) dbgcCmdRegTerse(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
2423	{
2424	NOREF(pCmd); NOREF(pVM); NOREF(paArgs); NOREF(cArgs); NOREF(pResult);
2425
2426	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2427	pDbgc->fRegTerse = !pDbgc->fRegTerse;
2428	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, pDbgc->fRegTerse ? "info: Terse register info.\n" : "info: Verbose register info.\n");
2429	}
2430
2431
2432	/**
2433	* The 't' command.
2434	*
2435	* @returns VBox status.
2436	* @param pCmd Pointer to the command descriptor (as registered).
2437	* @param pCmdHlp Pointer to command helper functions.
2438	* @param pVM Pointer to the current VM (if any).
2439	* @param paArgs Pointer to (readonly) array of arguments.
2440	* @param cArgs Number of arguments in the array.
2441	*/
2442	static DECLCALLBACK(int) dbgcCmdTrace(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
2443	{
2444	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2445
2446	int rc = DBGFR3Step(pVM);
2447	if (VBOX_SUCCESS(rc))
2448	pDbgc->fReady = false;
2449	else
2450	rc = pDbgc->CmdHlp.pfnVBoxError(&pDbgc->CmdHlp, rc, "When trying to single step VM %p\n", pDbgc->pVM);
2451
2452	NOREF(pCmd); NOREF(paArgs); NOREF(cArgs); NOREF(pResult);
2453	return rc;
2454	}
2455
2456
2457	/**
2458	* The 'k', 'kg' and 'kh' commands.
2459	*
2460	* @returns VBox status.
2461	* @param pCmd Pointer to the command descriptor (as registered).
2462	* @param pCmdHlp Pointer to command helper functions.
2463	* @param pVM Pointer to the current VM (if any).
2464	* @param paArgs Pointer to (readonly) array of arguments.
2465	* @param cArgs Number of arguments in the array.
2466	*/
2467	static DECLCALLBACK(int) dbgcCmdStack(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
2468	{
2469	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2470
2471	/*
2472	* Figure which context we're called for.
2473	*/
2474	bool fGuest = pCmd->pszCmd[1] == 'g'
2475	\|\| (!pCmd->pszCmd[1] && pDbgc->fRegCtxGuest);
2476
2477
2478	DBGFSTACKFRAME Frame;
2479	memset(&Frame, 0, sizeof(Frame));
2480	int rc;
2481	if (fGuest)
2482	rc = DBGFR3StackWalkBeginGuest(pVM, &Frame);
2483	else
2484	rc = DBGFR3StackWalkBeginHyper(pVM, &Frame);
2485	if (VBOX_FAILURE(rc))
2486	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Failed to begin stack walk, rc=%Vrc\n", rc);
2487
2488	/*
2489	* Print header.
2490	* 12345678 12345678 0023:87654321 12345678 87654321 12345678 87654321 symbol
2491	*/
2492	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "EBP Ret EBP Ret CS:EIP Arg0 Arg1 Arg2 Arg3 CS:EIP / Symbol [line]\n");
2493	if (VBOX_FAILURE(rc))
2494	return rc;
2495	do
2496	{
2497	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%08RX32 %08RX32 %04RX32:%08RX32 %08RX32 %08RX32 %08RX32 %08RX32",
2498	(uint32_t)Frame.AddrFrame.off,
2499	(uint32_t)Frame.AddrReturnFrame.off,
2500	(uint32_t)Frame.AddrReturnPC.Sel,
2501	(uint32_t)Frame.AddrReturnPC.off,
2502	Frame.Args.au32[0],
2503	Frame.Args.au32[1],
2504	Frame.Args.au32[2],
2505	Frame.Args.au32[3]);
2506	if (VBOX_FAILURE(rc))
2507	return rc;
2508	if (!Frame.pSymPC)
2509	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " %RTsel:%08RGv", Frame.AddrPC.Sel, Frame.AddrPC.off);
2510	else
2511	{
2512	RTGCINTPTR offDisp = Frame.AddrPC.FlatPtr - Frame.pSymPC->Value; /** @todo this isn't 100% correct for segemnted stuff. */
2513	if (offDisp > 0)
2514	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " %s+%llx", Frame.pSymPC->szName, (int64_t)offDisp);
2515	else if (offDisp < 0)
2516	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " %s-%llx", Frame.pSymPC->szName, -(int64_t)offDisp);
2517	else
2518	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " %s", Frame.pSymPC->szName);
2519	}
2520	if (VBOX_SUCCESS(rc) && Frame.pLinePC)
2521	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " [%s @ 0i%d]", Frame.pLinePC->szFilename, Frame.pLinePC->uLineNo);
2522	if (VBOX_SUCCESS(rc))
2523	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "\n");
2524	if (VBOX_FAILURE(rc))
2525	return rc;
2526
2527	/* next */
2528	rc = DBGFR3StackWalkNext(pVM, &Frame);
2529	} while (VBOX_SUCCESS(rc));
2530
2531	NOREF(paArgs); NOREF(cArgs); NOREF(pResult);
2532	return VINF_SUCCESS;
2533	}
2534
2535
2536	static int dbgcCmdDumpDTWorker64(PDBGCCMDHLP /pCmdHlp/, PCX86DESC64 /pDesc/, unsigned /iEntry/, bool /* fHyper /, bool /fDblEntry/)
2537	{
2538	/* GUEST64 */
2539	return VINF_SUCCESS;
2540	}
2541
2542
2543	/**
2544	* Wroker function that displays one descriptor entry (GDT, LDT, IDT).
2545	*
2546	* @returns pfnPrintf status code.
2547	* @param pCmdHlp The DBGC command helpers.
2548	* @param pDesc The descriptor to display.
2549	* @param iEntry The descriptor entry number.
2550	* @param fHyper Whether the selector belongs to the hypervisor or not.
2551	*/
2552	static int dbgcCmdDumpDTWorker32(PDBGCCMDHLP pCmdHlp, PCX86DESC pDesc, unsigned iEntry, bool fHyper)
2553	{
2554	int rc;
2555
2556	const char *pszHyper = fHyper ? " HYPER" : "";
2557	const char *pszPresent = pDesc->Gen.u1Present ? "P " : "NP";
2558	if (pDesc->Gen.u1DescType)
2559	{
2560	static const char * const s_apszTypes[] =
2561	{
2562	"DataRO", /* 0 Read-Only */
2563	"DataRO", /* 1 Read-Only - Accessed */
2564	"DataRW", /* 2 Read/Write */
2565	"DataRW", /* 3 Read/Write - Accessed */
2566	"DownRO", /* 4 Expand-down, Read-Only */
2567	"DownRO", /* 5 Expand-down, Read-Only - Accessed */
2568	"DownRW", /* 6 Expand-down, Read/Write */
2569	"DownRO", /* 7 Expand-down, Read/Write - Accessed */
2570	"CodeEO", /* 8 Execute-Only */
2571	"CodeEO", /* 9 Execute-Only - Accessed */
2572	"CodeER", /* A Execute/Readable */
2573	"CodeER", /* B Execute/Readable - Accessed */
2574	"ConfE0", /* C Conforming, Execute-Only */
2575	"ConfE0", /* D Conforming, Execute-Only - Accessed */
2576	"ConfER", /* E Conforming, Execute/Readable */
2577	"ConfER" /* F Conforming, Execute/Readable - Accessed */
2578	};
2579	const char *pszAccessed = pDesc->Gen.u4Type & BIT(0) ? "A " : "NA";
2580	const char *pszGranularity = pDesc->Gen.u1Granularity ? "G" : " ";
2581	const char *pszBig = pDesc->Gen.u1DefBig ? "BIG" : " ";
2582	uint32_t u32Base = pDesc->Gen.u16BaseLow
2583	\| ((uint32_t)pDesc->Gen.u8BaseHigh1 << 16)
2584	\| ((uint32_t)pDesc->Gen.u8BaseHigh2 << 24);
2585	uint32_t cbLimit = pDesc->Gen.u16LimitLow \| (pDesc->Gen.u4LimitHigh << 16);
2586	if (pDesc->Gen.u1Granularity)
2587	cbLimit <<= PAGE_SHIFT;
2588
2589	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%04x %s Bas=%08x Lim=%08x DPL=%d %s %s %s %s AVL=%d R=%d%s\n",
2590	iEntry, s_apszTypes[pDesc->Gen.u4Type], u32Base, cbLimit,
2591	pDesc->Gen.u2Dpl, pszPresent, pszAccessed, pszGranularity, pszBig,
2592	pDesc->Gen.u1Available, pDesc->Gen.u1Reserved, pszHyper);
2593	}
2594	else
2595	{
2596	static const char * const s_apszTypes[] =
2597	{
2598	"Ill-0 ", /* 0 0000 Reserved (Illegal) */
2599	"Tss16A", /* 1 0001 Available 16-bit TSS */
2600	"LDT ", /* 2 0010 LDT */
2601	"Tss16B", /* 3 0011 Busy 16-bit TSS */
2602	"Call16", /* 4 0100 16-bit Call Gate */
2603	"TaskG ", /* 5 0101 Task Gate */
2604	"Int16 ", /* 6 0110 16-bit Interrupt Gate */
2605	"Trap16", /* 7 0111 16-bit Trap Gate */
2606	"Ill-8 ", /* 8 1000 Reserved (Illegal) */
2607	"Tss32A", /* 9 1001 Available 32-bit TSS */
2608	"Ill-A ", /* A 1010 Reserved (Illegal) */
2609	"Tss32B", /* B 1011 Busy 32-bit TSS */
2610	"Call32", /* C 1100 32-bit Call Gate */
2611	"Ill-D ", /* D 1101 Reserved (Illegal) */
2612	"Int32 ", /* E 1110 32-bit Interrupt Gate */
2613	"Trap32" /* F 1111 32-bit Trap Gate */
2614	};
2615	switch (pDesc->Gen.u4Type)
2616	{
2617	/* raw */
2618	case X86_SEL_TYPE_SYS_UNDEFINED:
2619	case X86_SEL_TYPE_SYS_UNDEFINED2:
2620	case X86_SEL_TYPE_SYS_UNDEFINED4:
2621	case X86_SEL_TYPE_SYS_UNDEFINED3:
2622	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%04x %s %.8Rhxs DPL=%d %s%s\n",
2623	iEntry, s_apszTypes[pDesc->Gen.u4Type], pDesc,
2624	pDesc->Gen.u2Dpl, pszPresent, pszHyper);
2625	break;
2626
2627	case X86_SEL_TYPE_SYS_286_TSS_AVAIL:
2628	case X86_SEL_TYPE_SYS_386_TSS_AVAIL:
2629	case X86_SEL_TYPE_SYS_286_TSS_BUSY:
2630	case X86_SEL_TYPE_SYS_386_TSS_BUSY:
2631	case X86_SEL_TYPE_SYS_LDT:
2632	{
2633	const char *pszGranularity = pDesc->Gen.u1Granularity ? "G" : " ";
2634	const char *pszBusy = pDesc->Gen.u4Type & BIT(1) ? "B " : "NB";
2635	const char *pszBig = pDesc->Gen.u1DefBig ? "BIG" : " ";
2636	uint32_t u32Base = pDesc->Gen.u16BaseLow
2637	\| ((uint32_t)pDesc->Gen.u8BaseHigh1 << 16)
2638	\| ((uint32_t)pDesc->Gen.u8BaseHigh2 << 24);
2639	uint32_t cbLimit = pDesc->Gen.u16LimitLow \| (pDesc->Gen.u4LimitHigh << 16);
2640	if (pDesc->Gen.u1Granularity)
2641	cbLimit <<= PAGE_SHIFT;
2642
2643	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%04x %s Bas=%08x Lim=%08x DPL=%d %s %s %s %s AVL=%d R=%d%s\n",
2644	iEntry, s_apszTypes[pDesc->Gen.u4Type], u32Base, cbLimit,
2645	pDesc->Gen.u2Dpl, pszPresent, pszBusy, pszGranularity, pszBig,
2646	pDesc->Gen.u1Available, pDesc->Gen.u1Reserved \| (pDesc->Gen.u1DefBig << 1),
2647	pszHyper);
2648	break;
2649	}
2650
2651	case X86_SEL_TYPE_SYS_TASK_GATE:
2652	{
2653	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%04x %s TSS=%04x DPL=%d %s%s\n",
2654	iEntry, s_apszTypes[pDesc->Gen.u4Type], pDesc->au16[1],
2655	pDesc->Gen.u2Dpl, pszPresent, pszHyper);
2656	break;
2657	}
2658
2659	case X86_SEL_TYPE_SYS_286_CALL_GATE:
2660	case X86_SEL_TYPE_SYS_386_CALL_GATE:
2661	{
2662	unsigned cParams = pDesc->au8[0] & 0x1f;
2663	const char *pszCountOf = pDesc->Gen.u4Type & BIT(3) ? "DC" : "WC";
2664	RTSEL sel = pDesc->au16[1];
2665	uint32_t off = pDesc->au16[0] \| ((uint32_t)pDesc->au16[3] << 16);
2666	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%04x %s Sel:Off=%04x:%08x DPL=%d %s %s=%d%s\n",
2667	iEntry, s_apszTypes[pDesc->Gen.u4Type], sel, off,
2668	pDesc->Gen.u2Dpl, pszPresent, pszCountOf, cParams, pszHyper);
2669	break;
2670	}
2671
2672	case X86_SEL_TYPE_SYS_286_INT_GATE:
2673	case X86_SEL_TYPE_SYS_386_INT_GATE:
2674	case X86_SEL_TYPE_SYS_286_TRAP_GATE:
2675	case X86_SEL_TYPE_SYS_386_TRAP_GATE:
2676	{
2677	RTSEL sel = pDesc->au16[1];
2678	uint32_t off = pDesc->au16[0] \| ((uint32_t)pDesc->au16[3] << 16);
2679	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%04x %s Sel:Off=%04x:%08x DPL=%d %s%s\n",
2680	iEntry, s_apszTypes[pDesc->Gen.u4Type], sel, off,
2681	pDesc->Gen.u2Dpl, pszPresent, pszHyper);
2682	break;
2683	}
2684
2685	/* impossible, just it's necessary to keep gcc happy. */
2686	default:
2687	return VINF_SUCCESS;
2688	}
2689	}
2690	return rc;
2691	}
2692
2693
2694	/**
2695	* The 'dg', 'dga', 'dl' and 'dla' commands.
2696	*
2697	* @returns VBox status.
2698	* @param pCmd Pointer to the command descriptor (as registered).
2699	* @param pCmdHlp Pointer to command helper functions.
2700	* @param pVM Pointer to the current VM (if any).
2701	* @param paArgs Pointer to (readonly) array of arguments.
2702	* @param cArgs Number of arguments in the array.
2703	*/
2704	static DECLCALLBACK(int) dbgcCmdDumpDT(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
2705	{
2706	/*
2707	* Validate input.
2708	*/
2709	if (!pVM)
2710	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: No VM.\n");
2711
2712	/*
2713	* Get the CPU mode, check which command variation this is
2714	* and fix a default parameter if needed.
2715	*/
2716	CPUMMODE enmMode = CPUMGetGuestMode(pVM);
2717	bool fGdt = pCmd->pszCmd[1] == 'g';
2718	bool fAll = pCmd->pszCmd[2] == 'a';
2719
2720	DBGCVAR Var;
2721	if (!cArgs)
2722	{
2723	cArgs = 1;
2724	paArgs = &Var;
2725	Var.enmType = DBGCVAR_TYPE_NUMBER;
2726	Var.u.u64Number = fGdt ? 0 : 4;
2727	Var.enmRangeType = DBGCVAR_RANGE_ELEMENTS;
2728	Var.u64Range = 1024;
2729	}
2730
2731	/*
2732	* Process the arguments.
2733	*/
2734	for (unsigned i = 0; i < cArgs; i++)
2735	{
2736	/*
2737	* Retrive the selector value from the argument.
2738	* The parser may confuse pointers and numbers if more than one
2739	* argument is given, that that into account.
2740	*/
2741	/* check that what've got makes sense as we don't trust the parser yet. */
2742	if ( paArgs[i].enmType != DBGCVAR_TYPE_NUMBER
2743	&& !DBGCVAR_ISPOINTER(paArgs[i].enmType))
2744	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: arg #%u isn't of number or pointer type but %d.\n", i, paArgs[i].enmType);
2745	unsigned u64;
2746	unsigned cSels = 1;
2747	switch (paArgs[i].enmType)
2748	{
2749	case DBGCVAR_TYPE_NUMBER:
2750	u64 = paArgs[i].u.u64Number;
2751	if (paArgs[i].enmRangeType != DBGCVAR_RANGE_NONE)
2752	cSels = RT_MIN(paArgs[i].u64Range, 1024);
2753	break;
2754	case DBGCVAR_TYPE_GC_FAR: u64 = paArgs[i].u.GCFar.sel; break;
2755	case DBGCVAR_TYPE_GC_FLAT: u64 = paArgs[i].u.GCFlat; break;
2756	case DBGCVAR_TYPE_GC_PHYS: u64 = paArgs[i].u.GCPhys; break;
2757	case DBGCVAR_TYPE_HC_FAR: u64 = paArgs[i].u.HCFar.sel; break;
2758	case DBGCVAR_TYPE_HC_FLAT: u64 = (uintptr_t)paArgs[i].u.pvHCFlat; break;
2759	case DBGCVAR_TYPE_HC_PHYS: u64 = paArgs[i].u.HCPhys; break;
2760	default: u64 = _64K; break;
2761	}
2762	if (u64 < _64K)
2763	{
2764	unsigned Sel = (RTSEL)u64;
2765
2766	/*
2767	* Dump the specified range.
2768	*/
2769	bool fSingle = cSels == 1;
2770	while ( cSels-- > 0
2771	&& Sel < _64K)
2772	{
2773	SELMSELINFO SelInfo;
2774	int rc = SELMR3GetSelectorInfo(pVM, Sel, &SelInfo);
2775	if (RT_SUCCESS(rc))
2776	{
2777	if (SelInfo.fRealMode)
2778	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%04x RealM Bas=%04x Lim=%04x\n",
2779	Sel, (unsigned)SelInfo.GCPtrBase, (unsigned)SelInfo.cbLimit);
2780	else if (fAll \|\| fSingle \|\| SelInfo.Raw.Gen.u1Present)
2781	{
2782	if (enmMode == CPUMMODE_PROTECTED)
2783	rc = dbgcCmdDumpDTWorker32(pCmdHlp, (PX86DESC)&SelInfo.Raw, Sel, SelInfo.fHyper);
2784	else
2785	{
2786	bool fDblSkip = false;
2787	rc = dbgcCmdDumpDTWorker64(pCmdHlp, (PX86DESC64)&SelInfo.Raw, Sel, SelInfo.fHyper, &fDblSkip);
2788	if (fDblSkip)
2789	Sel += 4;
2790	}
2791	}
2792	}
2793	else
2794	{
2795	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%04x %Vrc\n", Sel, rc);
2796	if (!fAll)
2797	return rc;
2798	}
2799	if (RT_FAILURE(rc))
2800	return rc;
2801
2802	/* next */
2803	Sel += 4;
2804	}
2805	}
2806	else
2807	pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: %llx is out of bounds\n", u64);
2808	}
2809
2810	NOREF(pResult);
2811	return VINF_SUCCESS;
2812	}
2813
2814
2815	/**
2816	* The 'di' and 'dia' commands.
2817	*
2818	* @returns VBox status.
2819	* @param pCmd Pointer to the command descriptor (as registered).
2820	* @param pCmdHlp Pointer to command helper functions.
2821	* @param pVM Pointer to the current VM (if any).
2822	* @param paArgs Pointer to (readonly) array of arguments.
2823	* @param cArgs Number of arguments in the array.
2824	*/
2825	static DECLCALLBACK(int) dbgcCmdDumpIDT(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
2826	{
2827	/*
2828	* Validate input.
2829	*/
2830	if (!pVM)
2831	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: No VM.\n");
2832
2833	/*
2834	* Establish some stuff like the current IDTR and CPU mode,
2835	* and fix a default parameter.
2836	*/
2837	uint16_t cbLimit;
2838	RTGCUINTPTR GCPtrBase = CPUMGetGuestIDTR(pVM, &cbLimit);
2839	CPUMMODE enmMode = CPUMGetGuestMode(pVM);
2840	size_t cbEntry;
2841	switch (enmMode)
2842	{
2843	case CPUMMODE_REAL: cbEntry = sizeof(RTFAR16); break;
2844	case CPUMMODE_PROTECTED: cbEntry = sizeof(X86DESC); break;
2845	case CPUMMODE_LONG: cbEntry = sizeof(X86DESC64); break;
2846	default:
2847	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Invalid CPU mode %d.\n", enmMode);
2848	}
2849
2850	bool fAll = pCmd->pszCmd[2] == 'a';
2851	DBGCVAR Var;
2852	if (!cArgs)
2853	{
2854	cArgs = 1;
2855	paArgs = &Var;
2856	Var.enmType = DBGCVAR_TYPE_NUMBER;
2857	Var.u.u64Number = 0;
2858	Var.enmRangeType = DBGCVAR_RANGE_ELEMENTS;
2859	Var.u64Range = 256;
2860	}
2861
2862	/*
2863	* Process the arguments.
2864	*/
2865	for (unsigned i = 0; i < cArgs; i++)
2866	{
2867	/* check that what've got makes sense as we don't trust the parser yet. */
2868	if (paArgs[i].enmType != DBGCVAR_TYPE_NUMBER)
2869	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: arg #%u isn't of number type but %d.\n", i, paArgs[i].enmType);
2870	if (paArgs[i].u.u64Number < 256)
2871	{
2872	RTGCUINTPTR iInt = paArgs[i].u.u64Number;
2873	unsigned cInts = paArgs[i].enmRangeType != DBGCVAR_RANGE_NONE
2874	? paArgs[i].u64Range
2875	: 1;
2876	bool fSingle = cInts == 1;
2877	while ( cInts-- > 0
2878	&& iInt < 256)
2879	{
2880	/*
2881	* Try read it.
2882	*/
2883	union
2884	{
2885	RTFAR16 Real;
2886	X86DESC Prot;
2887	X86DESC64 Long;
2888	} u;
2889	if (iInt * cbEntry + (cbEntry - 1) > cbLimit)
2890	{
2891	pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%04x not within the IDT\n", (unsigned)iInt);
2892	if (!fAll && !fSingle)
2893	return VINF_SUCCESS;
2894	}
2895	DBGCVAR AddrVar;
2896	AddrVar.enmType = DBGCVAR_TYPE_GC_FLAT;
2897	AddrVar.u.GCFlat = GCPtrBase + iInt * cbEntry;
2898	AddrVar.enmRangeType = DBGCVAR_RANGE_NONE;
2899	int rc = pCmdHlp->pfnMemRead(pCmdHlp, pVM, &u, cbEntry, &AddrVar, NULL);
2900	if (VBOX_FAILURE(rc))
2901	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Reading IDT entry %#04x.\n", (unsigned)iInt);
2902
2903	/*
2904	* Display it.
2905	*/
2906	switch (enmMode)
2907	{
2908	case CPUMMODE_REAL:
2909	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%04x %RTfp16\n", (unsigned)iInt, u.Real);
2910	/** @todo resolve 16:16 IDTE to a symbol */
2911	break;
2912	case CPUMMODE_PROTECTED:
2913	if (fAll \|\| fSingle \|\| u.Prot.Gen.u1Present)
2914	rc = dbgcCmdDumpDTWorker32(pCmdHlp, &u.Prot, iInt, false);
2915	break;
2916	case CPUMMODE_LONG:
2917	if (fAll \|\| fSingle \|\| u.Long.Gen.u1Present)
2918	rc = dbgcCmdDumpDTWorker64(pCmdHlp, &u.Long, iInt, false, NULL);
2919	break;
2920	default: break; /* to shut up gcc */
2921	}
2922	if (RT_FAILURE(rc))
2923	return rc;
2924
2925	/* next */
2926	iInt++;
2927	}
2928	}
2929	else
2930	pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: %llx is out of bounds (max 256)\n", paArgs[i].u.u64Number);
2931	}
2932
2933	NOREF(pResult);
2934	return VINF_SUCCESS;
2935	}
2936
2937
2938	/**
2939	* The 'da', 'dq', 'dd', 'dw' and 'db' commands.
2940	*
2941	* @returns VBox status.
2942	* @param pCmd Pointer to the command descriptor (as registered).
2943	* @param pCmdHlp Pointer to command helper functions.
2944	* @param pVM Pointer to the current VM (if any).
2945	* @param paArgs Pointer to (readonly) array of arguments.
2946	* @param cArgs Number of arguments in the array.
2947	*/
2948	static DECLCALLBACK(int) dbgcCmdDumpMem(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
2949	{
2950	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2951
2952	/*
2953	* Validate input.
2954	*/
2955	if ( cArgs > 1
2956	\|\| (cArgs == 1 && !DBGCVAR_ISPOINTER(paArgs[0].enmType)))
2957	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "internal error: The parser doesn't do its job properly yet.. It might help to use the '%%' operator.\n");
2958	if (!pVM)
2959	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: No VM.\n");
2960
2961	/*
2962	* Figure out the element size.
2963	*/
2964	size_t cbElement;
2965	bool fAscii = false;
2966	switch (pCmd->pszCmd[1])
2967	{
2968	default:
2969	case 'b': cbElement = 1; break;
2970	case 'w': cbElement = 2; break;
2971	case 'd': cbElement = 4; break;
2972	case 'q': cbElement = 8; break;
2973	case 'a':
2974	cbElement = 1;
2975	fAscii = true;
2976	break;
2977	case '\0':
2978	fAscii = !!(pDbgc->cbDumpElement & 0x80000000);
2979	cbElement = pDbgc->cbDumpElement & 0x7fffffff;
2980	if (!cbElement)
2981	cbElement = 1;
2982	break;
2983	}
2984
2985	/*
2986	* Find address.
2987	*/
2988	if (!cArgs)
2989	pDbgc->DumpPos.enmRangeType = DBGCVAR_RANGE_NONE;
2990	else
2991	pDbgc->DumpPos = paArgs[0];
2992
2993	/*
2994	* Range.
2995	*/
2996	switch (pDbgc->DumpPos.enmRangeType)
2997	{
2998	case DBGCVAR_RANGE_NONE:
2999	pDbgc->DumpPos.enmRangeType = DBGCVAR_RANGE_BYTES;
3000	pDbgc->DumpPos.u64Range = 0x60;
3001	break;
3002
3003	case DBGCVAR_RANGE_ELEMENTS:
3004	if (pDbgc->DumpPos.u64Range > 2048)
3005	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Too many elements requested. Max is 2048 elements.\n");
3006	pDbgc->DumpPos.enmRangeType = DBGCVAR_RANGE_BYTES;
3007	pDbgc->DumpPos.u64Range = (cbElement ? cbElement : 1) * pDbgc->DumpPos.u64Range;
3008	break;
3009
3010	case DBGCVAR_RANGE_BYTES:
3011	if (pDbgc->DumpPos.u64Range > 65536)
3012	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: The requested range is too big. Max is 64KB.\n");
3013	break;
3014
3015	default:
3016	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "internal error: Unknown range type %d.\n", pDbgc->DumpPos.enmRangeType);
3017	}
3018
3019	/*
3020	* Do the dumping.
3021	*/
3022	pDbgc->cbDumpElement = cbElement \| (fAscii << 31);
3023	int cbLeft = (int)pDbgc->DumpPos.u64Range;
3024	uint8_t u8Prev = '\0';
3025	for (;;)
3026	{
3027	/*
3028	* Read memory.
3029	*/
3030	char achBuffer[16];
3031	size_t cbReq = RT_MIN((int)sizeof(achBuffer), cbLeft);
3032	size_t cb = RT_MIN((int)sizeof(achBuffer), cbLeft);
3033	int rc = pCmdHlp->pfnMemRead(pCmdHlp, pVM, &achBuffer, cbReq, &pDbgc->DumpPos, &cb);
3034	if (VBOX_FAILURE(rc))
3035	{
3036	if (u8Prev && u8Prev != '\n')
3037	pCmdHlp->pfnPrintf(pCmdHlp, NULL, "\n");
3038	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Reading memory at %DV.\n", &pDbgc->DumpPos);
3039	}
3040
3041	/*
3042	* Display it.
3043	*/
3044	memset(&achBuffer[cb], 0, sizeof(achBuffer) - cb);
3045	if (!fAscii)
3046	{
3047	pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%DV:", &pDbgc->DumpPos);
3048	unsigned i;
3049	for (i = 0; i < cb; i += cbElement)
3050	{
3051	const char *pszSpace = " ";
3052	if (cbElement <= 2 && i == 8 && !fAscii)
3053	pszSpace = "-";
3054	switch (cbElement)
3055	{
3056	case 1: pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%s%02x", pszSpace, (uint8_t )&achBuffer[i]); break;
3057	case 2: pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%s%04x", pszSpace, (uint16_t )&achBuffer[i]); break;
3058	case 4: pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%s%08x", pszSpace, (uint32_t )&achBuffer[i]); break;
3059	case 8: pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%s%016llx", pszSpace, (uint64_t )&achBuffer[i]); break;
3060	}
3061	}
3062
3063	/* chars column */
3064	if (pDbgc->cbDumpElement == 1)
3065	{
3066	while (i++ < sizeof(achBuffer))
3067	pCmdHlp->pfnPrintf(pCmdHlp, NULL, " ");
3068	pCmdHlp->pfnPrintf(pCmdHlp, NULL, " ");
3069	for (i = 0; i < cb; i += cbElement)
3070	{
3071	uint8_t u8 = (uint8_t )&achBuffer[i];
3072	if (isprint(u8) && u8 < 127)
3073	pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%c", u8);
3074	else
3075	pCmdHlp->pfnPrintf(pCmdHlp, NULL, ".");
3076	}
3077	}
3078	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "\n");
3079	}
3080	else
3081	{
3082	/*
3083	* We print up to the first zero and stop there.
3084	* Only printables + '\t' and '\n' are printed.
3085	*/
3086	if (!u8Prev)
3087	pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%DV:\n", &pDbgc->DumpPos);
3088	uint8_t u8 = '\0';
3089	unsigned i;
3090	for (i = 0; i < cb; i++)
3091	{
3092	u8Prev = u8;
3093	u8 = (uint8_t )&achBuffer[i];
3094	if ( u8 < 127
3095	&& ( isprint(u8)
3096	\|\| u8 == '\t'
3097	\|\| u8 == '\n'))
3098	pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%c", u8);
3099	else if (!u8)
3100	break;
3101	else
3102	pCmdHlp->pfnPrintf(pCmdHlp, NULL, "\\x%x", u8);
3103	}
3104	if (u8 == '\0')
3105	cbLeft = cb = i + 1;
3106	if (cbLeft - cb <= 0 && u8Prev != '\n')
3107	pCmdHlp->pfnPrintf(pCmdHlp, NULL, "\n");
3108	}
3109
3110	/*
3111	* Advance
3112	*/
3113	cbLeft -= cb;
3114	rc = pCmdHlp->pfnEval(pCmdHlp, &pDbgc->DumpPos, "(%Dv) + %x", &pDbgc->DumpPos, cb);
3115	if (VBOX_FAILURE(rc))
3116	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Expression: (%Dv) + %x\n", &pDbgc->DumpPos, cb);
3117	if (cbLeft <= 0)
3118	break;
3119	}
3120
3121	NOREF(pCmd); NOREF(pResult);
3122	return VINF_SUCCESS;
3123	}
3124
3125
3126	/**
3127	* Best guess at which paging mode currently applies to the guest
3128	* paging structures.
3129	*
3130	* This have to come up with a decent answer even when the guest
3131	* is in non-paged protected mode or real mode.
3132	*
3133	* @returns cr3.
3134	* @param pDbgc The DBGC instance.
3135	* @param pfPAE Where to store the page address extension indicator.
3136	* @param pfLME Where to store the long mode enabled indicator.
3137	* @param pfPSE Where to store the page size extension indicator.
3138	* @param pfPGE Where to store the page global enabled indicator.
3139	* @param pfNXE Where to store the no-execution enabled inidicator.
3140	*/
3141	static RTGCPHYS dbgcGetGuestPageMode(PDBGC pDbgc, bool pfPAE, bool pfLME, bool pfPSE, bool pfPGE, bool *pfNXE)
3142	{
3143	RTGCUINTREG cr4 = CPUMGetGuestCR4(pDbgc->pVM);
3144	*pfPSE = !!(cr4 & X86_CR4_PSE);
3145	*pfPGE = !!(cr4 & X86_CR4_PGE);
3146	*pfPAE = !!(cr4 & X86_CR4_PAE);
3147	*pfLME = CPUMGetGuestMode(pDbgc->pVM) == CPUMMODE_LONG;
3148	pfNXE = false; / GUEST64 GUESTNX */
3149	return CPUMGetGuestCR3(pDbgc->pVM);
3150	}
3151
3152
3153	/**
3154	* Determin the shadow paging mode.
3155	*
3156	* @returns cr3.
3157	* @param pDbgc The DBGC instance.
3158	* @param pfPAE Where to store the page address extension indicator.
3159	* @param pfLME Where to store the long mode enabled indicator.
3160	* @param pfPSE Where to store the page size extension indicator.
3161	* @param pfPGE Where to store the page global enabled indicator.
3162	* @param pfNXE Where to store the no-execution enabled inidicator.
3163	*/
3164	static RTHCPHYS dbgcGetShadowPageMode(PDBGC pDbgc, bool pfPAE, bool pfLME, bool pfPSE, bool pfPGE, bool *pfNXE)
3165	{
3166	*pfPSE = true;
3167	*pfPGE = false;
3168	switch (PGMGetShadowMode(pDbgc->pVM))
3169	{
3170	default:
3171	case PGMMODE_32_BIT:
3172	pfPAE = pfLME = *pfNXE = false;
3173	break;
3174	case PGMMODE_PAE:
3175	pfLME = pfNXE = false;
3176	*pfPAE = true;
3177	break;
3178	case PGMMODE_PAE_NX:
3179	*pfLME = false;
3180	pfPAE = pfNXE = true;
3181	break;
3182	case PGMMODE_AMD64:
3183	*pfNXE = false;
3184	pfPAE = pfLME = true;
3185	break;
3186	case PGMMODE_AMD64_NX:
3187	pfPAE = pfLME = *pfNXE = true;
3188	break;
3189	}
3190	return PGMGetHyperCR3(pDbgc->pVM);
3191	}
3192
3193
3194	/**
3195	* The 'dpd', 'dpda', 'dpdb', 'dpdg' and 'dpdh' commands.
3196	*
3197	* @returns VBox status.
3198	* @param pCmd Pointer to the command descriptor (as registered).
3199	* @param pCmdHlp Pointer to command helper functions.
3200	* @param pVM Pointer to the current VM (if any).
3201	* @param paArgs Pointer to (readonly) array of arguments.
3202	* @param cArgs Number of arguments in the array.
3203	*/
3204	static DECLCALLBACK(int) dbgcCmdDumpPageDir(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
3205	{
3206	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
3207
3208	/*
3209	* Validate input.
3210	*/
3211	if ( cArgs > 1
3212	\|\| (cArgs == 1 && pCmd->pszCmd[3] == 'a' && !DBGCVAR_ISPOINTER(paArgs[0].enmType))
3213	\|\| (cArgs == 1 && pCmd->pszCmd[3] != 'a' && !(paArgs[0].enmType == DBGCVAR_TYPE_NUMBER \|\| DBGCVAR_ISPOINTER(paArgs[0].enmType)))
3214	)
3215	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "internal error: The parser doesn't do its job properly yet.. It might help to use the '%%' operator.\n");
3216	if (!pVM)
3217	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: No VM.\n");
3218
3219	/*
3220	* Guest or shadow page directories? Get the paging parameters.
3221	*/
3222	bool fGuest = pCmd->pszCmd[3] != 'h';
3223	if (!pCmd->pszCmd[3] \|\| pCmd->pszCmd[3] == 'a')
3224	fGuest = paArgs[0].enmType == DBGCVAR_TYPE_NUMBER
3225	? pDbgc->fRegCtxGuest
3226	: DBGCVAR_ISGCPOINTER(paArgs[0].enmType);
3227
3228	bool fPAE, fLME, fPSE, fPGE, fNXE;
3229	uint64_t cr3 = fGuest
3230	? dbgcGetGuestPageMode(pDbgc, &fPAE, &fLME, &fPSE, &fPGE, &fNXE)
3231	: dbgcGetShadowPageMode(pDbgc, &fPAE, &fLME, &fPSE, &fPGE, &fNXE);
3232	const unsigned cbEntry = fPAE ? sizeof(X86PTEPAE) : sizeof(X86PTE);
3233
3234	/*
3235	* Setup default arugment if none was specified.
3236	* Fix address / index confusion.
3237	*/
3238	DBGCVAR VarDefault;
3239	if (!cArgs)
3240	{
3241	if (pCmd->pszCmd[3] == 'a')
3242	{
3243	if (fLME \|\| fPAE)
3244	return DBGCCmdHlpPrintf(pCmdHlp, "Default argument for 'dpda' hasn't been fully implemented yet. Try with an address or use one of the other commands.\n");
3245	if (fGuest)
3246	DBGCVAR_INIT_GC_PHYS(&VarDefault, cr3);
3247	else
3248	DBGCVAR_INIT_HC_PHYS(&VarDefault, cr3);
3249	}
3250	else
3251	DBGCVAR_INIT_GC_FLAT(&VarDefault, 0);
3252	paArgs = &VarDefault;
3253	cArgs = 1;
3254	}
3255	else if (paArgs[0].enmType == DBGCVAR_TYPE_NUMBER)
3256	{
3257	Assert(pCmd->pszCmd[3] != 'a');
3258	VarDefault = paArgs[0];
3259	if (VarDefault.u.u64Number <= 1024)
3260	{
3261	if (fPAE)
3262	return DBGCCmdHlpPrintf(pCmdHlp, "PDE indexing is only implemented for 32-bit paging.\n");
3263	if (VarDefault.u.u64Number >= PAGE_SIZE / cbEntry)
3264	return DBGCCmdHlpPrintf(pCmdHlp, "PDE index is out of range [0..%d].\n", PAGE_SIZE / cbEntry - 1);
3265	VarDefault.u.u64Number <<= X86_PD_SHIFT;
3266	}
3267	VarDefault.enmType = DBGCVAR_TYPE_GC_FLAT;
3268	paArgs = &VarDefault;
3269	}
3270
3271	/*
3272	* Locate the PDE to start displaying at.
3273	*
3274	* The 'dpda' command takes the address of a PDE, while the others are guest
3275	* virtual address which PDEs should be displayed. So, 'dpda' is rather simple
3276	* while the others require us to do all the tedious walking thru the paging
3277	* hierarchy to find the intended PDE.
3278	*/
3279	unsigned iEntry = ~0U; /* The page directory index. ~0U for 'dpta'. */
3280	DBGCVAR VarGCPtr; /* The GC address corresponding to the current PDE (iEntry != ~0U). */
3281	DBGCVAR VarPDEAddr; /* The address of the current PDE. */
3282	unsigned cEntries; /* The number of entries to display. */
3283	unsigned cEntriesMax; /* The max number of entries to display. */
3284	int rc;
3285	if (pCmd->pszCmd[3] == 'a')
3286	{
3287	VarPDEAddr = paArgs[0];
3288	switch (VarPDEAddr.enmRangeType)
3289	{
3290	case DBGCVAR_RANGE_BYTES: cEntries = VarPDEAddr.u64Range / cbEntry; break;
3291	case DBGCVAR_RANGE_ELEMENTS: cEntries = VarPDEAddr.u64Range; break;
3292	default: cEntries = 10; break;
3293	}
3294	cEntriesMax = PAGE_SIZE / cbEntry;
3295	}
3296	else
3297	{
3298	/*
3299	* Determin the range.
3300	*/
3301	switch (paArgs[0].enmRangeType)
3302	{
3303	case DBGCVAR_RANGE_BYTES: cEntries = paArgs[0].u64Range / PAGE_SIZE; break;
3304	case DBGCVAR_RANGE_ELEMENTS: cEntries = paArgs[0].u64Range; break;
3305	default: cEntries = 10; break;
3306	}
3307
3308	/*
3309	* Normalize the input address, it must be a flat GC address.
3310	*/
3311	rc = pCmdHlp->pfnEval(pCmdHlp, &VarGCPtr, "%%(%Dv)", &paArgs[0]);
3312	if (VBOX_FAILURE(rc))
3313	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "%%(%Dv)", &paArgs[0]);
3314	if (VarGCPtr.enmType == DBGCVAR_TYPE_HC_FLAT)
3315	{
3316	VarGCPtr.u.GCFlat = (uintptr_t)VarGCPtr.u.pvHCFlat;
3317	VarGCPtr.enmType = DBGCVAR_TYPE_GC_FLAT;
3318	}
3319	if (fPAE)
3320	VarGCPtr.u.GCFlat &= ~(((RTGCPTR)1 << X86_PD_PAE_SHIFT) - 1);
3321	else
3322	VarGCPtr.u.GCFlat &= ~(((RTGCPTR)1 << X86_PD_SHIFT) - 1);
3323
3324	/*
3325	* Do the paging walk until we get to the page directory.
3326	*/
3327	DBGCVAR VarCur;
3328	if (fGuest)
3329	DBGCVAR_INIT_GC_PHYS(&VarCur, cr3);
3330	else
3331	DBGCVAR_INIT_HC_PHYS(&VarCur, cr3);
3332	if (fLME)
3333	{
3334	/* Page Map Level 4 Lookup. */
3335	/* Check if it's a valid address first? */
3336	VarCur.u.u64Number &= X86_PTE_PAE_PG_MASK;
3337	VarCur.u.u64Number += (((uint64_t)VarGCPtr.u.GCFlat >> X86_PML4_SHIFT) & X86_PML4_MASK) * sizeof(X86PML4E);
3338	X86PML4E Pml4e;
3339	rc = pCmdHlp->pfnMemRead(pCmdHlp, pVM, &Pml4e, sizeof(Pml4e), &VarCur, NULL);
3340	if (VBOX_FAILURE(rc))
3341	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "Reading PML4E memory at %DV.\n", &VarCur);
3342	if (!Pml4e.n.u1Present)
3343	return DBGCCmdHlpPrintf(pCmdHlp, "Page directory pointer table is not present for %Dv.\n", &VarGCPtr);
3344
3345	VarCur.u.u64Number = Pml4e.u & X86_PML4E_PG_MASK;
3346	Assert(fPAE);
3347	}
3348	if (fPAE)
3349	{
3350	/* Page directory pointer table. */
3351	X86PDPE Pdpe;
3352	VarCur.u.u64Number += ((VarGCPtr.u.GCFlat >> X86_PDPTR_SHIFT) & X86_PDPTR_MASK) * sizeof(Pdpe);
3353	rc = pCmdHlp->pfnMemRead(pCmdHlp, pVM, &Pdpe, sizeof(Pdpe), &VarCur, NULL);
3354	if (VBOX_FAILURE(rc))
3355	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "Reading PDPE memory at %DV.\n", &VarCur);
3356	if (!Pdpe.n.u1Present)
3357	return DBGCCmdHlpPrintf(pCmdHlp, "Page directory is not present for %Dv.\n", &VarGCPtr);
3358
3359	iEntry = (VarGCPtr.u.GCFlat >> X86_PD_PAE_SHIFT) & X86_PD_PAE_MASK;
3360	VarPDEAddr = VarCur;
3361	VarPDEAddr.u.u64Number = Pdpe.u & X86_PDPE_PG_MASK;
3362	VarPDEAddr.u.u64Number += iEntry * sizeof(X86PDEPAE);
3363	}
3364	else
3365	{
3366	/* 32-bit legacy - CR3 == page directory. */
3367	iEntry = (VarGCPtr.u.GCFlat >> X86_PD_SHIFT) & X86_PD_MASK;
3368	VarPDEAddr = VarCur;
3369	VarPDEAddr.u.u64Number += iEntry * sizeof(X86PDE);
3370	}
3371	cEntriesMax = (PAGE_SIZE - iEntry) / cbEntry;
3372	iEntry /= cbEntry;
3373	}
3374
3375	/* adjust cEntries */
3376	cEntries = RT_MAX(1, cEntries);
3377	cEntries = RT_MIN(cEntries, cEntriesMax);
3378
3379	/*
3380	* The display loop.
3381	*/
3382	DBGCCmdHlpPrintf(pCmdHlp, iEntry != ~0U ? "%DV (index %#x):\n" : "%DV:\n",
3383	&VarPDEAddr, iEntry);
3384	do
3385	{
3386	/*
3387	* Read.
3388	*/
3389	X86PDEPAE Pde;
3390	Pde.u = 0;
3391	rc = pCmdHlp->pfnMemRead(pCmdHlp, pVM, &Pde, cbEntry, &VarPDEAddr, NULL);
3392	if (VBOX_FAILURE(rc))
3393	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Reading PDE memory at %DV.\n", &VarPDEAddr);
3394
3395	/*
3396	* Display.
3397	*/
3398	if (iEntry != ~0U)
3399	{
3400	DBGCCmdHlpPrintf(pCmdHlp, "%03x %DV: ", iEntry, &VarGCPtr);
3401	iEntry++;
3402	}
3403	if (fPSE && Pde.b.u1Size)
3404	DBGCCmdHlpPrintf(pCmdHlp,
3405	fPAE
3406	? "%016llx big phys=%016llx %s %s %s %s %s avl=%02x %s %s %s %s %s"
3407	: "%08llx big phys=%08llx %s %s %s %s %s avl=%02x %s %s %s %s %s",
3408	Pde.u,
3409	Pde.u & X86_PDE_PAE_PG_MASK,
3410	Pde.b.u1Present ? "p " : "np",
3411	Pde.b.u1Write ? "w" : "r",
3412	Pde.b.u1User ? "u" : "s",
3413	Pde.b.u1Accessed ? "a " : "na",
3414	Pde.b.u1Dirty ? "d " : "nd",
3415	Pde.b.u3Available,
3416	Pde.b.u1Global ? (fPGE ? "g" : "G") : " ",
3417	Pde.b.u1WriteThru ? "pwt" : " ",
3418	Pde.b.u1CacheDisable ? "pcd" : " ",
3419	Pde.b.u1PAT ? "pat" : "",
3420	Pde.b.u1NoExecute ? (fNXE ? "nx" : "NX") : " ");
3421	else
3422	DBGCCmdHlpPrintf(pCmdHlp,
3423	fPAE
3424	? "%016llx 4kb phys=%016llx %s %s %s %s %s avl=%02x %s %s %s %s"
3425	: "%08llx 4kb phys=%08llx %s %s %s %s %s avl=%02x %s %s %s %s",
3426	Pde.u,
3427	Pde.u & X86_PDE_PAE_PG_MASK,
3428	Pde.n.u1Present ? "p " : "np",
3429	Pde.n.u1Write ? "w" : "r",
3430	Pde.n.u1User ? "u" : "s",
3431	Pde.n.u1Accessed ? "a " : "na",
3432	Pde.u & BIT(6) ? "6 " : " ",
3433	Pde.n.u3Available,
3434	Pde.u & BIT(8) ? "8" : " ",
3435	Pde.n.u1WriteThru ? "pwt" : " ",
3436	Pde.n.u1CacheDisable ? "pcd" : " ",
3437	Pde.u & BIT(7) ? "7" : "",
3438	Pde.n.u1NoExecute ? (fNXE ? "nx" : "NX") : " ");
3439	if (Pde.u & UINT64_C(0x7fff000000000000))
3440	DBGCCmdHlpPrintf(pCmdHlp, " weird=%RX64", (Pde.u & UINT64_C(0x7fff000000000000)));
3441	rc = DBGCCmdHlpPrintf(pCmdHlp, "\n");
3442	if (VBOX_FAILURE(rc))
3443	return rc;
3444
3445	/*
3446	* Advance.
3447	*/
3448	VarPDEAddr.u.u64Number += cbEntry;
3449	if (iEntry != ~0U)
3450	VarGCPtr.u.GCFlat += 1 << (fPAE ? X86_PD_PAE_SHIFT : X86_PD_SHIFT);
3451	} while (cEntries-- > 0);
3452
3453	NOREF(pResult);
3454	return VINF_SUCCESS;
3455	}
3456
3457
3458	/**
3459	* The 'dpdb' command.
3460	*
3461	* @returns VBox status.
3462	* @param pCmd Pointer to the command descriptor (as registered).
3463	* @param pCmdHlp Pointer to command helper functions.
3464	* @param pVM Pointer to the current VM (if any).
3465	* @param paArgs Pointer to (readonly) array of arguments.
3466	* @param cArgs Number of arguments in the array.
3467	*/
3468	static DECLCALLBACK(int) dbgcCmdDumpPageDirBoth(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
3469	{
3470	if (!pVM)
3471	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: No VM.\n");
3472	int rc1 = pCmdHlp->pfnExec(pCmdHlp, "dpdg %DV", &paArgs[0]);
3473	int rc2 = pCmdHlp->pfnExec(pCmdHlp, "dpdh %DV", &paArgs[0]);
3474	if (VBOX_FAILURE(rc1))
3475	return rc1;
3476	NOREF(pCmd); NOREF(paArgs); NOREF(cArgs); NOREF(pResult);
3477	return rc2;
3478	}
3479
3480
3481	/**
3482	* The 'dpg*' commands.
3483	*
3484	* @returns VBox status.
3485	* @param pCmd Pointer to the command descriptor (as registered).
3486	* @param pCmdHlp Pointer to command helper functions.
3487	* @param pVM Pointer to the current VM (if any).
3488	* @param paArgs Pointer to (readonly) array of arguments.
3489	* @param cArgs Number of arguments in the array.
3490	*/
3491	static DECLCALLBACK(int) dbgcCmdDumpPageTable(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
3492	{
3493	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
3494
3495	/*
3496	* Validate input.
3497	*/
3498	if ( cArgs != 1
3499	\|\| (pCmd->pszCmd[3] == 'a' && !DBGCVAR_ISPOINTER(paArgs[0].enmType))
3500	\|\| (pCmd->pszCmd[3] != 'a' && !(paArgs[0].enmType == DBGCVAR_TYPE_NUMBER \|\| DBGCVAR_ISPOINTER(paArgs[0].enmType)))
3501	)
3502	return DBGCCmdHlpPrintf(pCmdHlp, "internal error: The parser doesn't do its job properly yet.. It might help to use the '%%' operator.\n");
3503	if (!pVM)
3504	return DBGCCmdHlpPrintf(pCmdHlp, "error: No VM.\n");
3505
3506	/*
3507	* Guest or shadow page tables? Get the paging parameters.
3508	*/
3509	bool fGuest = pCmd->pszCmd[3] != 'h';
3510	if (!pCmd->pszCmd[3] \|\| pCmd->pszCmd[3] == 'a')
3511	fGuest = paArgs[0].enmType == DBGCVAR_TYPE_NUMBER
3512	? pDbgc->fRegCtxGuest
3513	: DBGCVAR_ISGCPOINTER(paArgs[0].enmType);
3514
3515	bool fPAE, fLME, fPSE, fPGE, fNXE;
3516	uint64_t cr3 = fGuest
3517	? dbgcGetGuestPageMode(pDbgc, &fPAE, &fLME, &fPSE, &fPGE, &fNXE)
3518	: dbgcGetShadowPageMode(pDbgc, &fPAE, &fLME, &fPSE, &fPGE, &fNXE);
3519	const unsigned cbEntry = fPAE ? sizeof(X86PTEPAE) : sizeof(X86PTE);
3520
3521	/*
3522	* Locate the PTE to start displaying at.
3523	*
3524	* The 'dpta' command takes the address of a PTE, while the others are guest
3525	* virtual address which PTEs should be displayed. So, 'pdta' is rather simple
3526	* while the others require us to do all the tedious walking thru the paging
3527	* hierarchy to find the intended PTE.
3528	*/
3529	unsigned iEntry = ~0U; /* The page table index. ~0U for 'dpta'. */
3530	DBGCVAR VarGCPtr; /* The GC address corresponding to the current PTE (iEntry != ~0U). */
3531	DBGCVAR VarPTEAddr; /* The address of the current PTE. */
3532	unsigned cEntries; /* The number of entries to display. */
3533	unsigned cEntriesMax; /* The max number of entries to display. */
3534	int rc;
3535	if (pCmd->pszCmd[3] == 'a')
3536	{
3537	VarPTEAddr = paArgs[0];
3538	switch (VarPTEAddr.enmRangeType)
3539	{
3540	case DBGCVAR_RANGE_BYTES: cEntries = VarPTEAddr.u64Range / cbEntry; break;
3541	case DBGCVAR_RANGE_ELEMENTS: cEntries = VarPTEAddr.u64Range; break;
3542	default: cEntries = 10; break;
3543	}
3544	cEntriesMax = PAGE_SIZE / cbEntry;
3545	}
3546	else
3547	{
3548	/*
3549	* Determin the range.
3550	*/
3551	switch (paArgs[0].enmRangeType)
3552	{
3553	case DBGCVAR_RANGE_BYTES: cEntries = paArgs[0].u64Range / PAGE_SIZE; break;
3554	case DBGCVAR_RANGE_ELEMENTS: cEntries = paArgs[0].u64Range; break;
3555	default: cEntries = 10; break;
3556	}
3557
3558	/*
3559	* Normalize the input address, it must be a flat GC address.
3560	*/
3561	rc = pCmdHlp->pfnEval(pCmdHlp, &VarGCPtr, "%%(%Dv)", &paArgs[0]);
3562	if (VBOX_FAILURE(rc))
3563	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "%%(%Dv)", &paArgs[0]);
3564	if (VarGCPtr.enmType == DBGCVAR_TYPE_HC_FLAT)
3565	{
3566	VarGCPtr.u.GCFlat = (uintptr_t)VarGCPtr.u.pvHCFlat;
3567	VarGCPtr.enmType = DBGCVAR_TYPE_GC_FLAT;
3568	}
3569	VarGCPtr.u.GCFlat &= ~(RTGCPTR)PAGE_OFFSET_MASK;
3570
3571	/*
3572	* Do the paging walk until we get to the page table.
3573	*/
3574	DBGCVAR VarCur;
3575	if (fGuest)
3576	DBGCVAR_INIT_GC_PHYS(&VarCur, cr3);
3577	else
3578	DBGCVAR_INIT_HC_PHYS(&VarCur, cr3);
3579	if (fLME)
3580	{
3581	/* Page Map Level 4 Lookup. */
3582	/* Check if it's a valid address first? */
3583	VarCur.u.u64Number &= X86_PTE_PAE_PG_MASK;
3584	VarCur.u.u64Number += (((uint64_t)VarGCPtr.u.GCFlat >> X86_PML4_SHIFT) & X86_PML4_MASK) * sizeof(X86PML4E);
3585	X86PML4E Pml4e;
3586	rc = pCmdHlp->pfnMemRead(pCmdHlp, pVM, &Pml4e, sizeof(Pml4e), &VarCur, NULL);
3587	if (VBOX_FAILURE(rc))
3588	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "Reading PML4E memory at %DV.\n", &VarCur);
3589	if (!Pml4e.n.u1Present)
3590	return DBGCCmdHlpPrintf(pCmdHlp, "Page directory pointer table is not present for %Dv.\n", &VarGCPtr);
3591
3592	VarCur.u.u64Number = Pml4e.u & X86_PML4E_PG_MASK;
3593	Assert(fPAE);
3594	}
3595	if (fPAE)
3596	{
3597	/* Page directory pointer table. */
3598	X86PDPE Pdpe;
3599	VarCur.u.u64Number += ((VarGCPtr.u.GCFlat >> X86_PDPTR_SHIFT) & X86_PDPTR_MASK) * sizeof(Pdpe);
3600	rc = pCmdHlp->pfnMemRead(pCmdHlp, pVM, &Pdpe, sizeof(Pdpe), &VarCur, NULL);
3601	if (VBOX_FAILURE(rc))
3602	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "Reading PDPE memory at %DV.\n", &VarCur);
3603	if (!Pdpe.n.u1Present)
3604	return DBGCCmdHlpPrintf(pCmdHlp, "Page directory is not present for %Dv.\n", &VarGCPtr);
3605
3606	VarCur.u.u64Number = Pdpe.u & X86_PDPE_PG_MASK;
3607
3608	/* Page directory (PAE). */
3609	X86PDEPAE Pde;
3610	VarCur.u.u64Number += ((VarGCPtr.u.GCFlat >> X86_PD_PAE_SHIFT) & X86_PD_PAE_MASK) * sizeof(Pde);
3611	rc = pCmdHlp->pfnMemRead(pCmdHlp, pVM, &Pde, sizeof(Pde), &VarCur, NULL);
3612	if (VBOX_FAILURE(rc))
3613	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "Reading PDE memory at %DV.\n", &VarCur);
3614	if (!Pde.n.u1Present)
3615	return DBGCCmdHlpPrintf(pCmdHlp, "Page table is not present for %Dv.\n", &VarGCPtr);
3616	if (fPSE && Pde.n.u1Size)
3617	return pCmdHlp->pfnExec(pCmdHlp, "dpd%s %Dv L3", &pCmd->pszCmd[3], &VarGCPtr);
3618
3619	iEntry = (VarGCPtr.u.GCFlat >> X86_PT_PAE_SHIFT) & X86_PT_PAE_MASK;
3620	VarPTEAddr = VarCur;
3621	VarPTEAddr.u.u64Number = Pde.u & X86_PDE_PAE_PG_MASK;
3622	VarPTEAddr.u.u64Number += iEntry * sizeof(X86PTEPAE);
3623	}
3624	else
3625	{
3626	/* Page directory (legacy). */
3627	X86PDE Pde;
3628	VarCur.u.u64Number += ((VarGCPtr.u.GCFlat >> X86_PD_SHIFT) & X86_PD_MASK) * sizeof(Pde);
3629	rc = pCmdHlp->pfnMemRead(pCmdHlp, pVM, &Pde, sizeof(Pde), &VarCur, NULL);
3630	if (VBOX_FAILURE(rc))
3631	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "Reading PDE memory at %DV.\n", &VarCur);
3632	if (!Pde.n.u1Present)
3633	return DBGCCmdHlpPrintf(pCmdHlp, "Page table is not present for %Dv.\n", &VarGCPtr);
3634	if (fPSE && Pde.n.u1Size)
3635	return pCmdHlp->pfnExec(pCmdHlp, "dpd%s %Dv L3", &pCmd->pszCmd[3], &VarGCPtr);
3636
3637	iEntry = (VarGCPtr.u.GCFlat >> X86_PT_SHIFT) & X86_PT_MASK;
3638	VarPTEAddr = VarCur;
3639	VarPTEAddr.u.u64Number = Pde.u & X86_PDE_PG_MASK;
3640	VarPTEAddr.u.u64Number += iEntry * sizeof(X86PTE);
3641	}
3642	cEntriesMax = (PAGE_SIZE - iEntry) / cbEntry;
3643	iEntry /= cbEntry;
3644	}
3645
3646	/* adjust cEntries */
3647	cEntries = RT_MAX(1, cEntries);
3648	cEntries = RT_MIN(cEntries, cEntriesMax);
3649
3650	/*
3651	* The display loop.
3652	*/
3653	DBGCCmdHlpPrintf(pCmdHlp, iEntry != ~0U ? "%DV (base %DV / index %#x):\n" : "%DV:\n",
3654	&VarPTEAddr, &VarGCPtr, iEntry);
3655	do
3656	{
3657	/*
3658	* Read.
3659	*/
3660	X86PTEPAE Pte;
3661	Pte.u = 0;
3662	rc = pCmdHlp->pfnMemRead(pCmdHlp, pVM, &Pte, cbEntry, &VarPTEAddr, NULL);
3663	if (VBOX_FAILURE(rc))
3664	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "Reading PTE memory at %DV.\n", &VarPTEAddr);
3665
3666	/*
3667	* Display.
3668	*/
3669	if (iEntry != ~0U)
3670	{
3671	DBGCCmdHlpPrintf(pCmdHlp, "%03x %DV: ", iEntry, &VarGCPtr);
3672	iEntry++;
3673	}
3674	DBGCCmdHlpPrintf(pCmdHlp,
3675	fPAE
3676	? "%016llx 4kb phys=%016llx %s %s %s %s %s avl=%02x %s %s %s %s %s"
3677	: "%08llx 4kb phys=%08llx %s %s %s %s %s avl=%02x %s %s %s %s %s",
3678	Pte.u,
3679	Pte.u & X86_PTE_PAE_PG_MASK,
3680	Pte.n.u1Present ? "p " : "np",
3681	Pte.n.u1Write ? "w" : "r",
3682	Pte.n.u1User ? "u" : "s",
3683	Pte.n.u1Accessed ? "a " : "na",
3684	Pte.n.u1Dirty ? "d " : "nd",
3685	Pte.n.u3Available,
3686	Pte.n.u1Global ? (fPGE ? "g" : "G") : " ",
3687	Pte.n.u1WriteThru ? "pwt" : " ",
3688	Pte.n.u1CacheDisable ? "pcd" : " ",
3689	Pte.n.u1PAT ? "pat" : " ",
3690	Pte.n.u1NoExecute ? (fNXE ? "nx" : "NX") : " "
3691	);
3692	if (Pte.u & UINT64_C(0x7fff000000000000))
3693	DBGCCmdHlpPrintf(pCmdHlp, " weird=%RX64", (Pte.u & UINT64_C(0x7fff000000000000)));
3694	rc = DBGCCmdHlpPrintf(pCmdHlp, "\n");
3695	if (VBOX_FAILURE(rc))
3696	return rc;
3697
3698	/*
3699	* Advance.
3700	*/
3701	VarPTEAddr.u.u64Number += cbEntry;
3702	if (iEntry != ~0U)
3703	VarGCPtr.u.GCFlat += PAGE_SIZE;
3704	} while (cEntries-- > 0);
3705
3706	NOREF(pResult);
3707	return VINF_SUCCESS;
3708	}
3709
3710
3711	/**
3712	* The 'dptb' command.
3713	*
3714	* @returns VBox status.
3715	* @param pCmd Pointer to the command descriptor (as registered).
3716	* @param pCmdHlp Pointer to command helper functions.
3717	* @param pVM Pointer to the current VM (if any).
3718	* @param paArgs Pointer to (readonly) array of arguments.
3719	* @param cArgs Number of arguments in the array.
3720	*/
3721	static DECLCALLBACK(int) dbgcCmdDumpPageTableBoth(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
3722	{
3723	if (!pVM)
3724	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: No VM.\n");
3725	int rc1 = pCmdHlp->pfnExec(pCmdHlp, "dptg %DV", &paArgs[0]);
3726	int rc2 = pCmdHlp->pfnExec(pCmdHlp, "dpth %DV", &paArgs[0]);
3727	if (VBOX_FAILURE(rc1))
3728	return rc1;
3729	NOREF(pCmd); NOREF(cArgs); NOREF(pResult);
3730	return rc2;
3731	}
3732
3733
3734	/**
3735	* The 'dt' command.
3736	*
3737	* @returns VBox status.
3738	* @param pCmd Pointer to the command descriptor (as registered).
3739	* @param pCmdHlp Pointer to command helper functions.
3740	* @param pVM Pointer to the current VM (if any).
3741	* @param paArgs Pointer to (readonly) array of arguments.
3742	* @param cArgs Number of arguments in the array.
3743	*/
3744	static DECLCALLBACK(int) dbgcCmdDumpTSS(PCDBGCCMD /pCmd/, PDBGCCMDHLP pCmdHlp, PVM /pVM/, PCDBGCVAR /paArgs/, unsigned /cArgs/, PDBGCVAR /pResult/)
3745	{
3746	/*
3747	* We can get a TSS selector (number), a far pointer using a TSS selector, or some kind of TSS pointer.
3748	*/
3749
3750	/** @todo */
3751	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "dt is not implemented yet, feel free to do it. \n");
3752	}
3753
3754
3755	/**
3756	* The 'm' command.
3757	*
3758	* @returns VBox status.
3759	* @param pCmd Pointer to the command descriptor (as registered).
3760	* @param pCmdHlp Pointer to command helper functions.
3761	* @param pVM Pointer to the current VM (if any).
3762	* @param paArgs Pointer to (readonly) array of arguments.
3763	* @param cArgs Number of arguments in the array.
3764	*/
3765	static DECLCALLBACK(int) dbgcCmdMemoryInfo(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
3766	{
3767	pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Address: %DV\n", &paArgs[0]);
3768	if (!pVM)
3769	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: No VM.\n");
3770	int rc1 = pCmdHlp->pfnExec(pCmdHlp, "dpdg %DV", &paArgs[0]);
3771	int rc2 = pCmdHlp->pfnExec(pCmdHlp, "dpdh %DV", &paArgs[0]);
3772	int rc3 = pCmdHlp->pfnExec(pCmdHlp, "dptg %DV", &paArgs[0]);
3773	int rc4 = pCmdHlp->pfnExec(pCmdHlp, "dpth %DV", &paArgs[0]);
3774	if (VBOX_FAILURE(rc1))
3775	return rc1;
3776	if (VBOX_FAILURE(rc2))
3777	return rc2;
3778	if (VBOX_FAILURE(rc3))
3779	return rc3;
3780	NOREF(pCmd); NOREF(cArgs); NOREF(pResult);
3781	return rc4;
3782	}
3783
3784
3785	/**
3786	* The 'echo' command.
3787	*
3788	* @returns VBox status.
3789	* @param pCmd Pointer to the command descriptor (as registered).
3790	* @param pCmdHlp Pointer to command helper functions.
3791	* @param pVM Pointer to the current VM (if any).
3792	* @param paArgs Pointer to (readonly) array of arguments.
3793	* @param cArgs Number of arguments in the array.
3794	*/
3795	static DECLCALLBACK(int) dbgcCmdEcho(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
3796	{
3797	/*
3798	* Loop thru the arguments and print them with one space between.
3799	*/
3800	int rc = 0;
3801	for (unsigned i = 0; i < cArgs; i++)
3802	{
3803	if (paArgs[i].enmType == DBGCVAR_TYPE_STRING)
3804	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, i ? " %s" : "%s", paArgs[i].u.pszString);
3805	else
3806	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, i ? " <parser error>" : "<parser error>");
3807	if (VBOX_FAILURE(rc))
3808	return rc;
3809	}
3810	NOREF(pCmd); NOREF(pResult); NOREF(pVM);
3811	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "\n");
3812	}
3813
3814
3815	/**
3816	* The 'echo' command.
3817	*
3818	* @returns VBox status.
3819	* @param pCmd Pointer to the command descriptor (as registered).
3820	* @param pCmdHlp Pointer to command helper functions.
3821	* @param pVM Pointer to the current VM (if any).
3822	* @param paArgs Pointer to (readonly) array of arguments.
3823	* @param cArgs Number of arguments in the array.
3824	*/
3825	static DECLCALLBACK(int) dbgcCmdRunScript(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
3826	{
3827	/* check that the parser did what it's supposed to do. */
3828	if ( cArgs != 1
3829	\|\| paArgs[0].enmType != DBGCVAR_TYPE_STRING)
3830	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "parser error\n");
3831
3832	/*
3833	* Try open the script.
3834	*/
3835	const char *pszFilename = paArgs[0].u.pszString;
3836	FILE *pFile = fopen(pszFilename, "r");
3837	if (!pFile)
3838	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Failed to open '%s'.\n", pszFilename);
3839
3840	/*
3841	* Execute it line by line.
3842	*/
3843	int rc = 0;
3844	unsigned iLine = 0;
3845	char szLine[8192];
3846	while (fgets(szLine, sizeof(szLine), pFile))
3847	{
3848	/* check that the line isn't too long. */
3849	char *pszEnd = strchr(szLine, '\0');
3850	if (pszEnd == &szLine[sizeof(szLine) - 1])
3851	{
3852	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "runscript error: Line #%u is too long\n", iLine);
3853	break;
3854	}
3855	iLine++;
3856
3857	/* strip leading blanks and check for comment / blank line. */
3858	char *psz = RTStrStripL(szLine);
3859	if ( *psz == '\0'
3860	\|\| *psz == '\n'
3861	\|\| *psz == '#')
3862	continue;
3863
3864	/* strip trailing blanks and check for empty line (\r case). */
3865	while ( pszEnd > psz
3866	&& isspace(pszEnd[-1])) /* isspace includes \n and \r normally. */
3867	*--pszEnd = '\0';
3868
3869	/** @todo check for Control-C / Cancel at this point... */
3870
3871	/*
3872	* Execute the command.
3873	*
3874	* This is a bit wasteful with scratch space btw., can fix it later.
3875	* The whole return code crap should be fixed too, so that it's possible
3876	* to know whether a command succeeded (VBOX_SUCCESS()) or failed, and
3877	* more importantly why it failed.
3878	*/
3879	rc = pCmdHlp->pfnExec(pCmdHlp, "%s", psz);
3880	if (VBOX_FAILURE(rc))
3881	{
3882	if (rc == VERR_BUFFER_OVERFLOW)
3883	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "runscript error: Line #%u is too long (exec overflowed)\n", iLine);
3884	break;
3885	}
3886	if (rc == VWRN_DBGC_CMD_PENDING)
3887	{
3888	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "runscript error: VWRN_DBGC_CMD_PENDING on line #%u, script terminated\n", iLine);
3889	break;
3890	}
3891	}
3892
3893	fclose(pFile);
3894
3895	NOREF(pCmd); NOREF(pResult); NOREF(pVM);
3896	return rc;
3897	}
3898
3899
3900
3901	/**
3902	* Print formatted string.
3903	*
3904	* @param pHlp Pointer to this structure.
3905	* @param pszFormat The format string.
3906	* @param ... Arguments.
3907	*/
3908	static DECLCALLBACK(void) dbgcCmdInfo_Printf(PCDBGFINFOHLP pHlp, const char *pszFormat, ...)
3909	{
3910	PDBGCCMDHLP pCmdHlp = (PDBGCCMDHLP )(pHlp + 1);
3911	va_list args;
3912	va_start(args, pszFormat);
3913	pCmdHlp->pfnPrintfV(pCmdHlp, NULL, pszFormat, args);
3914	va_end(args);
3915	}
3916
3917
3918	/**
3919	* Print formatted string.
3920	*
3921	* @param pHlp Pointer to this structure.
3922	* @param pszFormat The format string.
3923	* @param args Argument list.
3924	*/
3925	static DECLCALLBACK(void) dbgcCmdInfo_PrintfV(PCDBGFINFOHLP pHlp, const char *pszFormat, va_list args)
3926	{
3927	PDBGCCMDHLP pCmdHlp = (PDBGCCMDHLP )(pHlp + 1);
3928	pCmdHlp->pfnPrintfV(pCmdHlp, NULL, pszFormat, args);
3929	}
3930
3931
3932	/**
3933	* The 'info' command.
3934	*
3935	* @returns VBox status.
3936	* @param pCmd Pointer to the command descriptor (as registered).
3937	* @param pCmdHlp Pointer to command helper functions.
3938	* @param pVM Pointer to the current VM (if any).
3939	* @param paArgs Pointer to (readonly) array of arguments.
3940	* @param cArgs Number of arguments in the array.
3941	*/
3942	static DECLCALLBACK(int) dbgcCmdInfo(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
3943	{
3944	/*
3945	* Validate input.
3946	*/
3947	if ( cArgs < 1
3948	\|\| cArgs > 2
3949	\|\| paArgs[0].enmType != DBGCVAR_TYPE_STRING
3950	\|\| paArgs[cArgs - 1].enmType != DBGCVAR_TYPE_STRING)
3951	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "internal error: The parser doesn't do its job properly yet.. quote the string.\n");
3952	if (!pVM)
3953	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: No VM.\n");
3954
3955	/*
3956	* Dump it.
3957	*/
3958	struct
3959	{
3960	DBGFINFOHLP Hlp;
3961	PDBGCCMDHLP pCmdHlp;
3962	} Hlp = { { dbgcCmdInfo_Printf, dbgcCmdInfo_PrintfV }, pCmdHlp };
3963	int rc = DBGFR3Info(pVM, paArgs[0].u.pszString, cArgs == 2 ? paArgs[1].u.pszString : NULL, &Hlp.Hlp);
3964	if (VBOX_FAILURE(rc))
3965	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "DBGFR3Info()\n");
3966
3967	NOREF(pCmd); NOREF(pResult);
3968	return 0;
3969	}
3970
3971
3972	/**
3973	* The 'log' command.
3974	*
3975	* @returns VBox status.
3976	* @param pCmd Pointer to the command descriptor (as registered).
3977	* @param pCmdHlp Pointer to command helper functions.
3978	* @param pVM Pointer to the current VM (if any).
3979	* @param paArgs Pointer to (readonly) array of arguments.
3980	* @param cArgs Number of arguments in the array.
3981	*/
3982	static DECLCALLBACK(int) dbgcCmdLog(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
3983	{
3984	int rc = DBGFR3LogModifyGroups(pVM, paArgs[0].u.pszString);
3985	if (VBOX_SUCCESS(rc))
3986	return VINF_SUCCESS;
3987	NOREF(pCmd); NOREF(cArgs); NOREF(pResult);
3988	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "DBGFR3LogModifyGroups(%p,'%s')\n", pVM, paArgs[0].u.pszString);
3989	}
3990
3991
3992	/**
3993	* The 'logdest' command.
3994	*
3995	* @returns VBox status.
3996	* @param pCmd Pointer to the command descriptor (as registered).
3997	* @param pCmdHlp Pointer to command helper functions.
3998	* @param pVM Pointer to the current VM (if any).
3999	* @param paArgs Pointer to (readonly) array of arguments.
4000	* @param cArgs Number of arguments in the array.
4001	*/
4002	static DECLCALLBACK(int) dbgcCmdLogDest(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
4003	{
4004	int rc = DBGFR3LogModifyDestinations(pVM, paArgs[0].u.pszString);
4005	if (VBOX_SUCCESS(rc))
4006	return VINF_SUCCESS;
4007	NOREF(pCmd); NOREF(cArgs); NOREF(pResult);
4008	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "DBGFR3LogModifyDestinations(%p,'%s')\n", pVM, paArgs[0].u.pszString);
4009	}
4010
4011
4012	/**
4013	* The 'logflags' command.
4014	*
4015	* @returns VBox status.
4016	* @param pCmd Pointer to the command descriptor (as registered).
4017	* @param pCmdHlp Pointer to command helper functions.
4018	* @param pVM Pointer to the current VM (if any).
4019	* @param paArgs Pointer to (readonly) array of arguments.
4020	* @param cArgs Number of arguments in the array.
4021	*/
4022	static DECLCALLBACK(int) dbgcCmdLogFlags(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
4023	{
4024	int rc = DBGFR3LogModifyFlags(pVM, paArgs[0].u.pszString);
4025	if (VBOX_SUCCESS(rc))
4026	return VINF_SUCCESS;
4027	NOREF(pCmd); NOREF(cArgs); NOREF(pResult);
4028	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "DBGFR3LogModifyFlags(%p,'%s')\n", pVM, paArgs[0].u.pszString);
4029	}
4030
4031
4032	/**
4033	* The 'format' command.
4034	*
4035	* @returns VBox status.
4036	* @param pCmd Pointer to the command descriptor (as registered).
4037	* @param pCmdHlp Pointer to command helper functions.
4038	* @param pVM Pointer to the current VM (if any).
4039	* @param paArgs Pointer to (readonly) array of arguments.
4040	* @param cArgs Number of arguments in the array.
4041	*/
4042	static DECLCALLBACK(int) dbgcCmdFormat(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
4043	{
4044	LogFlow(("dbgcCmdFormat\n"));
4045	static const char *apszRangeDesc[] =
4046	{
4047	"none", "bytes", "elements"
4048	};
4049	int rc;
4050
4051	for (unsigned iArg = 0; iArg < cArgs; iArg++)
4052	{
4053	switch (paArgs[iArg].enmType)
4054	{
4055	case DBGCVAR_TYPE_UNKNOWN:
4056	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4057	"Unknown variable type!\n");
4058	break;
4059	case DBGCVAR_TYPE_GC_FLAT:
4060	if (paArgs[iArg].enmRangeType != DBGCVAR_RANGE_NONE)
4061	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4062	"Guest flat address: %%%08x range %lld %s\n",
4063	paArgs[iArg].u.GCFlat,
4064	paArgs[iArg].u64Range,
4065	apszRangeDesc[paArgs[iArg].enmRangeType]);
4066	else
4067	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4068	"Guest flat address: %%%08x\n",
4069	paArgs[iArg].u.GCFlat);
4070	break;
4071	case DBGCVAR_TYPE_GC_FAR:
4072	if (paArgs[iArg].enmRangeType != DBGCVAR_RANGE_NONE)
4073	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4074	"Guest far address: %04x:%08x range %lld %s\n",
4075	paArgs[iArg].u.GCFar.sel,
4076	paArgs[iArg].u.GCFar.off,
4077	paArgs[iArg].u64Range,
4078	apszRangeDesc[paArgs[iArg].enmRangeType]);
4079	else
4080	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4081	"Guest far address: %04x:%08x\n",
4082	paArgs[iArg].u.GCFar.sel,
4083	paArgs[iArg].u.GCFar.off);
4084	break;
4085	case DBGCVAR_TYPE_GC_PHYS:
4086	if (paArgs[iArg].enmRangeType != DBGCVAR_RANGE_NONE)
4087	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4088	"Guest physical address: %%%%%08x range %lld %s\n",
4089	paArgs[iArg].u.GCPhys,
4090	paArgs[iArg].u64Range,
4091	apszRangeDesc[paArgs[iArg].enmRangeType]);
4092	else
4093	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4094	"Guest physical address: %%%%%08x\n",
4095	paArgs[iArg].u.GCPhys);
4096	break;
4097	case DBGCVAR_TYPE_HC_FLAT:
4098	if (paArgs[iArg].enmRangeType != DBGCVAR_RANGE_NONE)
4099	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4100	"Host flat address: %%%08x range %lld %s\n",
4101	paArgs[iArg].u.pvHCFlat,
4102	paArgs[iArg].u64Range,
4103	apszRangeDesc[paArgs[iArg].enmRangeType]);
4104	else
4105	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4106	"Host flat address: %%%08x\n",
4107	paArgs[iArg].u.pvHCFlat);
4108	break;
4109	case DBGCVAR_TYPE_HC_FAR:
4110	if (paArgs[iArg].enmRangeType != DBGCVAR_RANGE_NONE)
4111	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4112	"Host far address: %04x:%08x range %lld %s\n",
4113	paArgs[iArg].u.HCFar.sel,
4114	paArgs[iArg].u.HCFar.off,
4115	paArgs[iArg].u64Range,
4116	apszRangeDesc[paArgs[iArg].enmRangeType]);
4117	else
4118	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4119	"Host far address: %04x:%08x\n",
4120	paArgs[iArg].u.HCFar.sel,
4121	paArgs[iArg].u.HCFar.off);
4122	break;
4123	case DBGCVAR_TYPE_HC_PHYS:
4124	if (paArgs[iArg].enmRangeType != DBGCVAR_RANGE_NONE)
4125	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4126	"Host physical address: %VHp range %lld %s\n",
4127	paArgs[iArg].u.HCPhys,
4128	paArgs[iArg].u64Range,
4129	apszRangeDesc[paArgs[iArg].enmRangeType]);
4130	else
4131	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4132	"Host physical address: %VHp\n",
4133	paArgs[iArg].u.HCPhys);
4134	break;
4135
4136	case DBGCVAR_TYPE_STRING:
4137	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4138	"String, %lld bytes long: %s\n",
4139	paArgs[iArg].u64Range,
4140	paArgs[iArg].u.pszString);
4141	break;
4142
4143	case DBGCVAR_TYPE_NUMBER:
4144	if (paArgs[iArg].enmRangeType != DBGCVAR_RANGE_NONE)
4145	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4146	"Number: hex %llx dec 0i%lld oct 0t%llo range %lld %s\n",
4147	paArgs[iArg].u.u64Number,
4148	paArgs[iArg].u.u64Number,
4149	paArgs[iArg].u.u64Number,
4150	paArgs[iArg].u64Range,
4151	apszRangeDesc[paArgs[iArg].enmRangeType]);
4152	else
4153	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4154	"Number: hex %llx dec 0i%lld oct 0t%llo\n",
4155	paArgs[iArg].u.u64Number,
4156	paArgs[iArg].u.u64Number,
4157	paArgs[iArg].u.u64Number);
4158	break;
4159
4160	default:
4161	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4162	"Invalid argument type %d\n",
4163	paArgs[iArg].enmType);
4164	break;
4165	}
4166	} /* arg loop */
4167
4168	NOREF(pCmd); NOREF(pVM); NOREF(pResult);
4169	return 0;
4170	}
4171
4172
4173	/**
4174	* List near symbol.
4175	*
4176	* @returns VBox status code.
4177	* @param pCmdHlp Pointer to command helper functions.
4178	* @param pVM Pointer to the current VM (if any).
4179	* @param pArg Pointer to the address or symbol to lookup.
4180	*/
4181	static int dbgcDoListNear(PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR pArg, PDBGCVAR pResult)
4182	{
4183	dbgcVarSetGCFlat(pResult, 0);
4184
4185	DBGFSYMBOL Symbol;
4186	int rc;
4187	if (pArg->enmType == DBGCVAR_TYPE_SYMBOL)
4188	{
4189	/*
4190	* Lookup the symbol address.
4191	*/
4192	rc = DBGFR3SymbolByName(pVM, pArg->u.pszString, &Symbol);
4193	if (VBOX_FAILURE(rc))
4194	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "DBGFR3SymbolByName(, %s,)\n", pArg->u.pszString);
4195
4196	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%VGv %s\n", (RTGCUINTPTR)Symbol.Value, Symbol.szName); /** @todo remove the RTUINGCPTR cast once DBGF got correct interfaces! */
4197	dbgcVarSetGCFlatByteRange(pResult, Symbol.Value, Symbol.cb);
4198	}
4199	else
4200	{
4201	/*
4202	* Convert it to a flat GC address and lookup that address.
4203	*/
4204	DBGCVAR AddrVar;
4205	rc = pCmdHlp->pfnEval(pCmdHlp, &AddrVar, "%%(%DV)", pArg);
4206	if (VBOX_FAILURE(rc))
4207	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "%%(%DV)\n", pArg);
4208
4209	dbgcVarSetVar(pResult, &AddrVar);
4210
4211	RTGCINTPTR offDisp = 0;
4212	rc = DBGFR3SymbolByAddr(pVM, AddrVar.u.GCFlat, &offDisp, &Symbol);
4213	if (VBOX_FAILURE(rc))
4214	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "DBGFR3SymbolByAddr(, %VGv,,)\n", AddrVar.u.GCFlat);
4215
4216	if (!offDisp)
4217	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%DV %s", &AddrVar, Symbol.szName);
4218	else if (offDisp > 0)
4219	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%DV %s + %RGv", &AddrVar, Symbol.szName, offDisp);
4220	else
4221	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%DV %s - %RGv", &AddrVar, Symbol.szName, -offDisp);
4222	if ((RTGCINTPTR)Symbol.cb > -offDisp)
4223	{
4224	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " LB %RGv\n", Symbol.cb + offDisp);
4225	dbgcVarSetByteRange(pResult, Symbol.cb + offDisp);
4226	}
4227	else
4228	{
4229	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "\n");
4230	dbgcVarSetNoRange(pResult);
4231	}
4232	}
4233
4234	return rc;
4235	}
4236
4237
4238	/**
4239	* The 'ln' (listnear) command.
4240	*
4241	* @returns VBox status.
4242	* @param pCmd Pointer to the command descriptor (as registered).
4243	* @param pCmdHlp Pointer to command helper functions.
4244	* @param pVM Pointer to the current VM (if any).
4245	* @param paArgs Pointer to (readonly) array of arguments.
4246	* @param cArgs Number of arguments in the array.
4247	*/
4248	static DECLCALLBACK(int) dbgcCmdListNear(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
4249	{
4250	dbgcVarSetGCFlat(pResult, 0);
4251	if (!cArgs)
4252	{
4253	/*
4254	* Current cs:eip symbol.
4255	*/
4256	DBGCVAR AddrVar;
4257	int rc = pCmdHlp->pfnEval(pCmdHlp, &AddrVar, "%%(cs:eip)");
4258	if (VBOX_FAILURE(rc))
4259	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "%%(cs:eip)\n");
4260	return dbgcDoListNear(pCmdHlp, pVM, &AddrVar, pResult);
4261	}
4262
4263	/*
4264	* Iterate arguments.
4265	*/
4266	for (unsigned iArg = 0; iArg < cArgs; iArg++)
4267	{
4268	int rc = dbgcDoListNear(pCmdHlp, pVM, &paArgs[iArg], pResult);
4269	if (VBOX_FAILURE(rc))
4270	return rc;
4271	}
4272
4273	NOREF(pCmd); NOREF(pResult);
4274	return VINF_SUCCESS;
4275	}
4276
4277
4278	/**
4279	* The 'loadsyms' command.
4280	*
4281	* @returns VBox status.
4282	* @param pCmd Pointer to the command descriptor (as registered).
4283	* @param pCmdHlp Pointer to command helper functions.
4284	* @param pVM Pointer to the current VM (if any).
4285	* @param paArgs Pointer to (readonly) array of arguments.
4286	* @param cArgs Number of arguments in the array.
4287	*/
4288	static DECLCALLBACK(int) dbgcCmdLoadSyms(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
4289	{
4290	/*
4291	* Validate the parsing and make sense of the input.
4292	* This is a mess as usual because we don't trust the parser yet.
4293	*/
4294	if ( cArgs < 1
4295	\|\| paArgs[0].enmType != DBGCVAR_TYPE_STRING)
4296	{
4297	AssertMsgFailed(("Parse error, first argument required to be string!\n"));
4298	return VERR_PARSE_INCORRECT_ARG_TYPE;
4299	}
4300	DBGCVAR AddrVar;
4301	RTGCUINTPTR Delta = 0;
4302	const char *pszModule = NULL;
4303	RTGCUINTPTR ModuleAddress = 0;
4304	unsigned cbModule = 0;
4305	if (cArgs > 1)
4306	{
4307	unsigned iArg = 1;
4308	if (paArgs[iArg].enmType == DBGCVAR_TYPE_NUMBER)
4309	{
4310	Delta = (RTGCUINTPTR)paArgs[iArg].u.u64Number;
4311	iArg++;
4312	}
4313	if (iArg < cArgs)
4314	{
4315	if (paArgs[iArg].enmType != DBGCVAR_TYPE_STRING)
4316	{
4317	AssertMsgFailed(("Parse error, module argument required to be string!\n"));
4318	return VERR_PARSE_INCORRECT_ARG_TYPE;
4319	}
4320	pszModule = paArgs[iArg].u.pszString;
4321	iArg++;
4322	if (iArg < cArgs)
4323	{
4324	if (DBGCVAR_ISPOINTER(paArgs[iArg].enmType))
4325	{
4326	AssertMsgFailed(("Parse error, module argument required to be GC pointer!\n"));
4327	return VERR_PARSE_INCORRECT_ARG_TYPE;
4328	}
4329	int rc = pCmdHlp->pfnEval(pCmdHlp, &AddrVar, "%%(%Dv)", &paArgs[iArg]);
4330	if (VBOX_FAILURE(rc))
4331	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Module address cast %%(%Dv) failed.", &paArgs[iArg]);
4332	ModuleAddress = paArgs[iArg].u.GCFlat;
4333	iArg++;
4334	if (iArg < cArgs)
4335	{
4336	if (paArgs[iArg].enmType != DBGCVAR_TYPE_NUMBER)
4337	{
4338	AssertMsgFailed(("Parse error, module argument required to be an interger!\n"));
4339	return VERR_PARSE_INCORRECT_ARG_TYPE;
4340	}
4341	cbModule = (unsigned)paArgs[iArg].u.u64Number;
4342	iArg++;
4343	if (iArg < cArgs)
4344	{
4345	AssertMsgFailed(("Parse error, too many arguments!\n"));
4346	return VERR_PARSE_TOO_MANY_ARGUMENTS;
4347	}
4348	}
4349	}
4350	}
4351	}
4352
4353	/*
4354	* Call the debug info manager about this loading...
4355	*/
4356	int rc = DBGFR3ModuleLoad(pVM, paArgs[0].u.pszString, Delta, pszModule, ModuleAddress, cbModule);
4357	if (VBOX_FAILURE(rc))
4358	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "DBGInfoSymbolLoad(, '%s', %VGv, '%s', %VGv, 0)\n",
4359	paArgs[0].u.pszString, Delta, pszModule, ModuleAddress);
4360
4361	NOREF(pCmd); NOREF(pResult);
4362	return VINF_SUCCESS;
4363	}
4364
4365
4366	/**
4367	* The 'set' command.
4368	*
4369	* @returns VBox status.
4370	* @param pCmd Pointer to the command descriptor (as registered).
4371	* @param pCmdHlp Pointer to command helper functions.
4372	* @param pVM Pointer to the current VM (if any).
4373	* @param paArgs Pointer to (readonly) array of arguments.
4374	* @param cArgs Number of arguments in the array.
4375	*/
4376	static DECLCALLBACK(int) dbgcCmdSet(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
4377	{
4378	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
4379
4380	/* parse sanity check. */
4381	AssertMsg(paArgs[0].enmType == DBGCVAR_TYPE_STRING, ("expected string not %d as first arg!\n", paArgs[0].enmType));
4382	if (paArgs[0].enmType != DBGCVAR_TYPE_STRING)
4383	return VERR_PARSE_INCORRECT_ARG_TYPE;
4384
4385
4386	/*
4387	* A variable must start with an alpha chars and only contain alpha numerical chars.
4388	*/
4389	const char *pszVar = paArgs[0].u.pszString;
4390	if (!isalpha(pszVar) \|\| pszVar == '_')
4391	return pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4392	"syntax error: Invalid variable name '%s'. Variable names must match regex '[_a-zA-Z][_a-zA-Z0-9*'!", paArgs[0].u.pszString);
4393
4394	while (isalnum(pszVar) \|\| pszVar == '_')
4395	*pszVar++;
4396	if (*pszVar)
4397	return pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4398	"syntax error: Invalid variable name '%s'. Variable names must match regex '[_a-zA-Z][_a-zA-Z0-9*]'!", paArgs[0].u.pszString);
4399
4400
4401	/*
4402	* Calc variable size.
4403	*/
4404	size_t cbVar = (size_t)paArgs[0].u64Range + sizeof(DBGCNAMEDVAR);
4405	if (paArgs[1].enmType == DBGCVAR_TYPE_STRING)
4406	cbVar += 1 + (size_t)paArgs[1].u64Range;
4407
4408	/*
4409	* Look for existing one.
4410	*/
4411	pszVar = paArgs[0].u.pszString;
4412	for (unsigned iVar = 0; iVar < pDbgc->cVars; iVar++)
4413	{
4414	if (!strcmp(pszVar, pDbgc->papVars[iVar]->szName))
4415	{
4416	/*
4417	* Update existing variable.
4418	*/
4419	void *pv = RTMemRealloc(pDbgc->papVars[iVar], cbVar);
4420	if (!pv)
4421	return VERR_PARSE_NO_MEMORY;
4422	PDBGCNAMEDVAR pVar = pDbgc->papVars[iVar] = (PDBGCNAMEDVAR)pv;
4423
4424	pVar->Var = paArgs[1];
4425	memcpy(pVar->szName, paArgs[0].u.pszString, (size_t)paArgs[0].u64Range + 1);
4426	if (paArgs[1].enmType == DBGCVAR_TYPE_STRING)
4427	pVar->Var.u.pszString = (char *)memcpy(&pVar->szName[paArgs[0].u64Range + 1], paArgs[1].u.pszString, (size_t)paArgs[1].u64Range + 1);
4428	return 0;
4429	}
4430	}
4431
4432	/*
4433	* Allocate another.
4434	*/
4435	PDBGCNAMEDVAR pVar = (PDBGCNAMEDVAR)RTMemAlloc(cbVar);
4436
4437	pVar->Var = paArgs[1];
4438	memcpy(pVar->szName, pszVar, (size_t)paArgs[0].u64Range + 1);
4439	if (paArgs[1].enmType == DBGCVAR_TYPE_STRING)
4440	pVar->Var.u.pszString = (char *)memcpy(&pVar->szName[paArgs[0].u64Range + 1], paArgs[1].u.pszString, (size_t)paArgs[1].u64Range + 1);
4441
4442	/* need to reallocate the pointer array too? */
4443	if (!(pDbgc->cVars % 0x20))
4444	{
4445	void pv = RTMemRealloc(pDbgc->papVars, (pDbgc->cVars + 0x20) sizeof(pDbgc->papVars[0]));
4446	if (!pv)
4447	{
4448	RTMemFree(pVar);
4449	return VERR_PARSE_NO_MEMORY;
4450	}
4451	pDbgc->papVars = (PDBGCNAMEDVAR *)pv;
4452	}
4453	pDbgc->papVars[pDbgc->cVars++] = pVar;
4454
4455	NOREF(pCmd); NOREF(pVM); NOREF(cArgs); NOREF(pResult);
4456	return 0;
4457	}
4458
4459
4460	/**
4461	* The 'unset' command.
4462	*
4463	* @returns VBox status.
4464	* @param pCmd Pointer to the command descriptor (as registered).
4465	* @param pCmdHlp Pointer to command helper functions.
4466	* @param pVM Pointer to the current VM (if any).
4467	* @param paArgs Pointer to (readonly) array of arguments.
4468	* @param cArgs Number of arguments in the array.
4469	*/
4470	static DECLCALLBACK(int) dbgcCmdUnset(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
4471	{
4472	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
4473
4474	/*
4475	* Don't trust the parser.
4476	*/
4477	for (unsigned i = 0; i < cArgs; i++)
4478	if (paArgs[i].enmType != DBGCVAR_TYPE_STRING)
4479	{
4480	AssertMsgFailed(("expected strings only. (arg=%d)!\n", i));
4481	return VERR_PARSE_INCORRECT_ARG_TYPE;
4482	}
4483
4484	/*
4485	* Iterate the variables and unset them.
4486	*/
4487	for (unsigned iArg = 0; iArg < cArgs; iArg++)
4488	{
4489	const char *pszVar = paArgs[iArg].u.pszString;
4490
4491	/*
4492	* Look up the variable.
4493	*/
4494	for (unsigned iVar = 0; iVar < pDbgc->cVars; iVar++)
4495	{
4496	if (!strcmp(pszVar, pDbgc->papVars[iVar]->szName))
4497	{
4498	/*
4499	* Shuffle the array removing this entry.
4500	*/
4501	void *pvFree = pDbgc->papVars[iVar];
4502	if (iVar + 1 < pDbgc->cVars)
4503	memmove(&pDbgc->papVars[iVar],
4504	&pDbgc->papVars[iVar + 1],
4505	(pDbgc->cVars - iVar - 1) * sizeof(pDbgc->papVars[0]));
4506	pDbgc->papVars[--pDbgc->cVars] = NULL;
4507
4508	RTMemFree(pvFree);
4509	}
4510	} /* lookup */
4511	} /* arg loop */
4512
4513	NOREF(pCmd); NOREF(pVM); NOREF(pResult);
4514	return 0;
4515	}
4516
4517
4518	/**
4519	* The 'loadvars' command.
4520	*
4521	* @returns VBox status.
4522	* @param pCmd Pointer to the command descriptor (as registered).
4523	* @param pCmdHlp Pointer to command helper functions.
4524	* @param pVM Pointer to the current VM (if any).
4525	* @param paArgs Pointer to (readonly) array of arguments.
4526	* @param cArgs Number of arguments in the array.
4527	*/
4528	static DECLCALLBACK(int) dbgcCmdLoadVars(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
4529	{
4530	/*
4531	* Don't trust the parser.
4532	*/
4533	if ( cArgs != 1
4534	\|\| paArgs[0].enmType != DBGCVAR_TYPE_STRING)
4535	{
4536	AssertMsgFailed(("Expected one string exactly!\n"));
4537	return VERR_PARSE_INCORRECT_ARG_TYPE;
4538	}
4539
4540	/*
4541	* Iterate the variables and unset them.
4542	*/
4543	FILE *pFile = fopen(paArgs[0].u.pszString, "r");
4544	if (pFile)
4545	{
4546	char szLine[4096];
4547	while (fgets(szLine, sizeof(szLine), pFile))
4548	{
4549	/* Strip it. */
4550	char *psz = szLine;
4551	while (isblank(*psz))
4552	psz++;
4553	int i = strlen(psz) - 1;
4554	while (i >= 0 && isspace(psz[i]))
4555	psz[i--] ='\0';
4556	/* Execute it if not comment or empty line. */
4557	if ( *psz != '\0'
4558	&& *psz != '#'
4559	&& *psz != ';')
4560	{
4561	pCmdHlp->pfnPrintf(pCmdHlp, NULL, "dbg: set %s", psz);
4562	pCmdHlp->pfnExec(pCmdHlp, "set %s", psz);
4563	}
4564	}
4565	fclose(pFile);
4566	}
4567	else
4568	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Failed to open file '%s'.\n", paArgs[0].u.pszString);
4569
4570	NOREF(pCmd); NOREF(pVM); NOREF(pResult);
4571	return 0;
4572	}
4573
4574
4575	/**
4576	* The 'showvars' command.
4577	*
4578	* @returns VBox status.
4579	* @param pCmd Pointer to the command descriptor (as registered).
4580	* @param pCmdHlp Pointer to command helper functions.
4581	* @param pVM Pointer to the current VM (if any).
4582	* @param paArgs Pointer to (readonly) array of arguments.
4583	* @param cArgs Number of arguments in the array.
4584	*/
4585	static DECLCALLBACK(int) dbgcCmdShowVars(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
4586	{
4587	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
4588
4589	for (unsigned iVar = 0; iVar < pDbgc->cVars; iVar++)
4590	{
4591	int rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%-20s ", &pDbgc->papVars[iVar]->szName);
4592	if (!rc)
4593	rc = dbgcCmdFormat(pCmd, pCmdHlp, pVM, &pDbgc->papVars[iVar]->Var, 1, NULL);
4594	if (rc)
4595	return rc;
4596	}
4597
4598	NOREF(paArgs); NOREF(cArgs); NOREF(pResult);
4599	return 0;
4600	}
4601
4602
4603	/**
4604	* The 'harakiri' command.
4605	*
4606	* @returns VBox status.
4607	* @param pCmd Pointer to the command descriptor (as registered).
4608	* @param pCmdHlp Pointer to command helper functions.
4609	* @param pVM Pointer to the current VM (if any).
4610	* @param paArgs Pointer to (readonly) array of arguments.
4611	* @param cArgs Number of arguments in the array.
4612	*/
4613	static DECLCALLBACK(int) dbgcCmdHarakiri(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
4614	{
4615	Log(("dbgcCmdHarakiri\n"));
4616	for (;;)
4617	exit(126);
4618	NOREF(pCmd); NOREF(pCmdHlp); NOREF(pVM); NOREF(paArgs); NOREF(cArgs); NOREF(pResult);
4619	}
4620
4621
4622
4623
4624
4625	//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
4626	//
4627	//
4628	// B u l t i n S y m b o l s
4629	//
4630	//
4631	//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
4632
4633
4634
4635	/**
4636	* Get builtin register symbol.
4637	*
4638	* The uUser is special for these symbol descriptors. See the SYMREG_* \#defines.
4639	*
4640	* @returns 0 on success.
4641	* @returns VBox evaluation / parsing error code on failure.
4642	* The caller does the bitching.
4643	* @param pSymDesc Pointer to the symbol descriptor.
4644	* @param pCmdHlp Pointer to the command callback structure.
4645	* @param enmType The result type.
4646	* @param pResult Where to store the result.
4647	*/
4648	static DECLCALLBACK(int) dbgcSymGetReg(PCDBGCSYM pSymDesc, PDBGCCMDHLP pCmdHlp, DBGCVARTYPE enmType, PDBGCVAR pResult)
4649	{
4650	LogFlow(("dbgcSymSetReg: pSymDesc->pszName=%d\n", pSymDesc->pszName));
4651
4652	/*
4653	* pVM is required.
4654	*/
4655	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
4656	Assert(pDbgc->pVM);
4657
4658	/*
4659	* Get the right CPU context.
4660	*/
4661	PCPUMCTX pCtx;
4662	int rc;
4663	if (!(pSymDesc->uUser & SYMREG_FLAGS_HYPER))
4664	rc = CPUMQueryGuestCtxPtr(pDbgc->pVM, &pCtx);
4665	else
4666	rc = CPUMQueryHyperCtxPtr(pDbgc->pVM, &pCtx);
4667	if (VBOX_FAILURE(rc))
4668	return rc;
4669
4670	/*
4671	* Get the value.
4672	*/
4673	void pvValue = (char )pCtx + SYMREG_OFFSET(pSymDesc->uUser);
4674	uint64_t u64;
4675	switch (SYMREG_SIZE(pSymDesc->uUser))
4676	{
4677	case 1: u64 = (uint8_t )pvValue; break;
4678	case 2: u64 = (uint16_t )pvValue; break;
4679	case 4: u64 = (uint32_t )pvValue; break;
4680	case 6: u64 = (uint32_t )pvValue \| ((uint64_t)(uint16_t )((char *)pvValue + sizeof(uint32_t)) << 32); break;
4681	case 8: u64 = (uint64_t )pvValue; break;
4682	default:
4683	return VERR_PARSE_NOT_IMPLEMENTED;
4684	}
4685
4686	/*
4687	* Construct the desired result.
4688	*/
4689	if (enmType == DBGCVAR_TYPE_ANY)
4690	enmType = DBGCVAR_TYPE_NUMBER;
4691	pResult->pDesc = NULL;
4692	pResult->pNext = NULL;
4693	pResult->enmType = enmType;
4694	pResult->enmRangeType = DBGCVAR_RANGE_NONE;
4695	pResult->u64Range = 0;
4696
4697	switch (enmType)
4698	{
4699	case DBGCVAR_TYPE_GC_FLAT:
4700	pResult->u.GCFlat = (RTGCPTR)u64;
4701	break;
4702
4703	case DBGCVAR_TYPE_GC_FAR:
4704	switch (SYMREG_SIZE(pSymDesc->uUser))
4705	{
4706	case 4:
4707	if (!(pSymDesc->uUser & SYMREG_FLAGS_HIGH_SEL))
4708	{
4709	pResult->u.GCFar.off = (uint16_t)u64;
4710	pResult->u.GCFar.sel = (uint16_t)(u64 >> 16);
4711	}
4712	else
4713	{
4714	pResult->u.GCFar.sel = (uint16_t)u64;
4715	pResult->u.GCFar.off = (uint16_t)(u64 >> 16);
4716	}
4717	break;
4718	case 6:
4719	if (!(pSymDesc->uUser & SYMREG_FLAGS_HIGH_SEL))
4720	{
4721	pResult->u.GCFar.off = (uint32_t)u64;
4722	pResult->u.GCFar.sel = (uint16_t)(u64 >> 32);
4723	}
4724	else
4725	{
4726	pResult->u.GCFar.sel = (uint32_t)u64;
4727	pResult->u.GCFar.off = (uint16_t)(u64 >> 32);
4728	}
4729	break;
4730
4731	default:
4732	return VERR_PARSE_BAD_RESULT_TYPE;
4733	}
4734	break;
4735
4736	case DBGCVAR_TYPE_GC_PHYS:
4737	pResult->u.GCPhys = (RTGCPHYS)u64;
4738	break;
4739
4740	case DBGCVAR_TYPE_HC_FLAT:
4741	pResult->u.pvHCFlat = (void *)(uintptr_t)u64;
4742	break;
4743
4744	case DBGCVAR_TYPE_HC_FAR:
4745	switch (SYMREG_SIZE(pSymDesc->uUser))
4746	{
4747	case 4:
4748	if (!(pSymDesc->uUser & SYMREG_FLAGS_HIGH_SEL))
4749	{
4750	pResult->u.HCFar.off = (uint16_t)u64;
4751	pResult->u.HCFar.sel = (uint16_t)(u64 >> 16);
4752	}
4753	else
4754	{
4755	pResult->u.HCFar.sel = (uint16_t)u64;
4756	pResult->u.HCFar.off = (uint16_t)(u64 >> 16);
4757	}
4758	break;
4759	case 6:
4760	if (!(pSymDesc->uUser & SYMREG_FLAGS_HIGH_SEL))
4761	{
4762	pResult->u.HCFar.off = (uint32_t)u64;
4763	pResult->u.HCFar.sel = (uint16_t)(u64 >> 32);
4764	}
4765	else
4766	{
4767	pResult->u.HCFar.sel = (uint32_t)u64;
4768	pResult->u.HCFar.off = (uint16_t)(u64 >> 32);
4769	}
4770	break;
4771
4772	default:
4773	return VERR_PARSE_BAD_RESULT_TYPE;
4774	}
4775	break;
4776
4777	case DBGCVAR_TYPE_HC_PHYS:
4778	pResult->u.GCPhys = (RTGCPHYS)u64;
4779	break;
4780
4781	case DBGCVAR_TYPE_NUMBER:
4782	pResult->u.u64Number = u64;
4783	break;
4784
4785	case DBGCVAR_TYPE_STRING:
4786	case DBGCVAR_TYPE_UNKNOWN:
4787	default:
4788	return VERR_PARSE_BAD_RESULT_TYPE;
4789
4790	}
4791
4792	return 0;
4793	}
4794
4795
4796	/**
4797	* Set builtin register symbol.
4798	*
4799	* The uUser is special for these symbol descriptors. See the SYMREG_* #defines.
4800	*
4801	* @returns 0 on success.
4802	* @returns VBox evaluation / parsing error code on failure.
4803	* The caller does the bitching.
4804	* @param pSymDesc Pointer to the symbol descriptor.
4805	* @param pCmdHlp Pointer to the command callback structure.
4806	* @param pValue The value to assign the symbol.
4807	*/
4808	static DECLCALLBACK(int) dbgcSymSetReg(PCDBGCSYM pSymDesc, PDBGCCMDHLP pCmdHlp, PCDBGCVAR pValue)
4809	{
4810	LogFlow(("dbgcSymSetReg: pSymDesc->pszName=%d\n", pSymDesc->pszName));
4811
4812	/*
4813	* pVM is required.
4814	*/
4815	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
4816	Assert(pDbgc->pVM);
4817
4818	/*
4819	* Get the right CPU context.
4820	*/
4821	PCPUMCTX pCtx;
4822	int rc;
4823	if (!(pSymDesc->uUser & SYMREG_FLAGS_HYPER))
4824	rc = CPUMQueryGuestCtxPtr(pDbgc->pVM, &pCtx);
4825	else
4826	rc = CPUMQueryHyperCtxPtr(pDbgc->pVM, &pCtx);
4827	if (VBOX_FAILURE(rc))
4828	return rc;
4829
4830	/*
4831	* Check the new value.
4832	*/
4833	if (pValue->enmType != DBGCVAR_TYPE_NUMBER)
4834	return VERR_PARSE_ARGUMENT_TYPE_MISMATCH;
4835
4836	/*
4837	* Set the value.
4838	*/
4839	void pvValue = (char )pCtx + SYMREG_OFFSET(pSymDesc->uUser);
4840	switch (SYMREG_SIZE(pSymDesc->uUser))
4841	{
4842	case 1:
4843	(uint8_t )pvValue = (uint8_t)pValue->u.u64Number;
4844	break;
4845	case 2:
4846	(uint16_t )pvValue = (uint16_t)pValue->u.u64Number;
4847	break;
4848	case 4:
4849	(uint32_t )pvValue = (uint32_t)pValue->u.u64Number;
4850	break;
4851	case 6:
4852	(uint32_t )pvValue = (uint32_t)pValue->u.u64Number;
4853	((uint16_t *)pvValue)[3] = (uint16_t)(pValue->u.u64Number >> 32);
4854	break;
4855	case 8:
4856	(uint64_t )pvValue = pValue->u.u64Number;
4857	break;
4858	default:
4859	return VERR_PARSE_NOT_IMPLEMENTED;
4860	}
4861
4862	return VINF_SUCCESS;
4863	}
4864
4865
4866
4867
4868
4869
4870
4871	//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
4872	//
4873	//
4874	// O p e r a t o r s
4875	//
4876	//
4877	//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
4878
4879
4880	/**
4881	* Minus (unary).
4882	*
4883	* @returns 0 on success.
4884	* @returns VBox evaluation / parsing error code on failure.
4885	* The caller does the bitching.
4886	* @param pDbgc Debugger console instance data.
4887	* @param pArg The argument.
4888	* @param pResult Where to store the result.
4889	*/
4890	static DECLCALLBACK(int) dbgcOpMinus(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult)
4891	{
4892	// LogFlow(("dbgcOpMinus\n"));
4893	pResult = pArg;
4894	switch (pArg->enmType)
4895	{
4896	case DBGCVAR_TYPE_GC_FLAT:
4897	pResult->u.GCFlat = -(RTGCINTPTR)pResult->u.GCFlat;
4898	break;
4899	case DBGCVAR_TYPE_GC_FAR:
4900	pResult->u.GCFar.off = -(int32_t)pResult->u.GCFar.off;
4901	break;
4902	case DBGCVAR_TYPE_GC_PHYS:
4903	pResult->u.GCPhys = (RTGCPHYS) -(int64_t)pResult->u.GCPhys;
4904	break;
4905	case DBGCVAR_TYPE_HC_FLAT:
4906	pResult->u.pvHCFlat = (void *) -(intptr_t)pResult->u.pvHCFlat;
4907	break;
4908	case DBGCVAR_TYPE_HC_FAR:
4909	pResult->u.HCFar.off = -(int32_t)pResult->u.HCFar.off;
4910	break;
4911	case DBGCVAR_TYPE_HC_PHYS:
4912	pResult->u.HCPhys = (RTHCPHYS) -(int64_t)pResult->u.HCPhys;
4913	break;
4914	case DBGCVAR_TYPE_NUMBER:
4915	pResult->u.u64Number = -(int64_t)pResult->u.u64Number;
4916	break;
4917
4918	case DBGCVAR_TYPE_UNKNOWN:
4919	case DBGCVAR_TYPE_STRING:
4920	default:
4921	return VERR_PARSE_INCORRECT_ARG_TYPE;
4922	}
4923	NOREF(pDbgc);
4924	return 0;
4925	}
4926
4927
4928	/**
4929	* Pluss (unary).
4930	*
4931	* @returns 0 on success.
4932	* @returns VBox evaluation / parsing error code on failure.
4933	* The caller does the bitching.
4934	* @param pDbgc Debugger console instance data.
4935	* @param pArg The argument.
4936	* @param pResult Where to store the result.
4937	*/
4938	static DECLCALLBACK(int) dbgcOpPluss(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult)
4939	{
4940	// LogFlow(("dbgcOpPluss\n"));
4941	pResult = pArg;
4942	switch (pArg->enmType)
4943	{
4944	case DBGCVAR_TYPE_GC_FLAT:
4945	case DBGCVAR_TYPE_GC_FAR:
4946	case DBGCVAR_TYPE_GC_PHYS:
4947	case DBGCVAR_TYPE_HC_FLAT:
4948	case DBGCVAR_TYPE_HC_FAR:
4949	case DBGCVAR_TYPE_HC_PHYS:
4950	case DBGCVAR_TYPE_NUMBER:
4951	break;
4952
4953	case DBGCVAR_TYPE_UNKNOWN:
4954	case DBGCVAR_TYPE_STRING:
4955	default:
4956	return VERR_PARSE_INCORRECT_ARG_TYPE;
4957	}
4958	NOREF(pDbgc);
4959	return 0;
4960	}
4961
4962
4963	/**
4964	* Boolean not (unary).
4965	*
4966	* @returns 0 on success.
4967	* @returns VBox evaluation / parsing error code on failure.
4968	* The caller does the bitching.
4969	* @param pDbgc Debugger console instance data.
4970	* @param pArg The argument.
4971	* @param pResult Where to store the result.
4972	*/
4973	static DECLCALLBACK(int) dbgcOpBooleanNot(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult)
4974	{
4975	// LogFlow(("dbgcOpBooleanNot\n"));
4976	pResult = pArg;
4977	switch (pArg->enmType)
4978	{
4979	case DBGCVAR_TYPE_GC_FLAT:
4980	pResult->u.u64Number = !pResult->u.GCFlat;
4981	break;
4982	case DBGCVAR_TYPE_GC_FAR:
4983	pResult->u.u64Number = !pResult->u.GCFar.off && pResult->u.GCFar.sel <= 3;
4984	break;
4985	case DBGCVAR_TYPE_GC_PHYS:
4986	pResult->u.u64Number = !pResult->u.GCPhys;
4987	break;
4988	case DBGCVAR_TYPE_HC_FLAT:
4989	pResult->u.u64Number = !pResult->u.pvHCFlat;
4990	break;
4991	case DBGCVAR_TYPE_HC_FAR:
4992	pResult->u.u64Number = !pResult->u.HCFar.off && pResult->u.HCFar.sel <= 3;
4993	break;
4994	case DBGCVAR_TYPE_HC_PHYS:
4995	pResult->u.u64Number = !pResult->u.HCPhys;
4996	break;
4997	case DBGCVAR_TYPE_NUMBER:
4998	pResult->u.u64Number = !pResult->u.u64Number;
4999	break;
5000	case DBGCVAR_TYPE_STRING:
5001	pResult->u.u64Number = !pResult->u64Range;
5002	break;
5003
5004	case DBGCVAR_TYPE_UNKNOWN:
5005	default:
5006	return VERR_PARSE_INCORRECT_ARG_TYPE;
5007	}
5008	pResult->enmType = DBGCVAR_TYPE_NUMBER;
5009	NOREF(pDbgc);
5010	return 0;
5011	}
5012
5013
5014	/**
5015	* Bitwise not (unary).
5016	*
5017	* @returns 0 on success.
5018	* @returns VBox evaluation / parsing error code on failure.
5019	* The caller does the bitching.
5020	* @param pDbgc Debugger console instance data.
5021	* @param pArg The argument.
5022	* @param pResult Where to store the result.
5023	*/
5024	static DECLCALLBACK(int) dbgcOpBitwiseNot(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult)
5025	{
5026	// LogFlow(("dbgcOpBitwiseNot\n"));
5027	pResult = pArg;
5028	switch (pArg->enmType)
5029	{
5030	case DBGCVAR_TYPE_GC_FLAT:
5031	pResult->u.GCFlat = ~pResult->u.GCFlat;
5032	break;
5033	case DBGCVAR_TYPE_GC_FAR:
5034	pResult->u.GCFar.off = ~pResult->u.GCFar.off;
5035	break;
5036	case DBGCVAR_TYPE_GC_PHYS:
5037	pResult->u.GCPhys = ~pResult->u.GCPhys;
5038	break;
5039	case DBGCVAR_TYPE_HC_FLAT:
5040	pResult->u.pvHCFlat = (void *)~(uintptr_t)pResult->u.pvHCFlat;
5041	break;
5042	case DBGCVAR_TYPE_HC_FAR:
5043	pResult->u.HCFar.off= ~pResult->u.HCFar.off;
5044	break;
5045	case DBGCVAR_TYPE_HC_PHYS:
5046	pResult->u.HCPhys = ~pResult->u.HCPhys;
5047	break;
5048	case DBGCVAR_TYPE_NUMBER:
5049	pResult->u.u64Number = ~pResult->u.u64Number;
5050	break;
5051
5052	case DBGCVAR_TYPE_UNKNOWN:
5053	case DBGCVAR_TYPE_STRING:
5054	default:
5055	return VERR_PARSE_INCORRECT_ARG_TYPE;
5056	}
5057	NOREF(pDbgc);
5058	return 0;
5059	}
5060
5061
5062	/**
5063	* Reference variable (unary).
5064	*
5065	* @returns 0 on success.
5066	* @returns VBox evaluation / parsing error code on failure.
5067	* The caller does the bitching.
5068	* @param pDbgc Debugger console instance data.
5069	* @param pArg The argument.
5070	* @param pResult Where to store the result.
5071	*/
5072	static DECLCALLBACK(int) dbgcOpVar(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult)
5073	{
5074	// LogFlow(("dbgcOpVar: %s\n", pArg->u.pszString));
5075	/*
5076	* Parse sanity.
5077	*/
5078	if (pArg->enmType != DBGCVAR_TYPE_STRING)
5079	return VERR_PARSE_INCORRECT_ARG_TYPE;
5080
5081	/*
5082	* Lookup the variable.
5083	*/
5084	const char *pszVar = pArg->u.pszString;
5085	for (unsigned iVar = 0; iVar < pDbgc->cVars; iVar++)
5086	{
5087	if (!strcmp(pszVar, pDbgc->papVars[iVar]->szName))
5088	{
5089	*pResult = pDbgc->papVars[iVar]->Var;
5090	return 0;
5091	}
5092	}
5093
5094	return VERR_PARSE_VARIABLE_NOT_FOUND;
5095	}
5096
5097
5098	/**
5099	* Flat address (unary).
5100	*
5101	* @returns VINF_SUCCESS on success.
5102	* @returns VBox evaluation / parsing error code on failure.
5103	* The caller does the bitching.
5104	* @param pDbgc Debugger console instance data.
5105	* @param pArg The argument.
5106	* @param pResult Where to store the result.
5107	*/
5108	static DECLCALLBACK(int) dbgcOpAddrFlat(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult)
5109	{
5110	// LogFlow(("dbgcOpAddrFlat\n"));
5111	int rc;
5112	pResult = pArg;
5113
5114	switch (pArg->enmType)
5115	{
5116	case DBGCVAR_TYPE_GC_FLAT:
5117	return VINF_SUCCESS;
5118
5119	case DBGCVAR_TYPE_GC_FAR:
5120	{
5121	Assert(pDbgc->pVM);
5122	DBGFADDRESS Address;
5123	rc = DBGFR3AddrFromSelOff(pDbgc->pVM, &Address, pArg->u.GCFar.sel, pArg->u.GCFar.off);
5124	if (VBOX_SUCCESS(rc))
5125	{
5126	pResult->enmType = DBGCVAR_TYPE_GC_FLAT;
5127	pResult->u.GCFlat = Address.FlatPtr;
5128	return VINF_SUCCESS;
5129	}
5130	return VERR_PARSE_CONVERSION_FAILED;
5131	}
5132
5133	case DBGCVAR_TYPE_GC_PHYS:
5134	//rc = MMR3PhysGCPhys2GCVirtEx(pDbgc->pVM, pResult->u.GCPhys, ..., &pResult->u.GCFlat); - yea, sure.
5135	return VERR_PARSE_INCORRECT_ARG_TYPE;
5136
5137	case DBGCVAR_TYPE_HC_FLAT:
5138	return VINF_SUCCESS;
5139
5140	case DBGCVAR_TYPE_HC_FAR:
5141	return VERR_PARSE_INCORRECT_ARG_TYPE;
5142
5143	case DBGCVAR_TYPE_HC_PHYS:
5144	Assert(pDbgc->pVM);
5145	pResult->enmType = DBGCVAR_TYPE_HC_FLAT;
5146	rc = MMR3HCPhys2HCVirt(pDbgc->pVM, pResult->u.HCPhys, &pResult->u.pvHCFlat);
5147	if (VBOX_SUCCESS(rc))
5148	return VINF_SUCCESS;
5149	return VERR_PARSE_CONVERSION_FAILED;
5150
5151	case DBGCVAR_TYPE_NUMBER:
5152	pResult->enmType = DBGCVAR_TYPE_GC_FLAT;
5153	pResult->u.GCFlat = (RTGCPTR)pResult->u.u64Number;
5154	return VINF_SUCCESS;
5155
5156	case DBGCVAR_TYPE_STRING:
5157	return dbgcSymbolGet(pDbgc, pArg->u.pszString, DBGCVAR_TYPE_GC_FLAT, pResult);
5158
5159	case DBGCVAR_TYPE_UNKNOWN:
5160	default:
5161	return VERR_PARSE_INCORRECT_ARG_TYPE;
5162	}
5163	}
5164
5165
5166	/**
5167	* Physical address (unary).
5168	*
5169	* @returns 0 on success.
5170	* @returns VBox evaluation / parsing error code on failure.
5171	* The caller does the bitching.
5172	* @param pDbgc Debugger console instance data.
5173	* @param pArg The argument.
5174	* @param pResult Where to store the result.
5175	*/
5176	static DECLCALLBACK(int) dbgcOpAddrPhys(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult)
5177	{
5178	// LogFlow(("dbgcOpAddrPhys\n"));
5179	int rc;
5180
5181	pResult = pArg;
5182	switch (pArg->enmType)
5183	{
5184	case DBGCVAR_TYPE_GC_FLAT:
5185	Assert(pDbgc->pVM);
5186	pResult->enmType = DBGCVAR_TYPE_GC_PHYS;
5187	rc = PGMPhysGCPtr2GCPhys(pDbgc->pVM, pArg->u.GCFlat, &pResult->u.GCPhys);
5188	if (VBOX_SUCCESS(rc))
5189	return 0;
5190	/** @todo more memory types! */
5191	return VERR_PARSE_CONVERSION_FAILED;
5192
5193	case DBGCVAR_TYPE_GC_FAR:
5194	{
5195	Assert(pDbgc->pVM);
5196	DBGFADDRESS Address;
5197	rc = DBGFR3AddrFromSelOff(pDbgc->pVM, &Address, pArg->u.GCFar.sel, pArg->u.GCFar.off);
5198	if (VBOX_SUCCESS(rc))
5199	{
5200	pResult->enmType = DBGCVAR_TYPE_GC_PHYS;
5201	rc = PGMPhysGCPtr2GCPhys(pDbgc->pVM, Address.FlatPtr, &pResult->u.GCPhys);
5202	if (VBOX_SUCCESS(rc))
5203	return 0;
5204	/** @todo more memory types! */
5205	}
5206	return VERR_PARSE_CONVERSION_FAILED;
5207	}
5208
5209	case DBGCVAR_TYPE_GC_PHYS:
5210	return 0;
5211
5212	case DBGCVAR_TYPE_HC_FLAT:
5213	Assert(pDbgc->pVM);
5214	pResult->enmType = DBGCVAR_TYPE_GC_PHYS;
5215	rc = PGMR3DbgHCPtr2GCPhys(pDbgc->pVM, pArg->u.pvHCFlat, &pResult->u.GCPhys);
5216	if (VBOX_SUCCESS(rc))
5217	return 0;
5218	/** @todo more memory types! */
5219	return VERR_PARSE_CONVERSION_FAILED;
5220
5221	case DBGCVAR_TYPE_HC_FAR:
5222	return VERR_PARSE_INCORRECT_ARG_TYPE;
5223
5224	case DBGCVAR_TYPE_HC_PHYS:
5225	return 0;
5226
5227	case DBGCVAR_TYPE_NUMBER:
5228	pResult->enmType = DBGCVAR_TYPE_GC_PHYS;
5229	pResult->u.GCPhys = (RTGCPHYS)pResult->u.u64Number;
5230	return 0;
5231
5232	case DBGCVAR_TYPE_STRING:
5233	return dbgcSymbolGet(pDbgc, pArg->u.pszString, DBGCVAR_TYPE_GC_PHYS, pResult);
5234
5235	case DBGCVAR_TYPE_UNKNOWN:
5236	default:
5237	return VERR_PARSE_INCORRECT_ARG_TYPE;
5238	}
5239	return 0;
5240	}
5241
5242
5243	/**
5244	* Physical host address (unary).
5245	*
5246	* @returns 0 on success.
5247	* @returns VBox evaluation / parsing error code on failure.
5248	* The caller does the bitching.
5249	* @param pDbgc Debugger console instance data.
5250	* @param pArg The argument.
5251	* @param pResult Where to store the result.
5252	*/
5253	static DECLCALLBACK(int) dbgcOpAddrHostPhys(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult)
5254	{
5255	// LogFlow(("dbgcOpAddrPhys\n"));
5256	int rc;
5257
5258	pResult = pArg;
5259	switch (pArg->enmType)
5260	{
5261	case DBGCVAR_TYPE_GC_FLAT:
5262	Assert(pDbgc->pVM);
5263	pResult->enmType = DBGCVAR_TYPE_HC_PHYS;
5264	rc = PGMPhysGCPtr2HCPhys(pDbgc->pVM, pArg->u.GCFlat, &pResult->u.HCPhys);
5265	if (VBOX_SUCCESS(rc))
5266	return 0;
5267	/** @todo more memory types. */
5268	return VERR_PARSE_CONVERSION_FAILED;
5269
5270	case DBGCVAR_TYPE_GC_FAR:
5271	{
5272	Assert(pDbgc->pVM);
5273	DBGFADDRESS Address;
5274	rc = DBGFR3AddrFromSelOff(pDbgc->pVM, &Address, pArg->u.GCFar.sel, pArg->u.GCFar.off);
5275	if (VBOX_SUCCESS(rc))
5276	{
5277	pResult->enmType = DBGCVAR_TYPE_HC_PHYS;
5278	rc = PGMPhysGCPtr2HCPhys(pDbgc->pVM, Address.FlatPtr, &pResult->u.HCPhys);
5279	if (VBOX_SUCCESS(rc))
5280	return 0;
5281	/** @todo more memory types. */
5282	}
5283	return VERR_PARSE_CONVERSION_FAILED;
5284	}
5285
5286	case DBGCVAR_TYPE_GC_PHYS:
5287	Assert(pDbgc->pVM);
5288	pResult->enmType = DBGCVAR_TYPE_HC_PHYS;
5289	rc = PGMPhysGCPhys2HCPhys(pDbgc->pVM, pArg->u.GCFlat, &pResult->u.HCPhys);
5290	if (VBOX_SUCCESS(rc))
5291	return 0;
5292	return VERR_PARSE_CONVERSION_FAILED;
5293
5294	case DBGCVAR_TYPE_HC_FLAT:
5295	Assert(pDbgc->pVM);
5296	pResult->enmType = DBGCVAR_TYPE_HC_PHYS;
5297	rc = PGMR3DbgHCPtr2HCPhys(pDbgc->pVM, pArg->u.pvHCFlat, &pResult->u.HCPhys);
5298	if (VBOX_SUCCESS(rc))
5299	return 0;
5300	/** @todo more memory types! */
5301	return VERR_PARSE_CONVERSION_FAILED;
5302
5303	case DBGCVAR_TYPE_HC_FAR:
5304	return VERR_PARSE_INCORRECT_ARG_TYPE;
5305
5306	case DBGCVAR_TYPE_HC_PHYS:
5307	return 0;
5308
5309	case DBGCVAR_TYPE_NUMBER:
5310	pResult->enmType = DBGCVAR_TYPE_HC_PHYS;
5311	pResult->u.HCPhys = (RTGCPHYS)pResult->u.u64Number;
5312	return 0;
5313
5314	case DBGCVAR_TYPE_STRING:
5315	return dbgcSymbolGet(pDbgc, pArg->u.pszString, DBGCVAR_TYPE_HC_PHYS, pResult);
5316
5317	case DBGCVAR_TYPE_UNKNOWN:
5318	default:
5319	return VERR_PARSE_INCORRECT_ARG_TYPE;
5320	}
5321	return 0;
5322	}
5323
5324
5325	/**
5326	* Host address (unary).
5327	*
5328	* @returns 0 on success.
5329	* @returns VBox evaluation / parsing error code on failure.
5330	* The caller does the bitching.
5331	* @param pDbgc Debugger console instance data.
5332	* @param pArg The argument.
5333	* @param pResult Where to store the result.
5334	*/
5335	static DECLCALLBACK(int) dbgcOpAddrHost(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult)
5336	{
5337	// LogFlow(("dbgcOpAddrHost\n"));
5338	int rc;
5339
5340	pResult = pArg;
5341	switch (pArg->enmType)
5342	{
5343	case DBGCVAR_TYPE_GC_FLAT:
5344	Assert(pDbgc->pVM);
5345	pResult->enmType = DBGCVAR_TYPE_HC_FLAT;
5346	rc = PGMPhysGCPtr2HCPtr(pDbgc->pVM, pArg->u.GCFlat, &pResult->u.pvHCFlat);
5347	if (VBOX_SUCCESS(rc))
5348	return 0;
5349	/** @todo more memory types. */
5350	return VERR_PARSE_CONVERSION_FAILED;
5351
5352	case DBGCVAR_TYPE_GC_FAR:
5353	{
5354	Assert(pDbgc->pVM);
5355	DBGFADDRESS Address;
5356	rc = DBGFR3AddrFromSelOff(pDbgc->pVM, &Address, pArg->u.GCFar.sel, pArg->u.GCFar.off);
5357	if (VBOX_SUCCESS(rc))
5358	{
5359	pResult->enmType = DBGCVAR_TYPE_HC_FLAT;
5360	rc = PGMPhysGCPtr2HCPtr(pDbgc->pVM, Address.FlatPtr, &pResult->u.pvHCFlat);
5361	if (VBOX_SUCCESS(rc))
5362	return 0;
5363	/** @todo more memory types. */
5364	}
5365	return VERR_PARSE_CONVERSION_FAILED;
5366	}
5367
5368	case DBGCVAR_TYPE_GC_PHYS:
5369	Assert(pDbgc->pVM);
5370	pResult->enmType = DBGCVAR_TYPE_HC_FLAT;
5371	rc = PGMPhysGCPhys2HCPtr(pDbgc->pVM, pArg->u.GCPhys, 1, &pResult->u.pvHCFlat);
5372	if (VBOX_SUCCESS(rc))
5373	return 0;
5374	return VERR_PARSE_CONVERSION_FAILED;
5375
5376	case DBGCVAR_TYPE_HC_FLAT:
5377	return 0;
5378
5379	case DBGCVAR_TYPE_HC_FAR:
5380	case DBGCVAR_TYPE_HC_PHYS:
5381	/** @todo !*/
5382	return VERR_PARSE_CONVERSION_FAILED;
5383
5384	case DBGCVAR_TYPE_NUMBER:
5385	pResult->enmType = DBGCVAR_TYPE_HC_FLAT;
5386	pResult->u.pvHCFlat = (void *)(uintptr_t)pResult->u.u64Number;
5387	return 0;
5388
5389	case DBGCVAR_TYPE_STRING:
5390	return dbgcSymbolGet(pDbgc, pArg->u.pszString, DBGCVAR_TYPE_HC_FLAT, pResult);
5391
5392	case DBGCVAR_TYPE_UNKNOWN:
5393	default:
5394	return VERR_PARSE_INCORRECT_ARG_TYPE;
5395	}
5396	}
5397
5398	/**
5399	* Bitwise not (unary).
5400	*
5401	* @returns 0 on success.
5402	* @returns VBox evaluation / parsing error code on failure.
5403	* The caller does the bitching.
5404	* @param pDbgc Debugger console instance data.
5405	* @param pArg The argument.
5406	* @param pResult Where to store the result.
5407	*/
5408	static DECLCALLBACK(int) dbgcOpAddrFar(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
5409	{
5410	// LogFlow(("dbgcOpAddrFar\n"));
5411	int rc;
5412
5413	switch (pArg1->enmType)
5414	{
5415	case DBGCVAR_TYPE_STRING:
5416	rc = dbgcSymbolGet(pDbgc, pArg1->u.pszString, DBGCVAR_TYPE_NUMBER, pResult);
5417	if (VBOX_FAILURE(rc))
5418	return rc;
5419	break;
5420	case DBGCVAR_TYPE_NUMBER:
5421	pResult = pArg1;
5422	break;
5423
5424	case DBGCVAR_TYPE_GC_FLAT:
5425	case DBGCVAR_TYPE_GC_FAR:
5426	case DBGCVAR_TYPE_GC_PHYS:
5427	case DBGCVAR_TYPE_HC_FLAT:
5428	case DBGCVAR_TYPE_HC_FAR:
5429	case DBGCVAR_TYPE_HC_PHYS:
5430	case DBGCVAR_TYPE_UNKNOWN:
5431	default:
5432	return VERR_PARSE_INCORRECT_ARG_TYPE;
5433	}
5434	pResult->u.GCFar.sel = (RTSEL)pResult->u.u64Number;
5435
5436	/* common code for the two types we support. */
5437	switch (pArg2->enmType)
5438	{
5439	case DBGCVAR_TYPE_GC_FLAT:
5440	pResult->u.GCFar.off = pArg2->u.GCFlat;
5441	pResult->enmType = DBGCVAR_TYPE_GC_FAR;
5442	break;
5443
5444	case DBGCVAR_TYPE_HC_FLAT:
5445	pResult->u.HCFar.off = pArg2->u.GCFlat;
5446	pResult->enmType = DBGCVAR_TYPE_GC_FAR;
5447	break;
5448
5449	case DBGCVAR_TYPE_NUMBER:
5450	pResult->u.GCFar.off = (RTGCPTR)pArg2->u.u64Number;
5451	pResult->enmType = DBGCVAR_TYPE_GC_FAR;
5452	break;
5453
5454	case DBGCVAR_TYPE_STRING:
5455	{
5456	DBGCVAR Var;
5457	rc = dbgcSymbolGet(pDbgc, pArg2->u.pszString, DBGCVAR_TYPE_NUMBER, &Var);
5458	if (VBOX_FAILURE(rc))
5459	return rc;
5460	pResult->u.GCFar.off = (RTGCPTR)Var.u.u64Number;
5461	pResult->enmType = DBGCVAR_TYPE_GC_FAR;
5462	break;
5463	}
5464
5465	case DBGCVAR_TYPE_GC_FAR:
5466	case DBGCVAR_TYPE_GC_PHYS:
5467	case DBGCVAR_TYPE_HC_FAR:
5468	case DBGCVAR_TYPE_HC_PHYS:
5469	case DBGCVAR_TYPE_UNKNOWN:
5470	default:
5471	return VERR_PARSE_INCORRECT_ARG_TYPE;
5472	}
5473	return 0;
5474
5475	}
5476
5477
5478	/**
5479	* Multiplication operator (binary).
5480	*
5481	* @returns 0 on success.
5482	* @returns VBox evaluation / parsing error code on failure.
5483	* The caller does the bitching.
5484	* @param pDbgc Debugger console instance data.
5485	* @param pArg1 The first argument.
5486	* @param pArg2 The 2nd argument.
5487	* @param pResult Where to store the result.
5488	*/
5489	static DECLCALLBACK(int) dbgcOpMult(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
5490	{
5491	// LogFlow(("dbgcOpMult\n"));
5492	int rc;
5493
5494	/*
5495	* Switch the factors so we preserve pointers, far pointers are considered more
5496	* important that physical and flat pointers.
5497	*/
5498	if ( DBGCVAR_ISPOINTER(pArg2->enmType)
5499	&& ( !DBGCVAR_ISPOINTER(pArg1->enmType)
5500	\|\| ( DBGCVAR_IS_FAR_PTR(pArg2->enmType)
5501	&& !DBGCVAR_IS_FAR_PTR(pArg1->enmType))))
5502	{
5503	PCDBGCVAR pTmp = pArg1;
5504	pArg2 = pArg1;
5505	pArg1 = pTmp;
5506	}
5507
5508	/*
5509	* Convert the 2nd number into a number we use multiply the first with.
5510	*/
5511	DBGCVAR Factor2 = *pArg2;
5512	if ( Factor2.enmType == DBGCVAR_TYPE_STRING
5513	\|\| Factor2.enmType == DBGCVAR_TYPE_SYMBOL)
5514	{
5515	rc = dbgcSymbolGet(pDbgc, pArg2->u.pszString, DBGCVAR_TYPE_NUMBER, &Factor2);
5516	if (VBOX_FAILURE(rc))
5517	return rc;
5518	}
5519	uint64_t u64Factor;
5520	switch (Factor2.enmType)
5521	{
5522	case DBGCVAR_TYPE_GC_FLAT: u64Factor = Factor2.u.GCFlat; break;
5523	case DBGCVAR_TYPE_GC_FAR: u64Factor = Factor2.u.GCFar.off; break;
5524	case DBGCVAR_TYPE_GC_PHYS: u64Factor = Factor2.u.GCPhys; break;
5525	case DBGCVAR_TYPE_HC_FLAT: u64Factor = (uintptr_t)Factor2.u.pvHCFlat; break;
5526	case DBGCVAR_TYPE_HC_FAR: u64Factor = Factor2.u.HCFar.off; break;
5527	case DBGCVAR_TYPE_HC_PHYS: u64Factor = Factor2.u.HCPhys; break;
5528	case DBGCVAR_TYPE_NUMBER: u64Factor = Factor2.u.u64Number; break;
5529	default:
5530	return VERR_PARSE_INCORRECT_ARG_TYPE;
5531	}
5532
5533	/*
5534	* Fix symbols in the 1st factor.
5535	*/
5536	pResult = pArg1;
5537	if ( pResult->enmType == DBGCVAR_TYPE_STRING
5538	\|\| pResult->enmType == DBGCVAR_TYPE_SYMBOL)
5539	{
5540	rc = dbgcSymbolGet(pDbgc, pArg1->u.pszString, DBGCVAR_TYPE_ANY, pResult);
5541	if (VBOX_FAILURE(rc))
5542	return rc;
5543	}
5544
5545	/*
5546	* Do the multiplication.
5547	*/
5548	switch (pArg1->enmType)
5549	{
5550	case DBGCVAR_TYPE_GC_FLAT: pResult->u.GCFlat *= u64Factor; break;
5551	case DBGCVAR_TYPE_GC_FAR: pResult->u.GCFar.off *= u64Factor; break;
5552	case DBGCVAR_TYPE_GC_PHYS: pResult->u.GCPhys *= u64Factor; break;
5553	case DBGCVAR_TYPE_HC_FLAT:
5554	pResult->u.pvHCFlat = (void )(uintptr_t)((uintptr_t)pResult->u.pvHCFlat u64Factor);
5555	break;
5556	case DBGCVAR_TYPE_HC_FAR: pResult->u.HCFar.off *= u64Factor; break;
5557	case DBGCVAR_TYPE_HC_PHYS: pResult->u.HCPhys *= u64Factor; break;
5558	case DBGCVAR_TYPE_NUMBER: pResult->u.u64Number *= u64Factor; break;
5559	default:
5560	return VERR_PARSE_INCORRECT_ARG_TYPE;
5561	}
5562	return 0;
5563	}
5564
5565
5566	/**
5567	* Division operator (binary).
5568	*
5569	* @returns 0 on success.
5570	* @returns VBox evaluation / parsing error code on failure.
5571	* The caller does the bitching.
5572	* @param pDbgc Debugger console instance data.
5573	* @param pArg1 The first argument.
5574	* @param pArg2 The 2nd argument.
5575	* @param pResult Where to store the result.
5576	*/
5577	static DECLCALLBACK(int) dbgcOpDiv(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
5578	{
5579	LogFlow(("dbgcOpDiv\n"));
5580	NOREF(pDbgc); NOREF(pArg1); NOREF(pArg2); NOREF(pResult);
5581	return -1;
5582	}
5583
5584
5585	/**
5586	* Modulus operator (binary).
5587	*
5588	* @returns 0 on success.
5589	* @returns VBox evaluation / parsing error code on failure.
5590	* The caller does the bitching.
5591	* @param pDbgc Debugger console instance data.
5592	* @param pArg1 The first argument.
5593	* @param pArg2 The 2nd argument.
5594	* @param pResult Where to store the result.
5595	*/
5596	static DECLCALLBACK(int) dbgcOpMod(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
5597	{
5598	LogFlow(("dbgcOpMod\n"));
5599	NOREF(pDbgc); NOREF(pArg1); NOREF(pArg2); NOREF(pResult);
5600	return -1;
5601	}
5602
5603
5604	/**
5605	* Addition operator (binary).
5606	*
5607	* @returns 0 on success.
5608	* @returns VBox evaluation / parsing error code on failure.
5609	* The caller does the bitching.
5610	* @param pDbgc Debugger console instance data.
5611	* @param pArg1 The first argument.
5612	* @param pArg2 The 2nd argument.
5613	* @param pResult Where to store the result.
5614	*/
5615	static DECLCALLBACK(int) dbgcOpAdd(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
5616	{
5617	// LogFlow(("dbgcOpAdd\n"));
5618
5619	/*
5620	* An addition operation will return (when possible) the left side type in the
5621	* expression. We make an omission for numbers, where we'll take the right side
5622	* type instead. An expression where only the left hand side is a string we'll
5623	* use the right hand type assuming that the string is a symbol.
5624	*/
5625	if ( (pArg1->enmType == DBGCVAR_TYPE_NUMBER && pArg2->enmType != DBGCVAR_TYPE_STRING)
5626	\|\| (pArg1->enmType == DBGCVAR_TYPE_STRING && pArg2->enmType != DBGCVAR_TYPE_STRING))
5627	{
5628	PCDBGCVAR pTmp = pArg2;
5629	pArg2 = pArg1;
5630	pArg1 = pTmp;
5631	}
5632	DBGCVAR Sym1, Sym2;
5633	if (pArg1->enmType == DBGCVAR_TYPE_STRING)
5634	{
5635	int rc = dbgcSymbolGet(pDbgc, pArg1->u.pszString, DBGCVAR_TYPE_ANY, &Sym1);
5636	if (VBOX_FAILURE(rc))
5637	return rc;
5638	pArg1 = &Sym1;
5639
5640	rc = dbgcSymbolGet(pDbgc, pArg2->u.pszString, DBGCVAR_TYPE_ANY, &Sym2);
5641	if (VBOX_FAILURE(rc))
5642	return rc;
5643	pArg2 = &Sym2;
5644	}
5645
5646	int rc;
5647	DBGCVAR Var;
5648	DBGCVAR Var2;
5649	switch (pArg1->enmType)
5650	{
5651	/*
5652	* GC Flat
5653	*/
5654	case DBGCVAR_TYPE_GC_FLAT:
5655	switch (pArg2->enmType)
5656	{
5657	case DBGCVAR_TYPE_HC_FLAT:
5658	case DBGCVAR_TYPE_HC_FAR:
5659	case DBGCVAR_TYPE_HC_PHYS:
5660	return VERR_PARSE_INVALID_OPERATION;
5661	default:
5662	pResult = pArg1;
5663	rc = dbgcOpAddrFlat(pDbgc, pArg2, &Var);
5664	if (VBOX_FAILURE(rc))
5665	return rc;
5666	pResult->u.GCFlat += pArg2->u.GCFlat;
5667	break;
5668	}
5669	break;
5670
5671	/*
5672	* GC Far
5673	*/
5674	case DBGCVAR_TYPE_GC_FAR:
5675	switch (pArg2->enmType)
5676	{
5677	case DBGCVAR_TYPE_HC_FLAT:
5678	case DBGCVAR_TYPE_HC_FAR:
5679	case DBGCVAR_TYPE_HC_PHYS:
5680	return VERR_PARSE_INVALID_OPERATION;
5681	case DBGCVAR_TYPE_NUMBER:
5682	pResult = pArg1;
5683	pResult->u.GCFar.off += (RTGCPTR)pArg2->u.u64Number;
5684	break;
5685	default:
5686	rc = dbgcOpAddrFlat(pDbgc, pArg1, pResult);
5687	if (VBOX_FAILURE(rc))
5688	return rc;
5689	rc = dbgcOpAddrFlat(pDbgc, pArg2, &Var);
5690	if (VBOX_FAILURE(rc))
5691	return rc;
5692	pResult->u.GCFlat += pArg2->u.GCFlat;
5693	break;
5694	}
5695	break;
5696
5697	/*
5698	* GC Phys
5699	*/
5700	case DBGCVAR_TYPE_GC_PHYS:
5701	switch (pArg2->enmType)
5702	{
5703	case DBGCVAR_TYPE_HC_FLAT:
5704	case DBGCVAR_TYPE_HC_FAR:
5705	case DBGCVAR_TYPE_HC_PHYS:
5706	return VERR_PARSE_INVALID_OPERATION;
5707	default:
5708	pResult = pArg1;
5709	rc = dbgcOpAddrPhys(pDbgc, pArg2, &Var);
5710	if (VBOX_FAILURE(rc))
5711	return rc;
5712	if (Var.enmType != DBGCVAR_TYPE_GC_PHYS)
5713	return VERR_PARSE_INVALID_OPERATION;
5714	pResult->u.GCPhys += Var.u.GCPhys;
5715	break;
5716	}
5717	break;
5718
5719	/*
5720	* HC Flat
5721	*/
5722	case DBGCVAR_TYPE_HC_FLAT:
5723	pResult = pArg1;
5724	rc = dbgcOpAddrHost(pDbgc, pArg2, &Var2);
5725	if (VBOX_FAILURE(rc))
5726	return rc;
5727	rc = dbgcOpAddrFlat(pDbgc, &Var2, &Var);
5728	if (VBOX_FAILURE(rc))
5729	return rc;
5730	pResult->u.pvHCFlat = (char *)pResult->u.pvHCFlat + (uintptr_t)Var.u.pvHCFlat;
5731	break;
5732
5733	/*
5734	* HC Far
5735	*/
5736	case DBGCVAR_TYPE_HC_FAR:
5737	switch (pArg2->enmType)
5738	{
5739	case DBGCVAR_TYPE_NUMBER:
5740	pResult = pArg1;
5741	pResult->u.HCFar.off += (uintptr_t)pArg2->u.u64Number;
5742	break;
5743
5744	default:
5745	rc = dbgcOpAddrFlat(pDbgc, pArg1, pResult);
5746	if (VBOX_FAILURE(rc))
5747	return rc;
5748	rc = dbgcOpAddrHost(pDbgc, pArg2, &Var2);
5749	if (VBOX_FAILURE(rc))
5750	return rc;
5751	rc = dbgcOpAddrFlat(pDbgc, &Var2, &Var);
5752	if (VBOX_FAILURE(rc))
5753	return rc;
5754	pResult->u.pvHCFlat = (char *)pResult->u.pvHCFlat + (uintptr_t)Var.u.pvHCFlat;
5755	break;
5756	}
5757	break;
5758
5759	/*
5760	* HC Phys
5761	*/
5762	case DBGCVAR_TYPE_HC_PHYS:
5763	pResult = pArg1;
5764	rc = dbgcOpAddrHostPhys(pDbgc, pArg2, &Var);
5765	if (VBOX_FAILURE(rc))
5766	return rc;
5767	pResult->u.HCPhys += Var.u.HCPhys;
5768	break;
5769
5770	/*
5771	* Numbers (see start of function)
5772	*/
5773	case DBGCVAR_TYPE_NUMBER:
5774	pResult = pArg1;
5775	switch (pArg2->enmType)
5776	{
5777	case DBGCVAR_TYPE_SYMBOL:
5778	case DBGCVAR_TYPE_STRING:
5779	rc = dbgcSymbolGet(pDbgc, pArg2->u.pszString, DBGCVAR_TYPE_NUMBER, &Var);
5780	if (VBOX_FAILURE(rc))
5781	return rc;
5782	case DBGCVAR_TYPE_NUMBER:
5783	pResult->u.u64Number += pArg2->u.u64Number;
5784	break;
5785	default:
5786	return VERR_PARSE_INVALID_OPERATION;
5787	}
5788	break;
5789
5790	default:
5791	return VERR_PARSE_INVALID_OPERATION;
5792
5793	}
5794	return 0;
5795	}
5796
5797
5798	/**
5799	* Subtration operator (binary).
5800	*
5801	* @returns 0 on success.
5802	* @returns VBox evaluation / parsing error code on failure.
5803	* The caller does the bitching.
5804	* @param pDbgc Debugger console instance data.
5805	* @param pArg1 The first argument.
5806	* @param pArg2 The 2nd argument.
5807	* @param pResult Where to store the result.
5808	*/
5809	static DECLCALLBACK(int) dbgcOpSub(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
5810	{
5811	// LogFlow(("dbgcOpSub\n"));
5812
5813	/*
5814	* An subtraction operation will return the left side type in the expression.
5815	* However, if the left hand side is a number and the right hand a pointer of
5816	* some kind we'll convert the left hand side to the same type as the right hand.
5817	* Any strings will be attempted resolved as symbols.
5818	*/
5819	DBGCVAR Sym1, Sym2;
5820	if ( pArg2->enmType == DBGCVAR_TYPE_STRING
5821	&& ( pArg1->enmType == DBGCVAR_TYPE_NUMBER
5822	\|\| pArg1->enmType == DBGCVAR_TYPE_STRING))
5823	{
5824	int rc = dbgcSymbolGet(pDbgc, pArg2->u.pszString, DBGCVAR_TYPE_ANY, &Sym2);
5825	if (VBOX_FAILURE(rc))
5826	return rc;
5827	pArg2 = &Sym2;
5828	}
5829
5830	if (pArg1->enmType == DBGCVAR_TYPE_STRING)
5831	{
5832	DBGCVARTYPE enmType;
5833	switch (pArg2->enmType)
5834	{
5835	case DBGCVAR_TYPE_NUMBER:
5836	enmType = DBGCVAR_TYPE_ANY;
5837	break;
5838	case DBGCVAR_TYPE_GC_FLAT:
5839	case DBGCVAR_TYPE_GC_PHYS:
5840	case DBGCVAR_TYPE_HC_FLAT:
5841	case DBGCVAR_TYPE_HC_PHYS:
5842	enmType = pArg2->enmType;
5843	break;
5844	case DBGCVAR_TYPE_GC_FAR:
5845	enmType = DBGCVAR_TYPE_GC_FLAT;
5846	break;
5847	case DBGCVAR_TYPE_HC_FAR:
5848	enmType = DBGCVAR_TYPE_HC_FLAT;
5849	break;
5850
5851	default:
5852	case DBGCVAR_TYPE_STRING:
5853	AssertMsgFailed(("Can't happen\n"));
5854	enmType = DBGCVAR_TYPE_STRING;
5855	break;
5856	}
5857	if (enmType != DBGCVAR_TYPE_STRING)
5858	{
5859	int rc = dbgcSymbolGet(pDbgc, pArg1->u.pszString, DBGCVAR_TYPE_ANY, &Sym1);
5860	if (VBOX_FAILURE(rc))
5861	return rc;
5862	pArg1 = &Sym1;
5863	}
5864	}
5865	else if (pArg1->enmType == DBGCVAR_TYPE_NUMBER)
5866	{
5867	PFNDBGCOPUNARY pOp = NULL;
5868	switch (pArg2->enmType)
5869	{
5870	case DBGCVAR_TYPE_GC_FAR:
5871	case DBGCVAR_TYPE_GC_FLAT:
5872	pOp = dbgcOpAddrFlat;
5873	break;
5874	case DBGCVAR_TYPE_GC_PHYS:
5875	pOp = dbgcOpAddrPhys;
5876	break;
5877	case DBGCVAR_TYPE_HC_FAR:
5878	case DBGCVAR_TYPE_HC_FLAT:
5879	pOp = dbgcOpAddrHost;
5880	break;
5881	case DBGCVAR_TYPE_HC_PHYS:
5882	pOp = dbgcOpAddrHostPhys;
5883	break;
5884	case DBGCVAR_TYPE_NUMBER:
5885	break;
5886	default:
5887	case DBGCVAR_TYPE_STRING:
5888	AssertMsgFailed(("Can't happen\n"));
5889	break;
5890	}
5891	if (pOp)
5892	{
5893	int rc = pOp(pDbgc, pArg1, &Sym1);
5894	if (VBOX_FAILURE(rc))
5895	return rc;
5896	pArg1 = &Sym1;
5897	}
5898	}
5899
5900
5901	/*
5902	* Normal processing.
5903	*/
5904	int rc;
5905	DBGCVAR Var;
5906	DBGCVAR Var2;
5907	switch (pArg1->enmType)
5908	{
5909	/*
5910	* GC Flat
5911	*/
5912	case DBGCVAR_TYPE_GC_FLAT:
5913	switch (pArg2->enmType)
5914	{
5915	case DBGCVAR_TYPE_HC_FLAT:
5916	case DBGCVAR_TYPE_HC_FAR:
5917	case DBGCVAR_TYPE_HC_PHYS:
5918	return VERR_PARSE_INVALID_OPERATION;
5919	default:
5920	pResult = pArg1;
5921	rc = dbgcOpAddrFlat(pDbgc, pArg2, &Var);
5922	if (VBOX_FAILURE(rc))
5923	return rc;
5924	pResult->u.GCFlat -= pArg2->u.GCFlat;
5925	break;
5926	}
5927	break;
5928
5929	/*
5930	* GC Far
5931	*/
5932	case DBGCVAR_TYPE_GC_FAR:
5933	switch (pArg2->enmType)
5934	{
5935	case DBGCVAR_TYPE_HC_FLAT:
5936	case DBGCVAR_TYPE_HC_FAR:
5937	case DBGCVAR_TYPE_HC_PHYS:
5938	return VERR_PARSE_INVALID_OPERATION;
5939	case DBGCVAR_TYPE_NUMBER:
5940	pResult = pArg1;
5941	pResult->u.GCFar.off -= (RTGCPTR)pArg2->u.u64Number;
5942	break;
5943	default:
5944	rc = dbgcOpAddrFlat(pDbgc, pArg1, pResult);
5945	if (VBOX_FAILURE(rc))
5946	return rc;
5947	rc = dbgcOpAddrFlat(pDbgc, pArg2, &Var);
5948	if (VBOX_FAILURE(rc))
5949	return rc;
5950	pResult->u.GCFlat -= pArg2->u.GCFlat;
5951	break;
5952	}
5953	break;
5954
5955	/*
5956	* GC Phys
5957	*/
5958	case DBGCVAR_TYPE_GC_PHYS:
5959	switch (pArg2->enmType)
5960	{
5961	case DBGCVAR_TYPE_HC_FLAT:
5962	case DBGCVAR_TYPE_HC_FAR:
5963	case DBGCVAR_TYPE_HC_PHYS:
5964	return VERR_PARSE_INVALID_OPERATION;
5965	default:
5966	pResult = pArg1;
5967	rc = dbgcOpAddrPhys(pDbgc, pArg2, &Var);
5968	if (VBOX_FAILURE(rc))
5969	return rc;
5970	if (Var.enmType != DBGCVAR_TYPE_GC_PHYS)
5971	return VERR_PARSE_INVALID_OPERATION;
5972	pResult->u.GCPhys -= Var.u.GCPhys;
5973	break;
5974	}
5975	break;
5976
5977	/*
5978	* HC Flat
5979	*/
5980	case DBGCVAR_TYPE_HC_FLAT:
5981	pResult = pArg1;
5982	rc = dbgcOpAddrHost(pDbgc, pArg2, &Var2);
5983	if (VBOX_FAILURE(rc))
5984	return rc;
5985	rc = dbgcOpAddrFlat(pDbgc, &Var2, &Var);
5986	if (VBOX_FAILURE(rc))
5987	return rc;
5988	pResult->u.pvHCFlat = (char *)pResult->u.pvHCFlat - (uintptr_t)Var.u.pvHCFlat;
5989	break;
5990
5991	/*
5992	* HC Far
5993	*/
5994	case DBGCVAR_TYPE_HC_FAR:
5995	switch (pArg2->enmType)
5996	{
5997	case DBGCVAR_TYPE_NUMBER:
5998	pResult = pArg1;
5999	pResult->u.HCFar.off -= (uintptr_t)pArg2->u.u64Number;
6000	break;
6001
6002	default:
6003	rc = dbgcOpAddrFlat(pDbgc, pArg1, pResult);
6004	if (VBOX_FAILURE(rc))
6005	return rc;
6006	rc = dbgcOpAddrHost(pDbgc, pArg2, &Var2);
6007	if (VBOX_FAILURE(rc))
6008	return rc;
6009	rc = dbgcOpAddrFlat(pDbgc, &Var2, &Var);
6010	if (VBOX_FAILURE(rc))
6011	return rc;
6012	pResult->u.pvHCFlat = (char *)pResult->u.pvHCFlat - (uintptr_t)Var.u.pvHCFlat;
6013	break;
6014	}
6015	break;
6016
6017	/*
6018	* HC Phys
6019	*/
6020	case DBGCVAR_TYPE_HC_PHYS:
6021	pResult = pArg1;
6022	rc = dbgcOpAddrHostPhys(pDbgc, pArg2, &Var);
6023	if (VBOX_FAILURE(rc))
6024	return rc;
6025	pResult->u.HCPhys -= Var.u.HCPhys;
6026	break;
6027
6028	/*
6029	* Numbers (see start of function)
6030	*/
6031	case DBGCVAR_TYPE_NUMBER:
6032	pResult = pArg1;
6033	switch (pArg2->enmType)
6034	{
6035	case DBGCVAR_TYPE_SYMBOL:
6036	case DBGCVAR_TYPE_STRING:
6037	rc = dbgcSymbolGet(pDbgc, pArg2->u.pszString, DBGCVAR_TYPE_NUMBER, &Var);
6038	if (VBOX_FAILURE(rc))
6039	return rc;
6040	case DBGCVAR_TYPE_NUMBER:
6041	pResult->u.u64Number -= pArg2->u.u64Number;
6042	break;
6043	default:
6044	return VERR_PARSE_INVALID_OPERATION;
6045	}
6046	break;
6047
6048	default:
6049	return VERR_PARSE_INVALID_OPERATION;
6050
6051	}
6052	return 0;
6053	}
6054
6055
6056	/**
6057	* Bitwise shift left operator (binary).
6058	*
6059	* @returns 0 on success.
6060	* @returns VBox evaluation / parsing error code on failure.
6061	* The caller does the bitching.
6062	* @param pDbgc Debugger console instance data.
6063	* @param pArg1 The first argument.
6064	* @param pArg2 The 2nd argument.
6065	* @param pResult Where to store the result.
6066	*/
6067	static DECLCALLBACK(int) dbgcOpBitwiseShiftLeft(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
6068	{
6069	LogFlow(("dbgcOpBitwiseShiftLeft\n"));
6070	NOREF(pDbgc); NOREF(pArg1); NOREF(pArg2); NOREF(pResult);
6071	return -1;
6072	}
6073
6074
6075	/**
6076	* Bitwise shift right operator (binary).
6077	*
6078	* @returns 0 on success.
6079	* @returns VBox evaluation / parsing error code on failure.
6080	* The caller does the bitching.
6081	* @param pDbgc Debugger console instance data.
6082	* @param pArg1 The first argument.
6083	* @param pArg2 The 2nd argument.
6084	* @param pResult Where to store the result.
6085	*/
6086	static DECLCALLBACK(int) dbgcOpBitwiseShiftRight(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
6087	{
6088	LogFlow(("dbgcOpBitwiseShiftRight\n"));
6089	NOREF(pDbgc); NOREF(pArg1); NOREF(pArg2); NOREF(pResult);
6090	return -1;
6091	}
6092
6093
6094	/**
6095	* Bitwise and operator (binary).
6096	*
6097	* @returns 0 on success.
6098	* @returns VBox evaluation / parsing error code on failure.
6099	* The caller does the bitching.
6100	* @param pDbgc Debugger console instance data.
6101	* @param pArg1 The first argument.
6102	* @param pArg2 The 2nd argument.
6103	* @param pResult Where to store the result.
6104	*/
6105	static DECLCALLBACK(int) dbgcOpBitwiseAnd(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
6106	{
6107	LogFlow(("dbgcOpBitwiseAnd\n"));
6108	NOREF(pDbgc); NOREF(pArg1); NOREF(pArg2); NOREF(pResult);
6109	return -1;
6110	}
6111
6112
6113	/**
6114	* Bitwise exclusive or operator (binary).
6115	*
6116	* @returns 0 on success.
6117	* @returns VBox evaluation / parsing error code on failure.
6118	* The caller does the bitching.
6119	* @param pDbgc Debugger console instance data.
6120	* @param pArg1 The first argument.
6121	* @param pArg2 The 2nd argument.
6122	* @param pResult Where to store the result.
6123	*/
6124	static DECLCALLBACK(int) dbgcOpBitwiseXor(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
6125	{
6126	LogFlow(("dbgcOpBitwiseXor\n"));
6127	NOREF(pDbgc); NOREF(pArg1); NOREF(pArg2); NOREF(pResult);
6128	return -1;
6129	}
6130
6131
6132	/**
6133	* Bitwise inclusive or operator (binary).
6134	*
6135	* @returns 0 on success.
6136	* @returns VBox evaluation / parsing error code on failure.
6137	* The caller does the bitching.
6138	* @param pDbgc Debugger console instance data.
6139	* @param pArg1 The first argument.
6140	* @param pArg2 The 2nd argument.
6141	* @param pResult Where to store the result.
6142	*/
6143	static DECLCALLBACK(int) dbgcOpBitwiseOr(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
6144	{
6145	LogFlow(("dbgcOpBitwiseOr\n"));
6146	NOREF(pDbgc); NOREF(pArg1); NOREF(pArg2); NOREF(pResult);
6147	return -1;
6148	}
6149
6150
6151	/**
6152	* Boolean and operator (binary).
6153	*
6154	* @returns 0 on success.
6155	* @returns VBox evaluation / parsing error code on failure.
6156	* The caller does the bitching.
6157	* @param pDbgc Debugger console instance data.
6158	* @param pArg1 The first argument.
6159	* @param pArg2 The 2nd argument.
6160	* @param pResult Where to store the result.
6161	*/
6162	static DECLCALLBACK(int) dbgcOpBooleanAnd(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
6163	{
6164	LogFlow(("dbgcOpBooleanAnd\n"));
6165	NOREF(pDbgc); NOREF(pArg1); NOREF(pArg2); NOREF(pResult);
6166	return -1;
6167	}
6168
6169
6170	/**
6171	* Boolean or operator (binary).
6172	*
6173	* @returns 0 on success.
6174	* @returns VBox evaluation / parsing error code on failure.
6175	* The caller does the bitching.
6176	* @param pDbgc Debugger console instance data.
6177	* @param pArg1 The first argument.
6178	* @param pArg2 The 2nd argument.
6179	* @param pResult Where to store the result.
6180	*/
6181	static DECLCALLBACK(int) dbgcOpBooleanOr(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
6182	{
6183	LogFlow(("dbgcOpBooleanOr\n"));
6184	NOREF(pDbgc); NOREF(pArg1); NOREF(pArg2); NOREF(pResult);
6185	return -1;
6186	}
6187
6188
6189	/**
6190	* Range to operator (binary).
6191	*
6192	* @returns 0 on success.
6193	* @returns VBox evaluation / parsing error code on failure.
6194	* The caller does the bitching.
6195	* @param pDbgc Debugger console instance data.
6196	* @param pArg1 The first argument.
6197	* @param pArg2 The 2nd argument.
6198	* @param pResult Where to store the result.
6199	*/
6200	static DECLCALLBACK(int) dbgcOpRangeLength(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
6201	{
6202	// LogFlow(("dbgcOpRangeLength\n"));
6203	/*
6204	* Make result. Strings needs to be resolved into symbols.
6205	*/
6206	if (pArg1->enmType == DBGCVAR_TYPE_STRING)
6207	{
6208	int rc = dbgcSymbolGet(pDbgc, pArg1->u.pszString, DBGCVAR_TYPE_ANY, pResult);
6209	if (VBOX_FAILURE(rc))
6210	return rc;
6211	}
6212	else
6213	pResult = pArg1;
6214
6215	/*
6216	* Convert 2nd argument to element count.
6217	*/
6218	pResult->enmRangeType = DBGCVAR_RANGE_ELEMENTS;
6219	switch (pArg2->enmType)
6220	{
6221	case DBGCVAR_TYPE_NUMBER:
6222	pResult->u64Range = pArg2->u.u64Number;
6223	break;
6224
6225	case DBGCVAR_TYPE_STRING:
6226	{
6227	int rc = dbgcSymbolGet(pDbgc, pArg1->u.pszString, DBGCVAR_TYPE_NUMBER, pResult);
6228	if (VBOX_FAILURE(rc))
6229	return rc;
6230	pResult->u64Range = pArg2->u.u64Number;
6231	break;
6232	}
6233
6234	default:
6235	return VERR_PARSE_INVALID_OPERATION;
6236	}
6237
6238	return VINF_SUCCESS;
6239	}
6240
6241
6242	/**
6243	* Range to operator (binary).
6244	*
6245	* @returns 0 on success.
6246	* @returns VBox evaluation / parsing error code on failure.
6247	* The caller does the bitching.
6248	* @param pDbgc Debugger console instance data.
6249	* @param pArg1 The first argument.
6250	* @param pArg2 The 2nd argument.
6251	* @param pResult Where to store the result.
6252	*/
6253	static DECLCALLBACK(int) dbgcOpRangeLengthBytes(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
6254	{
6255	// LogFlow(("dbgcOpRangeLengthBytes\n"));
6256	int rc = dbgcOpRangeLength(pDbgc, pArg1, pArg2, pResult);
6257	if (VBOX_SUCCESS(rc))
6258	pResult->enmRangeType = DBGCVAR_RANGE_BYTES;
6259	return rc;
6260	}
6261
6262
6263	/**
6264	* Range to operator (binary).
6265	*
6266	* @returns 0 on success.
6267	* @returns VBox evaluation / parsing error code on failure.
6268	* The caller does the bitching.
6269	* @param pDbgc Debugger console instance data.
6270	* @param pArg1 The first argument.
6271	* @param pArg2 The 2nd argument.
6272	* @param pResult Where to store the result.
6273	*/
6274	static DECLCALLBACK(int) dbgcOpRangeTo(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
6275	{
6276	// LogFlow(("dbgcOpRangeTo\n"));
6277	/*
6278	* Calc number of bytes between the two args.
6279	*/
6280	DBGCVAR Diff;
6281	int rc = dbgcOpSub(pDbgc, pArg2, pArg1, &Diff);
6282	if (VBOX_FAILURE(rc))
6283	return rc;
6284
6285	/*
6286	* Use the diff as the range of Arg1.
6287	*/
6288	pResult = pArg1;
6289	pResult->enmRangeType = DBGCVAR_RANGE_BYTES;
6290	switch (Diff.enmType)
6291	{
6292	case DBGCVAR_TYPE_GC_FLAT:
6293	pResult->u64Range = (RTGCUINTPTR)Diff.u.GCFlat;
6294	break;
6295	case DBGCVAR_TYPE_GC_PHYS:
6296	pResult->u64Range = Diff.u.GCPhys;
6297	break;
6298	case DBGCVAR_TYPE_HC_FLAT:
6299	pResult->u64Range = (uintptr_t)Diff.u.pvHCFlat;
6300	break;
6301	case DBGCVAR_TYPE_HC_PHYS:
6302	pResult->u64Range = Diff.u.HCPhys;
6303	break;
6304	case DBGCVAR_TYPE_NUMBER:
6305	pResult->u64Range = Diff.u.u64Number;
6306	break;
6307
6308	case DBGCVAR_TYPE_GC_FAR:
6309	case DBGCVAR_TYPE_STRING:
6310	case DBGCVAR_TYPE_HC_FAR:
6311	default:
6312	AssertMsgFailed(("Impossible!\n"));
6313	return VERR_PARSE_INVALID_OPERATION;
6314	}
6315
6316	return 0;
6317	}
6318
6319
6320
6321
6322
6323	/**
6324	* Output callback.
6325	*
6326	* @returns number of bytes written.
6327	* @param pvArg User argument.
6328	* @param pachChars Pointer to an array of utf-8 characters.
6329	* @param cbChars Number of bytes in the character array pointed to by pachChars.
6330	*/
6331	static DECLCALLBACK(size_t) dbgcFormatOutput(void pvArg, const char pachChars, size_t cbChars)
6332	{
6333	PDBGC pDbgc = (PDBGC)pvArg;
6334	if (cbChars)
6335	{
6336	int rc = pDbgc->pBack->pfnWrite(pDbgc->pBack, pachChars, cbChars, NULL);
6337	if (VBOX_FAILURE(rc))
6338	{
6339	pDbgc->rcOutput = rc;
6340	cbChars = 0;
6341	}
6342	}
6343
6344	return cbChars;
6345	}
6346
6347
6348
6349
6350
6351
6352
6353
6354
6355	//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
6356	//
6357	//
6358	// C a l l b a c k H e l p e r s
6359	//
6360	//
6361	//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
6362
6363
6364
6365	/**
6366	* Command helper for writing text to the debug console.
6367	*
6368	* @returns VBox status.
6369	* @param pCmdHlp Pointer to the command callback structure.
6370	* @param pvBuf What to write.
6371	* @param cbBuf Number of bytes to write.
6372	* @param pcbWritten Where to store the number of bytes actually written.
6373	* If NULL the entire buffer must be successfully written.
6374	*/
6375	static DECLCALLBACK(int) dbgcHlpWrite(PDBGCCMDHLP pCmdHlp, const void pvBuf, size_t cbBuf, size_t pcbWritten)
6376	{
6377	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
6378	return pDbgc->pBack->pfnWrite(pDbgc->pBack, pvBuf, cbBuf, pcbWritten);
6379	}
6380
6381
6382	/**
6383	* Command helper for writing formatted text to the debug console.
6384	*
6385	* @returns VBox status.
6386	* @param pCmdHlp Pointer to the command callback structure.
6387	* @param pcb Where to store the number of bytes written.
6388	* @param pszFormat The format string.
6389	* This is using the log formatter, so it's format extensions can be used.
6390	* @param ... Arguments specified in the format string.
6391	*/
6392	static DECLCALLBACK(int) dbgcHlpPrintf(PDBGCCMDHLP pCmdHlp, size_t pcbWritten, const char pszFormat, ...)
6393	{
6394	/*
6395	* Do the formatting and output.
6396	*/
6397	va_list args;
6398	va_start(args, pszFormat);
6399	int rc = pCmdHlp->pfnPrintfV(pCmdHlp, pcbWritten, pszFormat, args);
6400	va_end(args);
6401
6402	return rc;
6403	}
6404
6405	/**
6406	* Callback to format non-standard format specifiers.
6407	*
6408	* @returns The number of bytes formatted.
6409	* @param pvArg Formatter argument.
6410	* @param pfnOutput Pointer to output function.
6411	* @param pvArgOutput Argument for the output function.
6412	* @param ppszFormat Pointer to the format string pointer. Advance this till the char
6413	* after the format specifier.
6414	* @param pArgs Pointer to the argument list. Use this to fetch the arguments.
6415	* @param cchWidth Format Width. -1 if not specified.
6416	* @param cchPrecision Format Precision. -1 if not specified.
6417	* @param fFlags Flags (RTSTR_NTFS_*).
6418	* @param chArgSize The argument size specifier, 'l' or 'L'.
6419	*/
6420	static DECLCALLBACK(int) dbgcStringFormatter(void pvArg, PFNRTSTROUTPUT pfnOutput, void pvArgOutput,
6421	const char *ppszFormat, va_list pArgs, int cchWidth, int cchPrecision, unsigned fFlags, char chArgSize)
6422	{
6423	NOREF(cchWidth); NOREF(cchPrecision); NOREF(fFlags); NOREF(chArgSize); NOREF(pvArg);
6424	if (**ppszFormat != 'D')
6425	{
6426	(*ppszFormat)++;
6427	return 0;
6428	}
6429
6430	(*ppszFormat)++;
6431	switch (**ppszFormat)
6432	{
6433	/*
6434	* Print variable without range.
6435	* The argument is a const pointer to the variable.
6436	*/
6437	case 'V':
6438	{
6439	(*ppszFormat)++;
6440	PCDBGCVAR pVar = va_arg(*pArgs, PCDBGCVAR);
6441	switch (pVar->enmType)
6442	{
6443	case DBGCVAR_TYPE_GC_FLAT:
6444	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%%%VGv", pVar->u.GCFlat);
6445	case DBGCVAR_TYPE_GC_FAR:
6446	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%04x:%08x", pVar->u.GCFar.sel, pVar->u.GCFar.off);
6447	case DBGCVAR_TYPE_GC_PHYS:
6448	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%%%%%VGp", pVar->u.GCPhys);
6449	case DBGCVAR_TYPE_HC_FLAT:
6450	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%%#%VHv", (uintptr_t)pVar->u.pvHCFlat);
6451	case DBGCVAR_TYPE_HC_FAR:
6452	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "#%04x:%08x", pVar->u.HCFar.sel, pVar->u.HCFar.off);
6453	case DBGCVAR_TYPE_HC_PHYS:
6454	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "#%%%%%VHp", pVar->u.HCPhys);
6455	case DBGCVAR_TYPE_STRING:
6456	return pfnOutput(pvArgOutput, pVar->u.pszString, (size_t)pVar->u64Range);
6457	case DBGCVAR_TYPE_NUMBER:
6458	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%llx", pVar->u.u64Number);
6459
6460	case DBGCVAR_TYPE_UNKNOWN:
6461	default:
6462	return pfnOutput(pvArgOutput, "??", 2);
6463	}
6464	}
6465
6466	/*
6467	* Print variable with range.
6468	* The argument is a const pointer to the variable.
6469	*/
6470	case 'v':
6471	{
6472	(*ppszFormat)++;
6473	PCDBGCVAR pVar = va_arg(*pArgs, PCDBGCVAR);
6474
6475	char szRange[32];
6476	switch (pVar->enmRangeType)
6477	{
6478	case DBGCVAR_RANGE_NONE:
6479	szRange[0] = '\0';
6480	break;
6481	case DBGCVAR_RANGE_ELEMENTS:
6482	RTStrPrintf(szRange, sizeof(szRange), " L %llx", pVar->u64Range);
6483	break;
6484	case DBGCVAR_RANGE_BYTES:
6485	RTStrPrintf(szRange, sizeof(szRange), " LB %llx", pVar->u64Range);
6486	break;
6487	}
6488
6489	switch (pVar->enmType)
6490	{
6491	case DBGCVAR_TYPE_GC_FLAT:
6492	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%%%VGv%s", pVar->u.GCFlat, szRange);
6493	case DBGCVAR_TYPE_GC_FAR:
6494	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%04x:%08x%s", pVar->u.GCFar.sel, pVar->u.GCFar.off, szRange);
6495	case DBGCVAR_TYPE_GC_PHYS:
6496	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%%%%%VGp%s", pVar->u.GCPhys, szRange);
6497	case DBGCVAR_TYPE_HC_FLAT:
6498	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%%#%VHv%s", (uintptr_t)pVar->u.pvHCFlat, szRange);
6499	case DBGCVAR_TYPE_HC_FAR:
6500	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "#%04x:%08x%s", pVar->u.HCFar.sel, pVar->u.HCFar.off, szRange);
6501	case DBGCVAR_TYPE_HC_PHYS:
6502	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "#%%%%%VHp%s", pVar->u.HCPhys, szRange);
6503	case DBGCVAR_TYPE_STRING:
6504	return pfnOutput(pvArgOutput, pVar->u.pszString, (size_t)pVar->u64Range);
6505	case DBGCVAR_TYPE_NUMBER:
6506	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%llx%s", pVar->u.u64Number, szRange);
6507
6508	case DBGCVAR_TYPE_UNKNOWN:
6509	default:
6510	return pfnOutput(pvArgOutput, "??", 2);
6511	}
6512	}
6513
6514	default:
6515	AssertMsgFailed(("Invalid format type '%s'!\n", **ppszFormat));
6516	return 0;
6517	}
6518	}
6519
6520
6521	/**
6522	* Command helper for writing formatted text to the debug console.
6523	*
6524	* @returns VBox status.
6525	* @param pCmdHlp Pointer to the command callback structure.
6526	* @param pcb Where to store the number of bytes written.
6527	* @param pszFormat The format string.
6528	* This is using the log formatter, so it's format extensions can be used.
6529	* @param args Arguments specified in the format string.
6530	*/
6531	static DECLCALLBACK(int) dbgcHlpPrintfV(PDBGCCMDHLP pCmdHlp, size_t pcbWritten, const char pszFormat, va_list args)
6532	{
6533	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
6534
6535	/*
6536	* Do the formatting and output.
6537	*/
6538	pDbgc->rcOutput = 0;
6539	size_t cb = RTStrFormatV(dbgcFormatOutput, pDbgc, dbgcStringFormatter, pDbgc, pszFormat, args);
6540
6541	if (pcbWritten)
6542	*pcbWritten = cb;
6543
6544	return pDbgc->rcOutput;
6545	}
6546
6547
6548	/**
6549	* Reports an error from a DBGF call.
6550	*
6551	* @returns VBox status code appropriate to return from a command.
6552	* @param pCmdHlp Pointer to command helpers.
6553	* @param rc The VBox status code returned by a DBGF call.
6554	* @param pszFormat Format string for additional messages. Can be NULL.
6555	* @param ... Format arguments, optional.
6556	*/
6557	static DECLCALLBACK(int) dbgcHlpVBoxErrorV(PDBGCCMDHLP pCmdHlp, int rc, const char *pszFormat, va_list args)
6558	{
6559	switch (rc)
6560	{
6561	case VINF_SUCCESS:
6562	break;
6563
6564	default:
6565	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: %Vrc: %s", rc, pszFormat ? " " : "\n");
6566	if (VBOX_SUCCESS(rc) && pszFormat)
6567	rc = pCmdHlp->pfnPrintfV(pCmdHlp, NULL, pszFormat, args);
6568	break;
6569	}
6570	return rc;
6571	}
6572
6573
6574	/**
6575	* Reports an error from a DBGF call.
6576	*
6577	* @returns VBox status code appropriate to return from a command.
6578	* @param pCmdHlp Pointer to command helpers.
6579	* @param rc The VBox status code returned by a DBGF call.
6580	* @param pszFormat Format string for additional messages. Can be NULL.
6581	* @param ... Format arguments, optional.
6582	*/
6583	static DECLCALLBACK(int) dbgcHlpVBoxError(PDBGCCMDHLP pCmdHlp, int rc, const char *pszFormat, ...)
6584	{
6585	va_list args;
6586	va_start(args, pszFormat);
6587	int rcRet = pCmdHlp->pfnVBoxErrorV(pCmdHlp, rc, pszFormat, args);
6588	va_end(args);
6589	return rcRet;
6590	}
6591
6592
6593	/**
6594	* Command helper for reading memory specified by a DBGC variable.
6595	*
6596	* @returns VBox status code appropriate to return from a command.
6597	* @param pCmdHlp Pointer to the command callback structure.
6598	* @param pVM VM handle if GC or physical HC address.
6599	* @param pvBuffer Where to store the read data.
6600	* @param cbRead Number of bytes to read.
6601	* @param pVarPointer DBGC variable specifying where to start reading.
6602	* @param pcbRead Where to store the number of bytes actually read.
6603	* This optional, but it's useful when read GC virtual memory where a
6604	* page in the requested range might not be present.
6605	* If not specified not-present failure or end of a HC physical page
6606	* will cause failure.
6607	*/
6608	static DECLCALLBACK(int) dbgcHlpMemRead(PDBGCCMDHLP pCmdHlp, PVM pVM, void pvBuffer, size_t cbRead, PCDBGCVAR pVarPointer, size_t pcbRead)
6609	{
6610	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
6611
6612	/*
6613	* Dummy check.
6614	*/
6615	if (cbRead == 0)
6616	{
6617	if (*pcbRead)
6618	*pcbRead = 0;
6619	return VINF_SUCCESS;
6620	}
6621
6622	/*
6623	* Convert Far addresses getting size and the correct base address.
6624	* Getting and checking the size is what makes this messy and slow.
6625	*/
6626	DBGCVAR Var = *pVarPointer;
6627	switch (pVarPointer->enmType)
6628	{
6629	case DBGCVAR_TYPE_GC_FAR:
6630	{
6631	/* Use DBGFR3AddrFromSelOff for the conversion. */
6632	Assert(pDbgc->pVM);
6633	DBGFADDRESS Address;
6634	int rc = DBGFR3AddrFromSelOff(pDbgc->pVM, &Address, Var.u.GCFar.sel, Var.u.GCFar.off);
6635	if (VBOX_FAILURE(rc))
6636	return rc;
6637
6638	/* don't bother with flat selectors (for now). */
6639	if (!DBGFADDRESS_IS_FLAT(&Address))
6640	{
6641	SELMSELINFO SelInfo;
6642	rc = SELMR3GetSelectorInfo(pDbgc->pVM, Address.Sel, &SelInfo);
6643	if (VBOX_SUCCESS(rc))
6644	{
6645	RTGCUINTPTR cb; /* -1 byte */
6646	if (SELMSelInfoIsExpandDown(&SelInfo))
6647	{
6648	if ( !SelInfo.Raw.Gen.u1Granularity
6649	&& Address.off > UINT16_C(0xffff))
6650	return VERR_OUT_OF_SELECTOR_BOUNDS;
6651	if (Address.off <= SelInfo.cbLimit)
6652	return VERR_OUT_OF_SELECTOR_BOUNDS;
6653	cb = (SelInfo.Raw.Gen.u1Granularity ? UINT32_C(0xffffffff) : UINT32_C(0xffff)) - Address.off;
6654	}
6655	else
6656	{
6657	if (Address.off > SelInfo.cbLimit)
6658	return VERR_OUT_OF_SELECTOR_BOUNDS;
6659	cb = SelInfo.cbLimit - Address.off;
6660	}
6661	if (cbRead - 1 > cb)
6662	{
6663	if (!pcbRead)
6664	return VERR_OUT_OF_SELECTOR_BOUNDS;
6665	cbRead = cb + 1;
6666	}
6667	}
6668
6669	Var.enmType = DBGCVAR_TYPE_GC_FLAT;
6670	Var.u.GCFlat = Address.FlatPtr;
6671	}
6672	break;
6673	}
6674
6675	case DBGCVAR_TYPE_GC_FLAT:
6676	case DBGCVAR_TYPE_GC_PHYS:
6677	case DBGCVAR_TYPE_HC_FLAT:
6678	case DBGCVAR_TYPE_HC_PHYS:
6679	break;
6680
6681	case DBGCVAR_TYPE_HC_FAR: /* not supported yet! */
6682	default:
6683	return VERR_NOT_IMPLEMENTED;
6684	}
6685
6686
6687
6688	/*
6689	* Copy page by page.
6690	*/
6691	size_t cbLeft = cbRead;
6692	for (;;)
6693	{
6694	/*
6695	* Calc read size.
6696	*/
6697	size_t cb = RT_MIN(PAGE_SIZE, cbLeft);
6698	switch (pVarPointer->enmType)
6699	{
6700	case DBGCVAR_TYPE_GC_FLAT: cb = RT_MIN(cb, PAGE_SIZE - (Var.u.GCFlat & PAGE_OFFSET_MASK)); break;
6701	case DBGCVAR_TYPE_GC_PHYS: cb = RT_MIN(cb, PAGE_SIZE - (Var.u.GCPhys & PAGE_OFFSET_MASK)); break;
6702	case DBGCVAR_TYPE_HC_FLAT: cb = RT_MIN(cb, PAGE_SIZE - ((uintptr_t)Var.u.pvHCFlat & PAGE_OFFSET_MASK)); break;
6703	case DBGCVAR_TYPE_HC_PHYS: cb = RT_MIN(cb, PAGE_SIZE - ((size_t)Var.u.HCPhys & PAGE_OFFSET_MASK)); break; /* size_t: MSC has braindead loss of data warnings! */
6704	default: break;
6705	}
6706
6707	/*
6708	* Perform read.
6709	*/
6710	int rc;
6711	switch (Var.enmType)
6712	{
6713	case DBGCVAR_TYPE_GC_FLAT:
6714	rc = MMR3ReadGCVirt(pVM, pvBuffer, Var.u.GCFlat, cb);
6715	break;
6716	case DBGCVAR_TYPE_GC_PHYS:
6717	rc = PGMPhysReadGCPhys(pVM, pvBuffer, Var.u.GCPhys, cb);
6718	break;
6719
6720	case DBGCVAR_TYPE_HC_PHYS:
6721	case DBGCVAR_TYPE_HC_FLAT:
6722	case DBGCVAR_TYPE_HC_FAR:
6723	{
6724	DBGCVAR Var2;
6725	rc = dbgcOpAddrFlat(pDbgc, &Var, &Var2);
6726	if (VBOX_SUCCESS(rc))
6727	{
6728	/** @todo protect this!!! */
6729	memcpy(pvBuffer, Var2.u.pvHCFlat, cb);
6730	rc = 0;
6731	}
6732	else
6733	rc = VERR_INVALID_POINTER;
6734	break;
6735	}
6736
6737	default:
6738	rc = VERR_PARSE_INCORRECT_ARG_TYPE;
6739	}
6740
6741	/*
6742	* Check for failure.
6743	*/
6744	if (VBOX_FAILURE(rc))
6745	{
6746	if (pcbRead && (*pcbRead = cbRead - cbLeft) > 0)
6747	return VINF_SUCCESS;
6748	return rc;
6749	}
6750
6751	/*
6752	* Next.
6753	*/
6754	cbLeft -= cb;
6755	if (!cbLeft)
6756	break;
6757	pvBuffer = (char *)pvBuffer + cb;
6758	rc = pCmdHlp->pfnEval(pCmdHlp, &Var, "%DV + %d", &Var, cb);
6759	if (VBOX_FAILURE(rc))
6760	{
6761	if (pcbRead && (*pcbRead = cbRead - cbLeft) > 0)
6762	return VINF_SUCCESS;
6763	return rc;
6764	}
6765	}
6766
6767	/*
6768	* Done
6769	*/
6770	if (pcbRead)
6771	*pcbRead = cbRead;
6772	return 0;
6773	}
6774
6775	/**
6776	* Command helper for writing memory specified by a DBGC variable.
6777	*
6778	* @returns VBox status code appropriate to return from a command.
6779	* @param pCmdHlp Pointer to the command callback structure.
6780	* @param pVM VM handle if GC or physical HC address.
6781	* @param pvBuffer What to write.
6782	* @param cbWrite Number of bytes to write.
6783	* @param pVarPointer DBGC variable specifying where to start reading.
6784	* @param pcbWritten Where to store the number of bytes written.
6785	* This is optional. If NULL be aware that some of the buffer
6786	* might have been written to the specified address.
6787	*/
6788	static DECLCALLBACK(int) dbgcHlpMemWrite(PDBGCCMDHLP pCmdHlp, PVM pVM, const void pvBuffer, size_t cbWrite, PCDBGCVAR pVarPointer, size_t pcbWritten)
6789	{
6790	NOREF(pCmdHlp); NOREF(pVM); NOREF(pvBuffer); NOREF(cbWrite); NOREF(pVarPointer); NOREF(pcbWritten);
6791	return VERR_NOT_IMPLEMENTED;
6792	}
6793
6794
6795	/**
6796	* Evaluates an expression.
6797	* (Hopefully the parser and functions are fully reentrant.)
6798	*
6799	* @returns VBox status code appropriate to return from a command.
6800	* @param pCmdHlp Pointer to the command callback structure.
6801	* @param pResult Where to store the result.
6802	* @param pszExpr The expression. Format string with the format DBGC extensions.
6803	* @param ... Format arguments.
6804	*/
6805	static DECLCALLBACK(int) dbgcHlpEval(PDBGCCMDHLP pCmdHlp, PDBGCVAR pResult, const char *pszExpr, ...)
6806	{
6807	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
6808
6809	/*
6810	* Format the expression.
6811	*/
6812	char szExprFormatted[2048];
6813	va_list args;
6814	va_start(args, pszExpr);
6815	size_t cb = RTStrPrintfExV(dbgcStringFormatter, pDbgc, szExprFormatted, sizeof(szExprFormatted), pszExpr, args);
6816	va_end(args);
6817	/* ignore overflows. */
6818
6819	return dbgcEvalSub(pDbgc, &szExprFormatted[0], cb, pResult);
6820	}
6821
6822
6823	/**
6824	* Executes one command expression.
6825	* (Hopefully the parser and functions are fully reentrant.)
6826	*
6827	* @returns VBox status code appropriate to return from a command.
6828	* @param pCmdHlp Pointer to the command callback structure.
6829	* @param pszExpr The expression. Format string with the format DBGC extensions.
6830	* @param ... Format arguments.
6831	*/
6832	static DECLCALLBACK(int) dbgcHlpExec(PDBGCCMDHLP pCmdHlp, const char *pszExpr, ...)
6833	{
6834	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
6835	/* Save the scratch state. */
6836	char *pszScratch = pDbgc->pszScratch;
6837	unsigned iArg = pDbgc->iArg;
6838
6839	/*
6840	* Format the expression.
6841	*/
6842	va_list args;
6843	va_start(args, pszExpr);
6844	size_t cbScratch = sizeof(pDbgc->achScratch) - (pDbgc->pszScratch - &pDbgc->achScratch[0]);
6845	size_t cb = RTStrPrintfExV(dbgcStringFormatter, pDbgc, pDbgc->pszScratch, cbScratch, pszExpr, args);
6846	va_end(args);
6847	if (cb >= cbScratch)
6848	return VERR_BUFFER_OVERFLOW;
6849
6850	/*
6851	* Execute the command.
6852	* We save and restore the arg index and scratch buffer pointer.
6853	*/
6854	pDbgc->pszScratch = pDbgc->pszScratch + cb + 1;
6855	int rc = dbgcProcessCommand(pDbgc, pszScratch, cb);
6856
6857	/* Restore the scratch state. */
6858	pDbgc->iArg = iArg;
6859	pDbgc->pszScratch = pszScratch;
6860
6861	return rc;
6862	}
6863
6864
6865	/**
6866	* Converts a DBGC variable to a DBGF address structure.
6867	*
6868	* @returns VBox status code.
6869	* @param pCmdHlp Pointer to the command callback structure.
6870	* @param pVar The variable to convert.
6871	* @param pAddress The target address.
6872	*/
6873	static DECLCALLBACK(int) dbgcHlpVarToDbgfAddr(PDBGCCMDHLP pCmdHlp, PCDBGCVAR pVar, PDBGFADDRESS pAddress)
6874	{
6875	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
6876	return dbgcVarToDbgfAddr(pDbgc, pVar, pAddress);
6877	}
6878
6879
6880	/**
6881	* Converts a DBGC variable to a boolean.
6882	*
6883	* @returns VBox status code.
6884	* @param pCmdHlp Pointer to the command callback structure.
6885	* @param pVar The variable to convert.
6886	* @param pf Where to store the boolean.
6887	*/
6888	static DECLCALLBACK(int) dbgcHlpVarToBool(PDBGCCMDHLP pCmdHlp, PCDBGCVAR pVar, bool *pf)
6889	{
6890	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
6891	NOREF(pDbgc);
6892
6893	switch (pVar->enmType)
6894	{
6895	case DBGCVAR_TYPE_STRING:
6896	/** @todo add strcasecmp / stricmp wrappers to iprt/string.h. */
6897	if ( !strcmp(pVar->u.pszString, "true")
6898	\|\| !strcmp(pVar->u.pszString, "True")
6899	\|\| !strcmp(pVar->u.pszString, "TRUE")
6900	\|\| !strcmp(pVar->u.pszString, "on")
6901	\|\| !strcmp(pVar->u.pszString, "On")
6902	\|\| !strcmp(pVar->u.pszString, "oN")
6903	\|\| !strcmp(pVar->u.pszString, "ON")
6904	\|\| !strcmp(pVar->u.pszString, "enabled")
6905	\|\| !strcmp(pVar->u.pszString, "Enabled")
6906	\|\| !strcmp(pVar->u.pszString, "DISABLED"))
6907	{
6908	*pf = true;
6909	return VINF_SUCCESS;
6910	}
6911	if ( !strcmp(pVar->u.pszString, "false")
6912	\|\| !strcmp(pVar->u.pszString, "False")
6913	\|\| !strcmp(pVar->u.pszString, "FALSE")
6914	\|\| !strcmp(pVar->u.pszString, "off")
6915	\|\| !strcmp(pVar->u.pszString, "Off")
6916	\|\| !strcmp(pVar->u.pszString, "OFF")
6917	\|\| !strcmp(pVar->u.pszString, "disabled")
6918	\|\| !strcmp(pVar->u.pszString, "Disabled")
6919	\|\| !strcmp(pVar->u.pszString, "DISABLED"))
6920	{
6921	*pf = false;
6922	return VINF_SUCCESS;
6923	}
6924	return VERR_PARSE_INCORRECT_ARG_TYPE; /** @todo better error code! */
6925
6926	case DBGCVAR_TYPE_GC_FLAT:
6927	case DBGCVAR_TYPE_GC_PHYS:
6928	case DBGCVAR_TYPE_HC_FLAT:
6929	case DBGCVAR_TYPE_HC_PHYS:
6930	case DBGCVAR_TYPE_NUMBER:
6931	*pf = pVar->u.u64Number != 0;
6932	return VINF_SUCCESS;
6933
6934	case DBGCVAR_TYPE_HC_FAR:
6935	case DBGCVAR_TYPE_GC_FAR:
6936	case DBGCVAR_TYPE_SYMBOL:
6937	default:
6938	return VERR_PARSE_INCORRECT_ARG_TYPE;
6939	}
6940	}
6941
6942
6943
6944
6945
6946	//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
6947	//
6948	//
6949	// V a r i a b l e M a n i p u l a t i o n
6950	//
6951	//
6952	//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
6953
6954
6955
6956	/** @todo move me!*/
6957	static void dbgcVarSetGCFlat(PDBGCVAR pVar, RTGCPTR GCFlat)
6958	{
6959	if (pVar)
6960	{
6961	pVar->enmType = DBGCVAR_TYPE_GC_FLAT;
6962	pVar->u.GCFlat = GCFlat;
6963	pVar->enmRangeType = DBGCVAR_RANGE_NONE;
6964	pVar->u64Range = 0;
6965	}
6966	}
6967
6968
6969	/** @todo move me!*/
6970	static void dbgcVarSetGCFlatByteRange(PDBGCVAR pVar, RTGCPTR GCFlat, uint64_t cb)
6971	{
6972	if (pVar)
6973	{
6974	pVar->enmType = DBGCVAR_TYPE_GC_FLAT;
6975	pVar->u.GCFlat = GCFlat;
6976	pVar->enmRangeType = DBGCVAR_RANGE_BYTES;
6977	pVar->u64Range = cb;
6978	}
6979	}
6980
6981
6982	/** @todo move me!*/
6983	static void dbgcVarSetVar(PDBGCVAR pVar, PCDBGCVAR pVar2)
6984	{
6985	if (pVar)
6986	{
6987	if (pVar2)
6988	pVar = pVar2;
6989	else
6990	{
6991	pVar->enmType = DBGCVAR_TYPE_UNKNOWN;
6992	memset(&pVar->u, 0, sizeof(pVar->u));
6993	pVar->enmRangeType = DBGCVAR_RANGE_NONE;
6994	pVar->u64Range = 0;
6995	}
6996	}
6997	}
6998
6999
7000	/** @todo move me!*/
7001	static void dbgcVarSetByteRange(PDBGCVAR pVar, uint64_t cb)
7002	{
7003	if (pVar)
7004	{
7005	pVar->enmRangeType = DBGCVAR_RANGE_BYTES;
7006	pVar->u64Range = cb;
7007	}
7008	}
7009
7010
7011	/** @todo move me!*/
7012	static void dbgcVarSetNoRange(PDBGCVAR pVar)
7013	{
7014	if (pVar)
7015	{
7016	pVar->enmRangeType = DBGCVAR_RANGE_NONE;
7017	pVar->u64Range = 0;
7018	}
7019	}
7020
7021
7022	/**
7023	* Converts a DBGC variable to a DBGF address.
7024	*
7025	* @returns VBox status code.
7026	* @param pDbgc The DBGC instance.
7027	* @param pVar The variable.
7028	* @param pAddress Where to store the address.
7029	*/
7030	static int dbgcVarToDbgfAddr(PDBGC pDbgc, PCDBGCVAR pVar, PDBGFADDRESS pAddress)
7031	{
7032	AssertReturn(pVar, VERR_INVALID_PARAMETER);
7033	switch (pVar->enmType)
7034	{
7035	case DBGCVAR_TYPE_GC_FLAT:
7036	DBGFR3AddrFromFlat(pDbgc->pVM, pAddress, pVar->u.GCFlat);
7037	return VINF_SUCCESS;
7038
7039	case DBGCVAR_TYPE_NUMBER:
7040	DBGFR3AddrFromFlat(pDbgc->pVM, pAddress, (RTGCUINTPTR)pVar->u.u64Number);
7041	return VINF_SUCCESS;
7042
7043	case DBGCVAR_TYPE_GC_FAR:
7044	return DBGFR3AddrFromSelOff(pDbgc->pVM, pAddress, pVar->u.GCFar.sel, pVar->u.GCFar.sel);
7045
7046	case DBGCVAR_TYPE_STRING:
7047	case DBGCVAR_TYPE_SYMBOL:
7048	{
7049	DBGCVAR Var;
7050	int rc = pDbgc->CmdHlp.pfnEval(&pDbgc->CmdHlp, &Var, "%%(%DV)", pVar);
7051	if (VBOX_FAILURE(rc))
7052	return rc;
7053	return dbgcVarToDbgfAddr(pDbgc, &Var, pAddress);
7054	}
7055
7056	case DBGCVAR_TYPE_GC_PHYS:
7057	case DBGCVAR_TYPE_HC_FLAT:
7058	case DBGCVAR_TYPE_HC_FAR:
7059	case DBGCVAR_TYPE_HC_PHYS:
7060	default:
7061	return VERR_PARSE_CONVERSION_FAILED;
7062	}
7063	}
7064
7065
7066
7067	//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
7068	//
7069	//
7070	// B r e a k p o i n t M a n a g e m e n t
7071	//
7072	//
7073	//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
7074
7075
7076	/**
7077	* Adds a breakpoint to the DBGC breakpoint list.
7078	*/
7079	static int dbgcBpAdd(PDBGC pDbgc, RTUINT iBp, const char *pszCmd)
7080	{
7081	/*
7082	* Check if it already exists.
7083	*/
7084	PDBGCBP pBp = dbgcBpGet(pDbgc, iBp);
7085	if (pBp)
7086	return VERR_DBGC_BP_EXISTS;
7087
7088	/*
7089	* Add the breakpoint.
7090	*/
7091	if (pszCmd)
7092	pszCmd = RTStrStripL(pszCmd);
7093	size_t cchCmd = pszCmd ? strlen(pszCmd) : 0;
7094	pBp = (PDBGCBP)RTMemAlloc(RT_OFFSETOF(DBGCBP, szCmd[cchCmd + 1]));
7095	if (!pBp)
7096	return VERR_NO_MEMORY;
7097	if (cchCmd)
7098	memcpy(pBp->szCmd, pszCmd, cchCmd + 1);
7099	else
7100	pBp->szCmd[0] = '\0';
7101	pBp->cchCmd = cchCmd;
7102	pBp->iBp = iBp;
7103	pBp->pNext = pDbgc->pFirstBp;
7104	pDbgc->pFirstBp = pBp;
7105
7106	return VINF_SUCCESS;
7107	}
7108
7109	/**
7110	* Updates the a breakpoint.
7111	*
7112	* @returns VBox status code.
7113	* @param pDbgc The DBGC instance.
7114	* @param iBp The breakpoint to update.
7115	* @param pszCmd The new command.
7116	*/
7117	static int dbgcBpUpdate(PDBGC pDbgc, RTUINT iBp, const char *pszCmd)
7118	{
7119	/*
7120	* Find the breakpoint.
7121	*/
7122	PDBGCBP pBp = dbgcBpGet(pDbgc, iBp);
7123	if (!pBp)
7124	return VERR_DBGC_BP_NOT_FOUND;
7125
7126	/*
7127	* Do we need to reallocate?
7128	*/
7129	if (pszCmd)
7130	pszCmd = RTStrStripL(pszCmd);
7131	if (!pszCmd \|\| !*pszCmd)
7132	pBp->szCmd[0] = '\0';
7133	else
7134	{
7135	size_t cchCmd = strlen(pszCmd);
7136	if (strlen(pBp->szCmd) >= cchCmd)
7137	{
7138	memcpy(pBp->szCmd, pszCmd, cchCmd + 1);
7139	pBp->cchCmd = cchCmd;
7140	}
7141	else
7142	{
7143	/*
7144	* Yes, let's do it the simple way...
7145	*/
7146	int rc = dbgcBpDelete(pDbgc, iBp);
7147	AssertRC(rc);
7148	return dbgcBpAdd(pDbgc, iBp, pszCmd);
7149	}
7150	}
7151	return VINF_SUCCESS;
7152	}
7153
7154
7155	/**
7156	* Deletes a breakpoint.
7157	*
7158	* @returns VBox status code.
7159	* @param pDbgc The DBGC instance.
7160	* @param iBp The breakpoint to delete.
7161	*/
7162	static int dbgcBpDelete(PDBGC pDbgc, RTUINT iBp)
7163	{
7164	/*
7165	* Search thru the list, when found unlink and free it.
7166	*/
7167	PDBGCBP pBpPrev = NULL;
7168	PDBGCBP pBp = pDbgc->pFirstBp;
7169	for (; pBp; pBp = pBp->pNext)
7170	{
7171	if (pBp->iBp == iBp)
7172	{
7173	if (pBpPrev)
7174	pBpPrev->pNext = pBp->pNext;
7175	else
7176	pDbgc->pFirstBp = pBp->pNext;
7177	RTMemFree(pBp);
7178	return VINF_SUCCESS;
7179	}
7180	pBpPrev = pBp;
7181	}
7182
7183	return VERR_DBGC_BP_NOT_FOUND;
7184	}
7185
7186
7187	/**
7188	* Get a breakpoint.
7189	*
7190	* @returns Pointer to the breakpoint.
7191	* @returns NULL if the breakpoint wasn't found.
7192	* @param pDbgc The DBGC instance.
7193	* @param iBp The breakpoint to get.
7194	*/
7195	static PDBGCBP dbgcBpGet(PDBGC pDbgc, RTUINT iBp)
7196	{
7197	/*
7198	* Enumerate the list.
7199	*/
7200	PDBGCBP pBp = pDbgc->pFirstBp;
7201	for (; pBp; pBp = pBp->pNext)
7202	if (pBp->iBp == iBp)
7203	return pBp;
7204	return NULL;
7205	}
7206
7207
7208	/**
7209	* Executes the command of a breakpoint.
7210	*
7211	* @returns VINF_DBGC_BP_NO_COMMAND if there is no command associated with the breakpoint.
7212	* @returns VERR_DBGC_BP_NOT_FOUND if the breakpoint wasn't found.
7213	* @returns VERR_BUFFER_OVERFLOW if the is not enough space in the scratch buffer for the command.
7214	* @returns VBox status code from dbgcProcessCommand() other wise.
7215	* @param pDbgc The DBGC instance.
7216	* @param iBp The breakpoint to execute.
7217	*/
7218	static int dbgcBpExec(PDBGC pDbgc, RTUINT iBp)
7219	{
7220	/*
7221	* Find the breakpoint.
7222	*/
7223	PDBGCBP pBp = dbgcBpGet(pDbgc, iBp);
7224	if (!pBp)
7225	return VERR_DBGC_BP_NOT_FOUND;
7226
7227	/*
7228	* Anything to do?
7229	*/
7230	if (!pBp->cchCmd)
7231	return VINF_DBGC_BP_NO_COMMAND;
7232
7233	/*
7234	* Execute the command.
7235	* This means copying it to the scratch buffer and process it as if it
7236	* were user input. We must save and restore the state of the scratch buffer.
7237	*/
7238	/* Save the scratch state. */
7239	char *pszScratch = pDbgc->pszScratch;
7240	unsigned iArg = pDbgc->iArg;
7241
7242	/* Copy the command to the scratch buffer. */
7243	size_t cbScratch = sizeof(pDbgc->achScratch) - (pDbgc->pszScratch - &pDbgc->achScratch[0]);
7244	if (pBp->cchCmd >= cbScratch)
7245	return VERR_BUFFER_OVERFLOW;
7246	memcpy(pDbgc->pszScratch, pBp->szCmd, pBp->cchCmd + 1);
7247
7248	/* Execute the command. */
7249	pDbgc->pszScratch = pDbgc->pszScratch + pBp->cchCmd + 1;
7250	int rc = dbgcProcessCommand(pDbgc, pszScratch, pBp->cchCmd);
7251
7252	/* Restore the scratch state. */
7253	pDbgc->iArg = iArg;
7254	pDbgc->pszScratch = pszScratch;
7255
7256	return rc;
7257	}
7258
7259
7260
7261
7262
7263	//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
7264	//
7265	//
7266	// I n p u t , p a r s i n g a n d l o g g i n g
7267	//
7268	//
7269	//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
7270
7271
7272
7273	/**
7274	* Prints any log lines from the log buffer.
7275	*
7276	* The caller must not call function this unless pDbgc->fLog is set.
7277	*
7278	* @returns VBox status. (output related)
7279	* @param pDbgc Debugger console instance data.
7280	*/
7281	static int dbgcProcessLog(PDBGC pDbgc)
7282	{
7283	/** @todo */
7284	NOREF(pDbgc);
7285	return 0;
7286	}
7287
7288
7289
7290	/**
7291	* Handle input buffer overflow.
7292	*
7293	* Will read any available input looking for a '\n' to reset the buffer on.
7294	*
7295	* @returns VBox status.
7296	* @param pDbgc Debugger console instance data.
7297	*/
7298	static int dbgcInputOverflow(PDBGC pDbgc)
7299	{
7300	/*
7301	* Assert overflow status and reset the input buffer.
7302	*/
7303	if (!pDbgc->fInputOverflow)
7304	{
7305	pDbgc->fInputOverflow = true;
7306	pDbgc->iRead = pDbgc->iWrite = 0;
7307	pDbgc->cInputLines = 0;
7308	pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "Input overflow!!\n");
7309	}
7310
7311	/*
7312	* Eat input till no more or there is a '\n'.
7313	* When finding a '\n' we'll continue normal processing.
7314	*/
7315	while (pDbgc->pBack->pfnInput(pDbgc->pBack, 0))
7316	{
7317	size_t cbRead;
7318	int rc = pDbgc->pBack->pfnRead(pDbgc->pBack, &pDbgc->achInput[0], sizeof(pDbgc->achInput) - 1, &cbRead);
7319	if (VBOX_FAILURE(rc))
7320	return rc;
7321	char psz = (char )memchr(&pDbgc->achInput[0], '\n', cbRead);
7322	if (psz)
7323	{
7324	pDbgc->fInputOverflow = false;
7325	pDbgc->iRead = psz - &pDbgc->achInput[0] + 1;
7326	pDbgc->iWrite = cbRead;
7327	pDbgc->cInputLines = 0;
7328	break;
7329	}
7330	}
7331
7332	return 0;
7333	}
7334
7335
7336
7337	/**
7338	* Read input and do some preprocessing.
7339	*
7340	* @returns VBox status.
7341	* In addition to the iWrite and achInput, cInputLines is maintained.
7342	* In case of an input overflow the fInputOverflow flag will be set.
7343	* @param pDbgc Debugger console instance data.
7344	*/
7345	static int dbgcInputRead(PDBGC pDbgc)
7346	{
7347	/*
7348	* We have ready input.
7349	* Read it till we don't have any or we have a full input buffer.
7350	*/
7351	int rc = 0;
7352	do
7353	{
7354	/*
7355	* More available buffer space?
7356	*/
7357	size_t cbLeft;
7358	if (pDbgc->iWrite > pDbgc->iRead)
7359	cbLeft = sizeof(pDbgc->achInput) - pDbgc->iWrite - (pDbgc->iRead == 0);
7360	else
7361	cbLeft = pDbgc->iRead - pDbgc->iWrite - 1;
7362	if (!cbLeft)
7363	{
7364	/* overflow? */
7365	if (!pDbgc->cInputLines)
7366	rc = dbgcInputOverflow(pDbgc);
7367	break;
7368	}
7369
7370	/*
7371	* Read one char and interpret it.
7372	*/
7373	char achRead[128];
7374	size_t cbRead;
7375	rc = pDbgc->pBack->pfnRead(pDbgc->pBack, &achRead[0], RT_MIN(cbLeft, sizeof(achRead)), &cbRead);
7376	if (VBOX_FAILURE(rc))
7377	return rc;
7378	char *psz = &achRead[0];
7379	while (cbRead-- > 0)
7380	{
7381	char ch = *psz++;
7382	switch (ch)
7383	{
7384	/*
7385	* Ignore.
7386	*/
7387	case '\0':
7388	case '\r':
7389	case '\a':
7390	break;
7391
7392	/*
7393	* Backspace.
7394	*/
7395	case '\b':
7396	Log2(("DBGC: backspace\n"));
7397	if (pDbgc->iRead != pDbgc->iWrite)
7398	{
7399	unsigned iWriteUndo = pDbgc->iWrite;
7400	if (pDbgc->iWrite)
7401	pDbgc->iWrite--;
7402	else
7403	pDbgc->iWrite = sizeof(pDbgc->achInput) - 1;
7404
7405	if (pDbgc->achInput[pDbgc->iWrite] == '\n')
7406	pDbgc->iWrite = iWriteUndo;
7407	}
7408	break;
7409
7410	/*
7411	* Add char to buffer.
7412	*/
7413	case '\t':
7414	case '\n':
7415	case ';':
7416	switch (ch)
7417	{
7418	case '\t': ch = ' '; break;
7419	case '\n': pDbgc->cInputLines++; break;
7420	}
7421	default:
7422	Log2(("DBGC: ch=%02x\n", (unsigned char)ch));
7423	pDbgc->achInput[pDbgc->iWrite] = ch;
7424	if (++pDbgc->iWrite >= sizeof(pDbgc->achInput))
7425	pDbgc->iWrite = 0;
7426	break;
7427	}
7428	}
7429
7430	/* Terminate it to make it easier to read in the debugger. */
7431	pDbgc->achInput[pDbgc->iWrite] = '\0';
7432	} while (pDbgc->pBack->pfnInput(pDbgc->pBack, 0));
7433
7434	return rc;
7435	}
7436
7437
7438	/**
7439	* Finds a builtin symbol.
7440	* @returns Pointer to symbol descriptor on success.
7441	* @returns NULL on failure.
7442	* @param pDbgc The debug console instance.
7443	* @param pszSymbol The symbol name.
7444	*/
7445	static PCDBGCSYM dbgcLookupRegisterSymbol(PDBGC pDbgc, const char *pszSymbol)
7446	{
7447	for (unsigned iSym = 0; iSym < ELEMENTS(g_aSyms); iSym++)
7448	if (!strcmp(pszSymbol, g_aSyms[iSym].pszName))
7449	return &g_aSyms[iSym];
7450
7451	/** @todo externally registered symbols. */
7452	NOREF(pDbgc);
7453	return NULL;
7454	}
7455
7456
7457	/**
7458	* Resolves a symbol (or tries to do so at least).
7459	*
7460	* @returns 0 on success.
7461	* @returns VBox status on failure.
7462	* @param pDbgc The debug console instance.
7463	* @param pszSymbol The symbol name.
7464	* @param enmType The result type.
7465	* @param pResult Where to store the result.
7466	*/
7467	static int dbgcSymbolGet(PDBGC pDbgc, const char *pszSymbol, DBGCVARTYPE enmType, PDBGCVAR pResult)
7468	{
7469	/*
7470	* Builtin?
7471	*/
7472	PCDBGCSYM pSymDesc = dbgcLookupRegisterSymbol(pDbgc, pszSymbol);
7473	if (pSymDesc)
7474	{
7475	if (!pSymDesc->pfnGet)
7476	return VERR_PARSE_WRITEONLY_SYMBOL;
7477	return pSymDesc->pfnGet(pSymDesc, &pDbgc->CmdHlp, enmType, pResult);
7478	}
7479
7480
7481	/*
7482	* Ask PDM.
7483	*/
7484	/** @todo resolve symbols using PDM. */
7485
7486
7487	/*
7488	* Ask the debug info manager.
7489	*/
7490	DBGFSYMBOL Symbol;
7491	int rc = DBGFR3SymbolByName(pDbgc->pVM, pszSymbol, &Symbol);
7492	if (VBOX_SUCCESS(rc))
7493	{
7494	/*
7495	* Default return is a flat gc address.
7496	*/
7497	memset(pResult, 0, sizeof(*pResult));
7498	pResult->enmRangeType = Symbol.cb ? DBGCVAR_RANGE_BYTES : DBGCVAR_RANGE_NONE;
7499	pResult->u64Range = Symbol.cb;
7500	pResult->enmType = DBGCVAR_TYPE_GC_FLAT;
7501	pResult->u.GCFlat = Symbol.Value;
7502	DBGCVAR VarTmp;
7503	switch (enmType)
7504	{
7505	/* nothing to do. */
7506	case DBGCVAR_TYPE_GC_FLAT:
7507	case DBGCVAR_TYPE_GC_FAR:
7508	case DBGCVAR_TYPE_ANY:
7509	return VINF_SUCCESS;
7510
7511	/* simply make it numeric. */
7512	case DBGCVAR_TYPE_NUMBER:
7513	pResult->enmType = DBGCVAR_TYPE_NUMBER;
7514	pResult->u.u64Number = Symbol.Value;
7515	return VINF_SUCCESS;
7516
7517	/* cast it. */
7518
7519	case DBGCVAR_TYPE_GC_PHYS:
7520	VarTmp = *pResult;
7521	return dbgcOpAddrPhys(pDbgc, &VarTmp, pResult);
7522
7523	case DBGCVAR_TYPE_HC_FAR:
7524	case DBGCVAR_TYPE_HC_FLAT:
7525	VarTmp = *pResult;
7526	return dbgcOpAddrHost(pDbgc, &VarTmp, pResult);
7527
7528	case DBGCVAR_TYPE_HC_PHYS:
7529	VarTmp = *pResult;
7530	return dbgcOpAddrHostPhys(pDbgc, &VarTmp, pResult);
7531
7532	default:
7533	AssertMsgFailed(("Internal error enmType=%d\n", enmType));
7534	return VERR_INVALID_PARAMETER;
7535	}
7536	}
7537
7538	return VERR_PARSE_NOT_IMPLEMENTED;
7539	}
7540
7541
7542
7543	/**
7544	* Finds a routine.
7545	*
7546	* @returns Pointer to the command descriptor.
7547	* If the request was for an external command, the caller is responsible for
7548	* unlocking the external command list.
7549	* @returns NULL if not found.
7550	* @param pDbgc The debug console instance.
7551	* @param pachName Pointer to the routine string (not terminated).
7552	* @param cchName Length of the routine name.
7553	* @param fExternal Whether or not the routine is external.
7554	*/
7555	static PCDBGCCMD dbgcRoutineLookup(PDBGC pDbgc, const char *pachName, size_t cchName, bool fExternal)
7556	{
7557	if (!fExternal)
7558	{
7559	for (unsigned iCmd = 0; iCmd < ELEMENTS(g_aCmds); iCmd++)
7560	{
7561	if ( !strncmp(pachName, g_aCmds[iCmd].pszCmd, cchName)
7562	&& !g_aCmds[iCmd].pszCmd[cchName])
7563	return &g_aCmds[iCmd];
7564	}
7565	}
7566	else
7567	{
7568	DBGCEXTCMDS_LOCK_RD();
7569	for (PDBGCEXTCMDS pExtCmds = g_pExtCmdsHead; pExtCmds; pExtCmds = pExtCmds->pNext)
7570	{
7571	for (unsigned iCmd = 0; iCmd < pExtCmds->cCmds; iCmd++)
7572	{
7573	if ( !strncmp(pachName, pExtCmds->paCmds[iCmd].pszCmd, cchName)
7574	&& !pExtCmds->paCmds[iCmd].pszCmd[cchName])
7575	return &pExtCmds->paCmds[iCmd];
7576	}
7577	}
7578	DBGCEXTCMDS_UNLOCK_RD();
7579	}
7580
7581	NOREF(pDbgc);
7582	return NULL;
7583	}
7584
7585
7586	/**
7587	* Searches for an operator descriptor which matches the start of
7588	* the expression given us.
7589	*
7590	* @returns Pointer to the operator on success.
7591	* @param pDbgc The debug console instance.
7592	* @param pszExpr Pointer to the expression string which might start with an operator.
7593	* @param fPreferBinary Whether to favour binary or unary operators.
7594	* Caller must assert that it's the disired type! Both types will still
7595	* be returned, this is only for resolving duplicates.
7596	* @param chPrev The previous char. Some operators requires a blank in front of it.
7597	*/
7598	static PCDBGCOP dbgcOperatorLookup(PDBGC pDbgc, const char *pszExpr, bool fPreferBinary, char chPrev)
7599	{
7600	PCDBGCOP pOp = NULL;
7601	for (unsigned iOp = 0; iOp < ELEMENTS(g_aOps); iOp++)
7602	{
7603	if ( g_aOps[iOp].szName[0] == pszExpr[0]
7604	&& (!g_aOps[iOp].szName[1] \|\| g_aOps[iOp].szName[1] == pszExpr[1])
7605	&& (!g_aOps[iOp].szName[2] \|\| g_aOps[iOp].szName[2] == pszExpr[2]))
7606	{
7607	/*
7608	* Check that we don't mistake it for some other operator which have more chars.
7609	*/
7610	unsigned j;
7611	for (j = iOp + 1; j < ELEMENTS(g_aOps); j++)
7612	if ( g_aOps[j].cchName > g_aOps[iOp].cchName
7613	&& g_aOps[j].szName[0] == pszExpr[0]
7614	&& (!g_aOps[j].szName[1] \|\| g_aOps[j].szName[1] == pszExpr[1])
7615	&& (!g_aOps[j].szName[2] \|\| g_aOps[j].szName[2] == pszExpr[2]) )
7616	break;
7617	if (j < ELEMENTS(g_aOps))
7618	continue; /* we'll catch it later. (for theoretical +,++,+++ cases.) */
7619	pOp = &g_aOps[iOp];
7620
7621	/*
7622	* Prefered type?
7623	*/
7624	if (g_aOps[iOp].fBinary == fPreferBinary)
7625	break;
7626	}
7627	}
7628
7629	if (pOp)
7630	Log2(("dbgcOperatorLookup: pOp=%p %s\n", pOp, pOp->szName));
7631	NOREF(pDbgc); NOREF(chPrev);
7632	return pOp;
7633	}
7634
7635
7636	/**
7637	* Initalizes g_bmOperatorChars.
7638	*/
7639	static void dbgcInitOpCharBitMap(void)
7640	{
7641	memset(g_bmOperatorChars, 0, sizeof(g_bmOperatorChars));
7642	for (unsigned iOp = 0; iOp < RT_ELEMENTS(g_aOps); iOp++)
7643	ASMBitSet(&g_bmOperatorChars[0], (uint8_t)g_aOps[iOp].szName[0]);
7644	}
7645
7646
7647	/**
7648	* Checks whether the character may be the start of an operator.
7649	*
7650	* @returns true/false.
7651	* @param ch The character.
7652	*/
7653	DECLINLINE(bool) dbgcIsOpChar(char ch)
7654	{
7655	return ASMBitTest(&g_bmOperatorChars[0], (uint8_t)ch);
7656	}
7657
7658
7659	static int dbgcEvalSubString(PDBGC pDbgc, char *pszExpr, size_t cchExpr, PDBGCVAR pArg)
7660	{
7661	Log2(("dbgcEvalSubString: cchExpr=%d pszExpr=%s\n", cchExpr, pszExpr));
7662
7663	/*
7664	* Removing any quoting and escapings.
7665	*/
7666	char ch = *pszExpr;
7667	if (ch == '"' \|\| ch == '\'' \|\| ch == '`')
7668	{
7669	if (pszExpr[--cchExpr] != ch)
7670	return VERR_PARSE_UNBALANCED_QUOTE;
7671	cchExpr--;
7672	pszExpr++;
7673
7674	/** @todo string unescaping. */
7675	}
7676	pszExpr[cchExpr] = '\0';
7677
7678	/*
7679	* Make the argument.
7680	*/
7681	pArg->pDesc = NULL;
7682	pArg->pNext = NULL;
7683	pArg->enmType = DBGCVAR_TYPE_STRING;
7684	pArg->u.pszString = pszExpr;
7685	pArg->enmRangeType = DBGCVAR_RANGE_BYTES;
7686	pArg->u64Range = cchExpr;
7687
7688	NOREF(pDbgc);
7689	return 0;
7690	}
7691
7692
7693	static int dbgcEvalSubNum(char *pszExpr, unsigned uBase, PDBGCVAR pArg)
7694	{
7695	Log2(("dbgcEvalSubNum: uBase=%d pszExpr=%s\n", uBase, pszExpr));
7696	/*
7697	* Convert to number.
7698	*/
7699	uint64_t u64 = 0;
7700	char ch;
7701	while ((ch = *pszExpr) != '\0')
7702	{
7703	uint64_t u64Prev = u64;
7704	unsigned u = ch - '0';
7705	if (u < 10 && u < uBase)
7706	u64 = u64 * uBase + u;
7707	else if (ch >= 'a' && (u = ch - ('a' - 10)) < uBase)
7708	u64 = u64 * uBase + u;
7709	else if (ch >= 'A' && (u = ch - ('A' - 10)) < uBase)
7710	u64 = u64 * uBase + u;
7711	else
7712	return VERR_PARSE_INVALID_NUMBER;
7713
7714	/* check for overflow - ARG!!! How to detect overflow correctly!?!?!? */
7715	if (u64Prev != u64 / uBase)
7716	return VERR_PARSE_NUMBER_TOO_BIG;
7717
7718	/* next */
7719	pszExpr++;
7720	}
7721
7722	/*
7723	* Initialize the argument.
7724	*/
7725	pArg->pDesc = NULL;
7726	pArg->pNext = NULL;
7727	pArg->enmType = DBGCVAR_TYPE_NUMBER;
7728	pArg->u.u64Number = u64;
7729	pArg->enmRangeType = DBGCVAR_RANGE_NONE;
7730	pArg->u64Range = 0;
7731
7732	return 0;
7733	}
7734
7735
7736	/**
7737	* Match variable and variable descriptor, promoting the variable if necessary.
7738	*
7739	* @returns VBox status code.
7740	* @param pDbgc Debug console instanace.
7741	* @param pVar Variable.
7742	* @param pVarDesc Variable descriptor.
7743	*/
7744	static int dbgcEvalSubMatchVar(PDBGC pDbgc, PDBGCVAR pVar, PCDBGCVARDESC pVarDesc)
7745	{
7746	/*
7747	* (If match or promoted to match, return, else break.)
7748	*/
7749	switch (pVarDesc->enmCategory)
7750	{
7751	/*
7752	* Anything goes
7753	*/
7754	case DBGCVAR_CAT_ANY:
7755	return VINF_SUCCESS;
7756
7757	/*
7758	* Pointer with and without range.
7759	* We can try resolve strings and symbols as symbols and
7760	* promote numbers to flat GC pointers.
7761	*/
7762	case DBGCVAR_CAT_POINTER_NO_RANGE:
7763	if (pVar->enmRangeType != DBGCVAR_RANGE_NONE)
7764	return VERR_PARSE_NO_RANGE_ALLOWED;
7765	/* fallthru */
7766	case DBGCVAR_CAT_POINTER:
7767	switch (pVar->enmType)
7768	{
7769	case DBGCVAR_TYPE_GC_FLAT:
7770	case DBGCVAR_TYPE_GC_FAR:
7771	case DBGCVAR_TYPE_GC_PHYS:
7772	case DBGCVAR_TYPE_HC_FLAT:
7773	case DBGCVAR_TYPE_HC_FAR:
7774	case DBGCVAR_TYPE_HC_PHYS:
7775	return VINF_SUCCESS;
7776
7777	case DBGCVAR_TYPE_SYMBOL:
7778	case DBGCVAR_TYPE_STRING:
7779	{
7780	DBGCVAR Var;
7781	int rc = dbgcSymbolGet(pDbgc, pVar->u.pszString, DBGCVAR_TYPE_GC_FLAT, &Var);
7782	if (VBOX_SUCCESS(rc))
7783	{
7784	/* deal with range */
7785	if (pVar->enmRangeType != DBGCVAR_RANGE_NONE)
7786	{
7787	Var.enmRangeType = pVar->enmRangeType;
7788	Var.u64Range = pVar->u64Range;
7789	}
7790	else if (pVarDesc->enmCategory == DBGCVAR_CAT_POINTER_NO_RANGE)
7791	Var.enmRangeType = DBGCVAR_RANGE_NONE;
7792	*pVar = Var;
7793	return rc;
7794	}
7795	break;
7796	}
7797
7798	case DBGCVAR_TYPE_NUMBER:
7799	{
7800	RTGCPTR GCPtr = (RTGCPTR)pVar->u.u64Number;
7801	pVar->enmType = DBGCVAR_TYPE_GC_FLAT;
7802	pVar->u.GCFlat = GCPtr;
7803	return VINF_SUCCESS;
7804	}
7805
7806	default:
7807	break;
7808	}
7809	break;
7810
7811	/*
7812	* GC pointer with and without range.
7813	* We can try resolve strings and symbols as symbols and
7814	* promote numbers to flat GC pointers.
7815	*/
7816	case DBGCVAR_CAT_GC_POINTER_NO_RANGE:
7817	if (pVar->enmRangeType != DBGCVAR_RANGE_NONE)
7818	return VERR_PARSE_NO_RANGE_ALLOWED;
7819	/* fallthru */
7820	case DBGCVAR_CAT_GC_POINTER:
7821	switch (pVar->enmType)
7822	{
7823	case DBGCVAR_TYPE_GC_FLAT:
7824	case DBGCVAR_TYPE_GC_FAR:
7825	case DBGCVAR_TYPE_GC_PHYS:
7826	return VINF_SUCCESS;
7827
7828	case DBGCVAR_TYPE_HC_FLAT:
7829	case DBGCVAR_TYPE_HC_FAR:
7830	case DBGCVAR_TYPE_HC_PHYS:
7831	return VERR_PARSE_CONVERSION_FAILED;
7832
7833	case DBGCVAR_TYPE_SYMBOL:
7834	case DBGCVAR_TYPE_STRING:
7835	{
7836	DBGCVAR Var;
7837	int rc = dbgcSymbolGet(pDbgc, pVar->u.pszString, DBGCVAR_TYPE_GC_FLAT, &Var);
7838	if (VBOX_SUCCESS(rc))
7839	{
7840	/* deal with range */
7841	if (pVar->enmRangeType != DBGCVAR_RANGE_NONE)
7842	{
7843	Var.enmRangeType = pVar->enmRangeType;
7844	Var.u64Range = pVar->u64Range;
7845	}
7846	else if (pVarDesc->enmCategory == DBGCVAR_CAT_POINTER_NO_RANGE)
7847	Var.enmRangeType = DBGCVAR_RANGE_NONE;
7848	*pVar = Var;
7849	return rc;
7850	}
7851	break;
7852	}
7853
7854	case DBGCVAR_TYPE_NUMBER:
7855	{
7856	RTGCPTR GCPtr = (RTGCPTR)pVar->u.u64Number;
7857	pVar->enmType = DBGCVAR_TYPE_GC_FLAT;
7858	pVar->u.GCFlat = GCPtr;
7859	return VINF_SUCCESS;
7860	}
7861
7862	default:
7863	break;
7864	}
7865	break;
7866
7867	/*
7868	* Number with or without a range.
7869	* Numbers can be resolved from symbols, but we cannot demote a pointer
7870	* to a number.
7871	*/
7872	case DBGCVAR_CAT_NUMBER_NO_RANGE:
7873	if (pVar->enmRangeType != DBGCVAR_RANGE_NONE)
7874	return VERR_PARSE_NO_RANGE_ALLOWED;
7875	/* fallthru */
7876	case DBGCVAR_CAT_NUMBER:
7877	switch (pVar->enmType)
7878	{
7879	case DBGCVAR_TYPE_NUMBER:
7880	return VINF_SUCCESS;
7881
7882	case DBGCVAR_TYPE_SYMBOL:
7883	case DBGCVAR_TYPE_STRING:
7884	{
7885	DBGCVAR Var;
7886	int rc = dbgcSymbolGet(pDbgc, pVar->u.pszString, DBGCVAR_TYPE_NUMBER, &Var);
7887	if (VBOX_SUCCESS(rc))
7888	{
7889	*pVar = Var;
7890	return rc;
7891	}
7892	break;
7893	}
7894	default:
7895	break;
7896	}
7897	break;
7898
7899	/*
7900	* Strings can easily be made from symbols (and of course strings).
7901	* We could consider reformatting the addresses and numbers into strings later...
7902	*/
7903	case DBGCVAR_CAT_STRING:
7904	switch (pVar->enmType)
7905	{
7906	case DBGCVAR_TYPE_SYMBOL:
7907	pVar->enmType = DBGCVAR_TYPE_STRING;
7908	/* fallthru */
7909	case DBGCVAR_TYPE_STRING:
7910	return VINF_SUCCESS;
7911	default:
7912	break;
7913	}
7914	break;
7915
7916	/*
7917	* Symol is pretty much the same thing as a string (at least until we actually implement it).
7918	*/
7919	case DBGCVAR_CAT_SYMBOL:
7920	switch (pVar->enmType)
7921	{
7922	case DBGCVAR_TYPE_STRING:
7923	pVar->enmType = DBGCVAR_TYPE_SYMBOL;
7924	/* fallthru */
7925	case DBGCVAR_TYPE_SYMBOL:
7926	return VINF_SUCCESS;
7927	default:
7928	break;
7929	}
7930	break;
7931
7932	/*
7933	* Anything else is illegal.
7934	*/
7935	default:
7936	AssertMsgFailed(("enmCategory=%d\n", pVar->enmType));
7937	break;
7938	}
7939
7940	return VERR_PARSE_NO_ARGUMENT_MATCH;
7941	}
7942
7943
7944	/**
7945	* Matches a set of variables with a description set.
7946	*
7947	* This is typically used for routine arguments before a call. The effects in
7948	* addition to the validation, is that some variables might be propagated to
7949	* other types in order to match the description. The following transformations
7950	* are supported:
7951	* - String reinterpreted as a symbol and resolved to a number or pointer.
7952	* - Number to a pointer.
7953	* - Pointer to a number.
7954	* @returns 0 on success with paVars.
7955	* @returns VBox error code for match errors.
7956	*/
7957	static int dbgcEvalSubMatchVars(PDBGC pDbgc, unsigned cVarsMin, unsigned cVarsMax,
7958	PCDBGCVARDESC paVarDescs, unsigned cVarDescs,
7959	PDBGCVAR paVars, unsigned cVars)
7960	{
7961	/*
7962	* Just do basic min / max checks first.
7963	*/
7964	if (cVars < cVarsMin)
7965	return VERR_PARSE_TOO_FEW_ARGUMENTS;
7966	if (cVars > cVarsMax)
7967	return VERR_PARSE_TOO_MANY_ARGUMENTS;
7968
7969	/*
7970	* Match the descriptors and actual variables.
7971	*/
7972	PCDBGCVARDESC pPrevDesc = NULL;
7973	unsigned cCurDesc = 0;
7974	unsigned iVar = 0;
7975	unsigned iVarDesc = 0;
7976	while (iVar < cVars)
7977	{
7978	/* walk the descriptors */
7979	if (iVarDesc >= cVarDescs)
7980	return VERR_PARSE_TOO_MANY_ARGUMENTS;
7981	if ( ( paVarDescs[iVarDesc].fFlags & DBGCVD_FLAGS_DEP_PREV
7982	&& &paVarDescs[iVarDesc - 1] != pPrevDesc)
7983	\|\| cCurDesc >= paVarDescs[iVarDesc].cTimesMax)
7984	{
7985	iVarDesc++;
7986	if (iVarDesc >= cVarDescs)
7987	return VERR_PARSE_TOO_MANY_ARGUMENTS;
7988	cCurDesc = 0;
7989	}
7990
7991	/*
7992	* Skip thru optional arguments until we find something which matches
7993	* or can easily be promoted to what the descriptor want.
7994	*/
7995	for (;;)
7996	{
7997	int rc = dbgcEvalSubMatchVar(pDbgc, &paVars[iVar], &paVarDescs[iVarDesc]);
7998	if (VBOX_SUCCESS(rc))
7999	{
8000	paVars[iVar].pDesc = &paVarDescs[iVarDesc];
8001	cCurDesc++;
8002	break;
8003	}
8004
8005	/* can we advance? */
8006	if (paVarDescs[iVarDesc].cTimesMin > cCurDesc)
8007	return VERR_PARSE_ARGUMENT_TYPE_MISMATCH;
8008	if (++iVarDesc >= cVarDescs)
8009	return VERR_PARSE_ARGUMENT_TYPE_MISMATCH;
8010	cCurDesc = 0;
8011	}
8012
8013	/* next var */
8014	iVar++;
8015	}
8016
8017	/*
8018	* Check that the rest of the descriptors are optional.
8019	*/
8020	while (iVarDesc < cVarDescs)
8021	{
8022	if (paVarDescs[iVarDesc].cTimesMin > cCurDesc)
8023	return VERR_PARSE_TOO_FEW_ARGUMENTS;
8024	cCurDesc = 0;
8025
8026	/* next */
8027	iVarDesc++;
8028	}
8029
8030	return 0;
8031	}
8032
8033
8034	/**
8035	* Evaluates one argument with respect to unary operators.
8036	*
8037	* @returns 0 on success. pResult contains the result.
8038	* @returns VBox error code on parse or other evaluation error.
8039	*
8040	* @param pDbgc Debugger console instance data.
8041	* @param pszExpr The expression string.
8042	* @param pResult Where to store the result of the expression evaluation.
8043	*/
8044	static int dbgcEvalSubUnary(PDBGC pDbgc, char *pszExpr, size_t cchExpr, PDBGCVAR pResult)
8045	{
8046	Log2(("dbgcEvalSubUnary: cchExpr=%d pszExpr=%s\n", cchExpr, pszExpr));
8047
8048	/*
8049	* The state of the expression is now such that it will start by zero or more
8050	* unary operators and being followed by an expression of some kind.
8051	* The expression is either plain or in parenthesis.
8052	*
8053	* Being in a lazy, recursive mode today, the parsing is done as simple as possible. :-)
8054	* ASSUME: unary operators are all of equal precedence.
8055	*/
8056	int rc = 0;
8057	PCDBGCOP pOp = dbgcOperatorLookup(pDbgc, pszExpr, false, ' ');
8058	if (pOp)
8059	{
8060	/* binary operators means syntax error. */
8061	if (pOp->fBinary)
8062	return VERR_PARSE_UNEXPECTED_OPERATOR;
8063
8064	/*
8065	* If the next expression (the one following the unary operator) is in a
8066	* parenthesis a full eval is needed. If not the unary eval will suffice.
8067	*/
8068	/* calc and strip next expr. */
8069	char *pszExpr2 = pszExpr + pOp->cchName;
8070	while (isblank(*pszExpr2))
8071	pszExpr2++;
8072
8073	if (!*pszExpr2)
8074	rc = VERR_PARSE_EMPTY_ARGUMENT;
8075	else
8076	{
8077	DBGCVAR Arg;
8078	if (*pszExpr2 == '(')
8079	rc = dbgcEvalSub(pDbgc, pszExpr2, cchExpr - (pszExpr2 - pszExpr), &Arg);
8080	else
8081	rc = dbgcEvalSubUnary(pDbgc, pszExpr2, cchExpr - (pszExpr2 - pszExpr), &Arg);
8082	if (VBOX_SUCCESS(rc))
8083	rc = pOp->pfnHandlerUnary(pDbgc, &Arg, pResult);
8084	}
8085	}
8086	else
8087	{
8088	/*
8089	* Didn't find any operators, so it we have to check if this can be an
8090	* function call before assuming numeric or string expression.
8091	*
8092	* (ASSUMPTIONS:)
8093	* A function name only contains alphanumerical chars and it can not start
8094	* with a numerical character.
8095	* Immediately following the name is a parenthesis which must over
8096	* the remaining part of the expression.
8097	*/
8098	bool fExternal = *pszExpr == '.';
8099	char *pszFun = fExternal ? pszExpr + 1 : pszExpr;
8100	char *pszFunEnd = NULL;
8101	if (pszExpr[cchExpr - 1] == ')' && isalpha(*pszFun))
8102	{
8103	pszFunEnd = pszExpr + 1;
8104	while (pszFunEnd != '(' && isalnum(pszFunEnd))
8105	pszFunEnd++;
8106	if (*pszFunEnd != '(')
8107	pszFunEnd = NULL;
8108	}
8109
8110	if (pszFunEnd)
8111	{
8112	/*
8113	* Ok, it's a function call.
8114	*/
8115	if (fExternal)
8116	pszExpr++, cchExpr--;
8117	PCDBGCCMD pFun = dbgcRoutineLookup(pDbgc, pszExpr, pszFunEnd - pszExpr, fExternal);
8118	if (!pFun)
8119	return VERR_PARSE_FUNCTION_NOT_FOUND;
8120	if (!pFun->pResultDesc)
8121	return VERR_PARSE_NOT_A_FUNCTION;
8122
8123	/*
8124	* Parse the expression in parenthesis.
8125	*/
8126	cchExpr -= pszFunEnd - pszExpr;
8127	pszExpr = pszFunEnd;
8128	/** @todo implement multiple arguments. */
8129	DBGCVAR Arg;
8130	rc = dbgcEvalSub(pDbgc, pszExpr, cchExpr, &Arg);
8131	if (!rc)
8132	{
8133	rc = dbgcEvalSubMatchVars(pDbgc, pFun->cArgsMin, pFun->cArgsMax, pFun->paArgDescs, pFun->cArgDescs, &Arg, 1);
8134	if (!rc)
8135	rc = pFun->pfnHandler(pFun, &pDbgc->CmdHlp, pDbgc->pVM, &Arg, 1, pResult);
8136	}
8137	else if (rc == VERR_PARSE_EMPTY_ARGUMENT && pFun->cArgsMin == 0)
8138	rc = pFun->pfnHandler(pFun, &pDbgc->CmdHlp, pDbgc->pVM, NULL, 0, pResult);
8139	}
8140	else
8141	{
8142	/*
8143	* Didn't find any operators, so it must be a plain expression.
8144	* This might be numeric or a string expression.
8145	*/
8146	char ch = pszExpr[0];
8147	char ch2 = pszExpr[1];
8148	if (ch == '0' && (ch2 == 'x' \|\| ch2 == 'X'))
8149	rc = dbgcEvalSubNum(pszExpr + 2, 16, pResult);
8150	else if (ch == '0' && (ch2 == 'i' \|\| ch2 == 'i'))
8151	rc = dbgcEvalSubNum(pszExpr + 2, 10, pResult);
8152	else if (ch == '0' && (ch2 == 't' \|\| ch2 == 'T'))
8153	rc = dbgcEvalSubNum(pszExpr + 2, 8, pResult);
8154	/// @todo 0b doesn't work as a binary prefix, we confuse it with 0bf8:0123 and stuff.
8155	//else if (ch == '0' && (ch2 == 'b' \|\| ch2 == 'b'))
8156	// rc = dbgcEvalSubNum(pszExpr + 2, 2, pResult);
8157	else
8158	{
8159	/*
8160	* Hexadecimal number or a string?
8161	*/
8162	char *psz = pszExpr;
8163	while (isxdigit(*psz))
8164	psz++;
8165	if (!*psz)
8166	rc = dbgcEvalSubNum(pszExpr, 16, pResult);
8167	else if ((psz == 'h' \|\| psz == 'H') && !psz[1])
8168	{
8169	*psz = '\0';
8170	rc = dbgcEvalSubNum(pszExpr, 16, pResult);
8171	}
8172	else
8173	rc = dbgcEvalSubString(pDbgc, pszExpr, cchExpr, pResult);
8174	}
8175	}
8176	}
8177
8178	return rc;
8179	}
8180
8181
8182	/**
8183	* Evaluates one argument.
8184	*
8185	* @returns 0 on success. pResult contains the result.
8186	* @returns VBox error code on parse or other evaluation error.
8187	*
8188	* @param pDbgc Debugger console instance data.
8189	* @param pszExpr The expression string.
8190	* @param pResult Where to store the result of the expression evaluation.
8191	*/
8192	static int dbgcEvalSub(PDBGC pDbgc, char *pszExpr, size_t cchExpr, PDBGCVAR pResult)
8193	{
8194	Log2(("dbgcEvalSub: cchExpr=%d pszExpr=%s\n", cchExpr, pszExpr));
8195	/*
8196	* First we need to remove blanks in both ends.
8197	* ASSUMES: There is no quoting unless the entire expression is a string.
8198	*/
8199
8200	/* stripping. */
8201	while (cchExpr > 0 && isblank(pszExpr[cchExpr - 1]))
8202	pszExpr[--cchExpr] = '\0';
8203	while (isblank(*pszExpr))
8204	pszExpr++, cchExpr--;
8205	if (!*pszExpr)
8206	return VERR_PARSE_EMPTY_ARGUMENT;
8207
8208	/* it there is any kind of quoting in the expression, it's string meat. */
8209	if (strpbrk(pszExpr, "\"'`"))
8210	return dbgcEvalSubString(pDbgc, pszExpr, cchExpr, pResult);
8211
8212	/*
8213	* Check if there are any parenthesis which needs removing.
8214	*/
8215	if (pszExpr[0] == '(' && pszExpr[cchExpr - 1] == ')')
8216	{
8217	do
8218	{
8219	unsigned cPar = 1;
8220	char *psz = pszExpr + 1;
8221	char ch;
8222	while ((ch = *psz) != '\0')
8223	{
8224	if (ch == '(')
8225	cPar++;
8226	else if (ch == ')')
8227	{
8228	if (cPar <= 0)
8229	return VERR_PARSE_UNBALANCED_PARENTHESIS;
8230	cPar--;
8231	if (cPar == 0 && psz[1]) /* If not at end, there's nothing to do. */
8232	break;
8233	}
8234	/* next */
8235	psz++;
8236	}
8237	if (ch)
8238	break;
8239
8240	/* remove the parenthesis. */
8241	pszExpr++;
8242	cchExpr -= 2;
8243	pszExpr[cchExpr] = '\0';
8244
8245	/* strip blanks. */
8246	while (cchExpr > 0 && isblank(pszExpr[cchExpr - 1]))
8247	pszExpr[--cchExpr] = '\0';
8248	while (isblank(*pszExpr))
8249	pszExpr++, cchExpr--;
8250	if (!*pszExpr)
8251	return VERR_PARSE_EMPTY_ARGUMENT;
8252	} while (pszExpr[0] == '(' && pszExpr[cchExpr - 1] == ')');
8253	}
8254
8255	/* tabs to spaces. */
8256	char *psz = pszExpr;
8257	while ((psz = strchr(psz, '\t')) != NULL)
8258	*psz = ' ';
8259
8260	/*
8261	* Now, we need to look for the binary operator with the lowest precedence.
8262	*
8263	* If there are no operators we're left with a simple expression which we
8264	* evaluate with respect to unary operators
8265	*/
8266	char *pszOpSplit = NULL;
8267	PCDBGCOP pOpSplit = NULL;
8268	unsigned cBinaryOps = 0;
8269	unsigned cPar = 0;
8270	char ch;
8271	char chPrev = ' ';
8272	bool fBinary = false;
8273	psz = pszExpr;
8274
8275	while ((ch = *psz) != '\0')
8276	{
8277	//Log2(("ch=%c cPar=%d fBinary=%d\n", ch, cPar, fBinary));
8278	/*
8279	* Parenthesis.
8280	*/
8281	if (ch == '(')
8282	{
8283	cPar++;
8284	fBinary = false;
8285	}
8286	else if (ch == ')')
8287	{
8288	if (cPar <= 0)
8289	return VERR_PARSE_UNBALANCED_PARENTHESIS;
8290	cPar--;
8291	fBinary = true;
8292	}
8293	/*
8294	* Potential operator.
8295	*/
8296	else if (cPar == 0 && !isblank(ch))
8297	{
8298	PCDBGCOP pOp = dbgcIsOpChar(ch)
8299	? dbgcOperatorLookup(pDbgc, psz, fBinary, chPrev)
8300	: NULL;
8301	if (pOp)
8302	{
8303	/* If not the right kind of operator we've got a syntax error. */
8304	if (pOp->fBinary != fBinary)
8305	return VERR_PARSE_UNEXPECTED_OPERATOR;
8306
8307	/*
8308	* Update the parse state and skip the operator.
8309	*/
8310	if (!pOpSplit)
8311	{
8312	pOpSplit = pOp;
8313	pszOpSplit = psz;
8314	cBinaryOps = fBinary;
8315	}
8316	else if (fBinary)
8317	{
8318	cBinaryOps++;
8319	if (pOp->iPrecedence >= pOpSplit->iPrecedence)
8320	{
8321	pOpSplit = pOp;
8322	pszOpSplit = psz;
8323	}
8324	}
8325
8326	psz += pOp->cchName - 1;
8327	fBinary = false;
8328	}
8329	else
8330	fBinary = true;
8331	}
8332
8333	/* next */
8334	psz++;
8335	chPrev = ch;
8336	} /* parse loop. */
8337
8338
8339	/*
8340	* Either we found an operator to divide the expression by
8341	* or we didn't find any. In the first case it's divide and
8342	* conquer. In the latter it's a single expression which
8343	* needs dealing with its unary operators if any.
8344	*/
8345	int rc;
8346	if ( cBinaryOps
8347	&& pOpSplit->fBinary)
8348	{
8349	/* process 1st sub expression. */
8350	*pszOpSplit = '\0';
8351	DBGCVAR Arg1;
8352	rc = dbgcEvalSub(pDbgc, pszExpr, pszOpSplit - pszExpr, &Arg1);
8353	if (VBOX_SUCCESS(rc))
8354	{
8355	/* process 2nd sub expression. */
8356	char *psz2 = pszOpSplit + pOpSplit->cchName;
8357	DBGCVAR Arg2;
8358	rc = dbgcEvalSub(pDbgc, psz2, cchExpr - (psz2 - pszExpr), &Arg2);
8359	if (VBOX_SUCCESS(rc))
8360	/* apply the operator. */
8361	rc = pOpSplit->pfnHandlerBinary(pDbgc, &Arg1, &Arg2, pResult);
8362	}
8363	}
8364	else if (cBinaryOps)
8365	{
8366	/* process sub expression. */
8367	pszOpSplit += pOpSplit->cchName;
8368	DBGCVAR Arg;
8369	rc = dbgcEvalSub(pDbgc, pszOpSplit, cchExpr - (pszOpSplit - pszExpr), &Arg);
8370	if (VBOX_SUCCESS(rc))
8371	/* apply the operator. */
8372	rc = pOpSplit->pfnHandlerUnary(pDbgc, &Arg, pResult);
8373	}
8374	else
8375	/* plain expression or using unary operators perhaps with paratheses. */
8376	rc = dbgcEvalSubUnary(pDbgc, pszExpr, cchExpr, pResult);
8377
8378	return rc;
8379	}
8380
8381
8382	/**
8383	* Parses the arguments of one command.
8384	*
8385	* @returns 0 on success.
8386	* @returns VBox error code on parse error with *pcArg containing the argument causing trouble.
8387	* @param pDbgc Debugger console instance data.
8388	* @param pCmd Pointer to the command descriptor.
8389	* @param pszArg Pointer to the arguments to parse.
8390	* @param paArgs Where to store the parsed arguments.
8391	* @param cArgs Size of the paArgs array.
8392	* @param pcArgs Where to store the number of arguments.
8393	* In the event of an error this is used to store the index of the offending argument.
8394	*/
8395	static int dbgcProcessArguments(PDBGC pDbgc, PCDBGCCMD pCmd, char pszArgs, PDBGCVAR paArgs, unsigned cArgs, unsigned pcArgs)
8396	{
8397	Log2(("dbgcProcessArguments: pCmd=%s pszArgs='%s'\n", pCmd->pszCmd, pszArgs));
8398	/*
8399	* Check if we have any argument and if the command takes any.
8400	*/
8401	*pcArgs = 0;
8402	/* strip leading blanks. */
8403	while (pszArgs && isblank(pszArgs))
8404	pszArgs++;
8405	if (!*pszArgs)
8406	{
8407	if (!pCmd->cArgsMin)
8408	return 0;
8409	return VERR_PARSE_TOO_FEW_ARGUMENTS;
8410	}
8411	/** @todo fixme - foo() doesn't work. */
8412	if (!pCmd->cArgsMax)
8413	return VERR_PARSE_TOO_MANY_ARGUMENTS;
8414
8415	/*
8416	* This is a hack, it's "temporary" and should go away "when" the parser is
8417	* modified to match arguments while parsing.
8418	*/
8419	if ( pCmd->cArgsMax == 1
8420	&& pCmd->cArgsMin == 1
8421	&& pCmd->cArgDescs == 1
8422	&& pCmd->paArgDescs[0].enmCategory == DBGCVAR_CAT_STRING
8423	&& cArgs >= 1)
8424	{
8425	*pcArgs = 1;
8426	RTStrStripR(pszArgs);
8427	return dbgcEvalSubString(pDbgc, pszArgs, strlen(pszArgs), &paArgs[0]);
8428	}
8429
8430
8431	/*
8432	* The parse loop.
8433	*/
8434	PDBGCVAR pArg0 = &paArgs[0];
8435	PDBGCVAR pArg = pArg0;
8436	*pcArgs = 0;
8437	do
8438	{
8439	/*
8440	* Can we have another argument?
8441	*/
8442	if (*pcArgs >= pCmd->cArgsMax)
8443	return VERR_PARSE_TOO_MANY_ARGUMENTS;
8444	if (pArg >= &paArgs[cArgs])
8445	return VERR_PARSE_ARGUMENT_OVERFLOW;
8446
8447	/*
8448	* Find the end of the argument.
8449	*/
8450	int cPar = 0;
8451	char chQuote = '\0';
8452	char *pszEnd = NULL;
8453	char *psz = pszArgs;
8454	char ch;
8455	bool fBinary = false;
8456	for (;;)
8457	{
8458	/*
8459	* Check for the end.
8460	*/
8461	if ((ch = *psz) == '\0')
8462	{
8463	if (chQuote)
8464	return VERR_PARSE_UNBALANCED_QUOTE;
8465	if (cPar)
8466	return VERR_PARSE_UNBALANCED_PARENTHESIS;
8467	pszEnd = psz;
8468	break;
8469	}
8470	/*
8471	* When quoted we ignore everything but the quotation char.
8472	* We use the REXX way of escaping the quotation char, i.e. double occurence.
8473	*/
8474	else if (ch == '\'' \|\| ch == '"' \|\| ch == '`')
8475	{
8476	if (chQuote)
8477	{
8478	/* end quote? */
8479	if (ch == chQuote)
8480	{
8481	if (psz[1] == ch)
8482	psz++; /* skip the escaped quote char */
8483	else
8484	chQuote = '\0'; /* end of quoted string. */
8485	}
8486	}
8487	else
8488	chQuote = ch; /* open new quote */
8489	}
8490	/*
8491	* Parenthesis can of course be nested.
8492	*/
8493	else if (ch == '(')
8494	{
8495	cPar++;
8496	fBinary = false;
8497	}
8498	else if (ch == ')')
8499	{
8500	if (!cPar)
8501	return VERR_PARSE_UNBALANCED_PARENTHESIS;
8502	cPar--;
8503	fBinary = true;
8504	}
8505	else if (!chQuote && !cPar)
8506	{
8507	/*
8508	* Encountering blanks may mean the end of it all. A binary operator
8509	* will force continued parsing.
8510	*/
8511	if (isblank(*psz))
8512	{
8513	pszEnd = psz++; /* just in case. */
8514	while (isblank(*psz))
8515	psz++;
8516	PCDBGCOP pOp = dbgcOperatorLookup(pDbgc, psz, fBinary, ' ');
8517	if (!pOp \|\| pOp->fBinary != fBinary)
8518	break; /* the end. */
8519	psz += pOp->cchName;
8520	while (isblank(psz)) / skip blanks so we don't get here again */
8521	psz++;
8522	fBinary = false;
8523	continue;
8524	}
8525
8526	/*
8527	* Look for operators without a space up front.
8528	*/
8529	if (dbgcIsOpChar(*psz))
8530	{
8531	PCDBGCOP pOp = dbgcOperatorLookup(pDbgc, psz, fBinary, ' ');
8532	if (pOp)
8533	{
8534	if (pOp->fBinary != fBinary)
8535	{
8536	pszEnd = psz;
8537	/** @todo this is a parsing error really. */
8538	break; /* the end. */
8539	}
8540	psz += pOp->cchName;
8541	while (isblank(psz)) / skip blanks so we don't get here again */
8542	psz++;
8543	fBinary = false;
8544	continue;
8545	}
8546	}
8547	fBinary = true;
8548	}
8549
8550	/* next char */
8551	psz++;
8552	}
8553	*pszEnd = '\0';
8554	/* (psz = next char to process) */
8555
8556	/*
8557	* Parse and evaluate the argument.
8558	*/
8559	int rc = dbgcEvalSub(pDbgc, pszArgs, strlen(pszArgs), pArg);
8560	if (VBOX_FAILURE(rc))
8561	return rc;
8562
8563	/*
8564	* Next.
8565	*/
8566	pArg++;
8567	(*pcArgs)++;
8568	pszArgs = psz;
8569	while (pszArgs && isblank(pszArgs))
8570	pszArgs++;
8571	} while (*pszArgs);
8572
8573	/*
8574	* Match the arguments.
8575	*/
8576	return dbgcEvalSubMatchVars(pDbgc, pCmd->cArgsMin, pCmd->cArgsMax, pCmd->paArgDescs, pCmd->cArgDescs, pArg0, pArg - pArg0);
8577	}
8578
8579
8580	/**
8581	* Process one command.
8582	*
8583	* @returns VBox status code. Any error indicates the termination of the console session.
8584	* @param pDbgc Debugger console instance data.
8585	* @param pszCmd Pointer to the command.
8586	* @param cchCmd Length of the command.
8587	*/
8588	static int dbgcProcessCommand(PDBGC pDbgc, char *pszCmd, size_t cchCmd)
8589	{
8590	char *pszCmdInput = pszCmd;
8591
8592	/*
8593	* Skip blanks.
8594	*/
8595	while (isblank(*pszCmd))
8596	pszCmd++, cchCmd--;
8597
8598	/* external command? */
8599	bool fExternal = *pszCmd == '.';
8600	if (fExternal)
8601	pszCmd++, cchCmd--;
8602
8603	/*
8604	* Find arguments.
8605	*/
8606	char *pszArgs = pszCmd;
8607	while (isalnum(*pszArgs))
8608	pszArgs++;
8609	if (pszArgs && (!isblank(pszArgs) \|\| pszArgs == pszCmd))
8610	{
8611	pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "Syntax error in command '%s'!\n", pszCmdInput);
8612	return 0;
8613	}
8614
8615	/*
8616	* Find the command.
8617	*/
8618	PCDBGCCMD pCmd = dbgcRoutineLookup(pDbgc, pszCmd, pszArgs - pszCmd, fExternal);
8619	if (!pCmd \|\| (pCmd->fFlags & DBGCCMD_FLAGS_FUNCTION))
8620	return pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "Unknown command '%s'!\n", pszCmdInput);
8621
8622	/*
8623	* Parse arguments (if any).
8624	*/
8625	unsigned cArgs;
8626	int rc = dbgcProcessArguments(pDbgc, pCmd, pszArgs, &pDbgc->aArgs[pDbgc->iArg], ELEMENTS(pDbgc->aArgs) - pDbgc->iArg, &cArgs);
8627
8628	/*
8629	* Execute the command.
8630	*/
8631	if (!rc)
8632	{
8633	rc = pCmd->pfnHandler(pCmd, &pDbgc->CmdHlp, pDbgc->pVM, &pDbgc->aArgs[0], cArgs, NULL);
8634	}
8635	else
8636	{
8637	/* report parse / eval error. */
8638	switch (rc)
8639	{
8640	case VERR_PARSE_TOO_FEW_ARGUMENTS:
8641	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8642	"Syntax error: Too few arguments. Minimum is %d for command '%s'.\n", pCmd->cArgsMin, pCmd->pszCmd);
8643	break;
8644	case VERR_PARSE_TOO_MANY_ARGUMENTS:
8645	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8646	"Syntax error: Too many arguments. Maximum is %d for command '%s'.\n", pCmd->cArgsMax, pCmd->pszCmd);
8647	break;
8648	case VERR_PARSE_ARGUMENT_OVERFLOW:
8649	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8650	"Syntax error: Too many arguments.\n");
8651	break;
8652	case VERR_PARSE_UNBALANCED_QUOTE:
8653	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8654	"Syntax error: Unbalanced quote (argument %d).\n", cArgs);
8655	break;
8656	case VERR_PARSE_UNBALANCED_PARENTHESIS:
8657	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8658	"Syntax error: Unbalanced parenthesis (argument %d).\n", cArgs);
8659	break;
8660	case VERR_PARSE_EMPTY_ARGUMENT:
8661	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8662	"Syntax error: An argument or subargument contains nothing useful (argument %d).\n", cArgs);
8663	break;
8664	case VERR_PARSE_UNEXPECTED_OPERATOR:
8665	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8666	"Syntax error: Invalid operator usage (argument %d).\n", cArgs);
8667	break;
8668	case VERR_PARSE_INVALID_NUMBER:
8669	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8670	"Syntax error: Ivalid numeric value (argument %d). If a string was the intention, then quote it.\n", cArgs);
8671	break;
8672	case VERR_PARSE_NUMBER_TOO_BIG:
8673	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8674	"Error: Numeric overflow (argument %d).\n", cArgs);
8675	break;
8676	case VERR_PARSE_INVALID_OPERATION:
8677	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8678	"Error: Invalid operation attempted (argument %d).\n", cArgs);
8679	break;
8680	case VERR_PARSE_FUNCTION_NOT_FOUND:
8681	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8682	"Error: Function not found (argument %d).\n", cArgs);
8683	break;
8684	case VERR_PARSE_NOT_A_FUNCTION:
8685	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8686	"Error: The function specified is not a function (argument %d).\n", cArgs);
8687	break;
8688	case VERR_PARSE_NO_MEMORY:
8689	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8690	"Error: Out memory in the regular heap! Expect odd stuff to happen...\n", cArgs);
8691	break;
8692	case VERR_PARSE_INCORRECT_ARG_TYPE:
8693	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8694	"Error: Incorrect argument type (argument %d?).\n", cArgs);
8695	break;
8696	case VERR_PARSE_VARIABLE_NOT_FOUND:
8697	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8698	"Error: An undefined variable was referenced (argument %d).\n", cArgs);
8699	break;
8700	case VERR_PARSE_CONVERSION_FAILED:
8701	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8702	"Error: A conversion between two types failed (argument %d).\n", cArgs);
8703	break;
8704	case VERR_PARSE_NOT_IMPLEMENTED:
8705	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8706	"Error: You hit a debugger feature which isn't implemented yet (argument %d).\n", cArgs);
8707	break;
8708	case VERR_PARSE_BAD_RESULT_TYPE:
8709	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8710	"Error: Couldn't satisfy a request for a specific result type (argument %d). (Usually applies to symbols)\n", cArgs);
8711	break;
8712	case VERR_PARSE_WRITEONLY_SYMBOL:
8713	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8714	"Error: Cannot get symbol, it's set only (argument %d).\n", cArgs);
8715	break;
8716
8717	default:
8718	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8719	"Error: Unknown error %d!\n", rc);
8720	return rc;
8721	}
8722
8723	/*
8724	* Parse errors are non fatal.
8725	*/
8726	if (rc >= VERR_PARSE_FIRST && rc < VERR_PARSE_LAST)
8727	rc = 0;
8728	}
8729
8730	return rc;
8731	}
8732
8733
8734	/**
8735	* Process all commands current in the buffer.
8736	*
8737	* @returns VBox status code. Any error indicates the termination of the console session.
8738	* @param pDbgc Debugger console instance data.
8739	*/
8740	static int dbgcProcessCommands(PDBGC pDbgc)
8741	{
8742	int rc = 0;
8743	while (pDbgc->cInputLines)
8744	{
8745	/*
8746	* Empty the log buffer if we're hooking the log.
8747	*/
8748	if (pDbgc->fLog)
8749	{
8750	rc = dbgcProcessLog(pDbgc);
8751	if (VBOX_FAILURE(rc))
8752	break;
8753	}
8754
8755	if (pDbgc->iRead == pDbgc->iWrite)
8756	{
8757	AssertMsgFailed(("The input buffer is empty while cInputLines=%d!\n", pDbgc->cInputLines));
8758	pDbgc->cInputLines = 0;
8759	return 0;
8760	}
8761
8762	/*
8763	* Copy the command to the parse buffer.
8764	*/
8765	char ch;
8766	char *psz = &pDbgc->achInput[pDbgc->iRead];
8767	char *pszTrg = &pDbgc->achScratch[0];
8768	while ((pszTrg = ch = psz++) != ';' && ch != '\n' )
8769	{
8770	if (psz == &pDbgc->achInput[sizeof(pDbgc->achInput)])
8771	psz = &pDbgc->achInput[0];
8772
8773	if (psz == &pDbgc->achInput[pDbgc->iWrite])
8774	{
8775	AssertMsgFailed(("The buffer contains no commands while cInputLines=%d!\n", pDbgc->cInputLines));
8776	pDbgc->cInputLines = 0;
8777	return 0;
8778	}
8779
8780	pszTrg++;
8781	}
8782	*pszTrg = '\0';
8783
8784	/*
8785	* Advance the buffer.
8786	*/
8787	pDbgc->iRead = psz - &pDbgc->achInput[0];
8788	if (ch == '\n')
8789	pDbgc->cInputLines--;
8790
8791	/*
8792	* Parse and execute this command.
8793	*/
8794	pDbgc->pszScratch = psz;
8795	pDbgc->iArg = 0;
8796	rc = dbgcProcessCommand(pDbgc, &pDbgc->achScratch[0], psz - &pDbgc->achScratch[0] - 1);
8797	if (rc)
8798	break;
8799	}
8800
8801	return rc;
8802	}
8803
8804
8805	/**
8806	* Reads input, parses it and executes commands on '\n'.
8807	*
8808	* @returns VBox status.
8809	* @param pDbgc Debugger console instance data.
8810	*/
8811	static int dbgcProcessInput(PDBGC pDbgc)
8812	{
8813	/*
8814	* We know there's input ready, so let's read it first.
8815	*/
8816	int rc = dbgcInputRead(pDbgc);
8817	if (VBOX_FAILURE(rc))
8818	return rc;
8819
8820	/*
8821	* Now execute any ready commands.
8822	*/
8823	if (pDbgc->cInputLines)
8824	{
8825	/** @todo this fReady stuff is broken. */
8826	pDbgc->fReady = false;
8827	rc = dbgcProcessCommands(pDbgc);
8828	if (VBOX_SUCCESS(rc) && rc != VWRN_DBGC_CMD_PENDING)
8829	pDbgc->fReady = true;
8830	if ( VBOX_SUCCESS(rc)
8831	&& pDbgc->iRead == pDbgc->iWrite
8832	&& pDbgc->fReady)
8833	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "VBoxDbg> ");
8834	}
8835
8836	return rc;
8837	}
8838
8839
8840	/**
8841	* Gets the event context identifier string.
8842	* @returns Read only string.
8843	* @param enmCtx The context.
8844	*/
8845	static const char *dbgcGetEventCtx(DBGFEVENTCTX enmCtx)
8846	{
8847	switch (enmCtx)
8848	{
8849	case DBGFEVENTCTX_RAW: return "raw";
8850	case DBGFEVENTCTX_REM: return "rem";
8851	case DBGFEVENTCTX_HWACCL: return "hwaccl";
8852	case DBGFEVENTCTX_HYPER: return "hyper";
8853	case DBGFEVENTCTX_OTHER: return "other";
8854
8855	case DBGFEVENTCTX_INVALID: return "!Invalid Event Ctx!";
8856	default:
8857	AssertMsgFailed(("enmCtx=%d\n", enmCtx));
8858	return "!Unknown Event Ctx!";
8859	}
8860	}
8861
8862
8863	/**
8864	* Processes debugger events.
8865	*
8866	* @returns VBox status.
8867	* @param pDbgc DBGC Instance data.
8868	* @param pEvent Pointer to event data.
8869	*/
8870	static int dbgcProcessEvent(PDBGC pDbgc, PCDBGFEVENT pEvent)
8871	{
8872	/*
8873	* Flush log first.
8874	*/
8875	if (pDbgc->fLog)
8876	{
8877	int rc = dbgcProcessLog(pDbgc);
8878	if (VBOX_FAILURE(rc))
8879	return rc;
8880	}
8881
8882	/*
8883	* Process the event.
8884	*/
8885	pDbgc->pszScratch = &pDbgc->achInput[0];
8886	pDbgc->iArg = 0;
8887	bool fPrintPrompt = true;
8888	int rc = VINF_SUCCESS;
8889	switch (pEvent->enmType)
8890	{
8891	/*
8892	* The first part is events we have initiated with commands.
8893	*/
8894	case DBGFEVENT_HALT_DONE:
8895	{
8896	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\ndbgf event: VM %p is halted! (%s)\n",
8897	pDbgc->pVM, dbgcGetEventCtx(pEvent->enmCtx));
8898	pDbgc->fRegCtxGuest = true; /* we're always in guest context when halted. */
8899	if (VBOX_SUCCESS(rc))
8900	rc = pDbgc->CmdHlp.pfnExec(&pDbgc->CmdHlp, "r");
8901	break;
8902	}
8903
8904
8905	/*
8906	* The second part is events which can occur at any time.
8907	*/
8908	case DBGFEVENT_FATAL_ERROR:
8909	{
8910	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\ndbf event: Fatal error! (%s)\n",
8911	dbgcGetEventCtx(pEvent->enmCtx));
8912	pDbgc->fRegCtxGuest = false; /* fatal errors are always in hypervisor. */
8913	if (VBOX_SUCCESS(rc))
8914	rc = pDbgc->CmdHlp.pfnExec(&pDbgc->CmdHlp, "r");
8915	break;
8916	}
8917
8918	case DBGFEVENT_BREAKPOINT:
8919	case DBGFEVENT_BREAKPOINT_HYPER:
8920	{
8921	bool fRegCtxGuest = pDbgc->fRegCtxGuest;
8922	pDbgc->fRegCtxGuest = pEvent->enmType == DBGFEVENT_BREAKPOINT;
8923
8924	rc = dbgcBpExec(pDbgc, pEvent->u.Bp.iBp);
8925	switch (rc)
8926	{
8927	case VERR_DBGC_BP_NOT_FOUND:
8928	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\ndbgf event: Unknown breakpoint %u! (%s)\n",
8929	pEvent->u.Bp.iBp, dbgcGetEventCtx(pEvent->enmCtx));
8930	break;
8931
8932	case VINF_DBGC_BP_NO_COMMAND:
8933	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\ndbgf event: Breakpoint %u! (%s)\n",
8934	pEvent->u.Bp.iBp, dbgcGetEventCtx(pEvent->enmCtx));
8935	break;
8936
8937	case VINF_BUFFER_OVERFLOW:
8938	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\ndbgf event: Breakpoint %u! Command too long to execute! (%s)\n",
8939	pEvent->u.Bp.iBp, dbgcGetEventCtx(pEvent->enmCtx));
8940	break;
8941
8942	default:
8943	break;
8944	}
8945	if (VBOX_SUCCESS(rc) && DBGFR3IsHalted(pDbgc->pVM))
8946	rc = pDbgc->CmdHlp.pfnExec(&pDbgc->CmdHlp, "r");
8947	else
8948	pDbgc->fRegCtxGuest = fRegCtxGuest;
8949	break;
8950	}
8951
8952	case DBGFEVENT_STEPPED:
8953	case DBGFEVENT_STEPPED_HYPER:
8954	{
8955	pDbgc->fRegCtxGuest = pEvent->enmType == DBGFEVENT_STEPPED;
8956
8957	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\ndbgf event: Single step! (%s)\n", dbgcGetEventCtx(pEvent->enmCtx));
8958	if (VBOX_SUCCESS(rc))
8959	rc = pDbgc->CmdHlp.pfnExec(&pDbgc->CmdHlp, "r");
8960	break;
8961	}
8962
8963	case DBGFEVENT_ASSERTION_HYPER:
8964	{
8965	pDbgc->fRegCtxGuest = false;
8966
8967	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8968	"\ndbgf event: Hypervisor Assertion! (%s)\n"
8969	"%s"
8970	"%s"
8971	"\n",
8972	dbgcGetEventCtx(pEvent->enmCtx),
8973	pEvent->u.Assert.pszMsg1,
8974	pEvent->u.Assert.pszMsg2);
8975	if (VBOX_SUCCESS(rc))
8976	rc = pDbgc->CmdHlp.pfnExec(&pDbgc->CmdHlp, "r");
8977	break;
8978	}
8979
8980	case DBGFEVENT_DEV_STOP:
8981	{
8982	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8983	"\n"
8984	"dbgf event: DBGFSTOP (%s)\n"
8985	"File: %s\n"
8986	"Line: %d\n"
8987	"Function: %s\n",
8988	dbgcGetEventCtx(pEvent->enmCtx),
8989	pEvent->u.Src.pszFile,
8990	pEvent->u.Src.uLine,
8991	pEvent->u.Src.pszFunction);
8992	if (VBOX_SUCCESS(rc) && pEvent->u.Src.pszMessage && *pEvent->u.Src.pszMessage)
8993	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8994	"Message: %s\n",
8995	pEvent->u.Src.pszMessage);
8996	if (VBOX_SUCCESS(rc))
8997	rc = pDbgc->CmdHlp.pfnExec(&pDbgc->CmdHlp, "r");
8998	break;
8999	}
9000
9001
9002	case DBGFEVENT_INVALID_COMMAND:
9003	{
9004	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\ndbgf/dbgc error: Invalid command event!\n");
9005	fPrintPrompt = !pDbgc->fReady;
9006	break;
9007	}
9008
9009	case DBGFEVENT_TERMINATING:
9010	{
9011	pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\nVM is terminating!\n");
9012	rc = VERR_GENERAL_FAILURE;
9013	break;
9014	}
9015
9016
9017	default:
9018	{
9019	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\ndbgf/dbgc error: Unknown event %d!\n", pEvent->enmType);
9020	fPrintPrompt = !pDbgc->fReady;
9021	break;
9022	}
9023	}
9024
9025	/*
9026	* Prompt, anyone?
9027	*/
9028	if (fPrintPrompt && VBOX_SUCCESS(rc))
9029	{
9030	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "VBoxDbg> ");
9031	}
9032
9033	return rc;
9034	}
9035
9036
9037
9038
9039
9040	/**
9041	* Make a console instance.
9042	*
9043	* This will not return until either an 'exit' command is issued or a error code
9044	* indicating connection loss is encountered.
9045	*
9046	* @returns VINF_SUCCESS if console termination caused by the 'exit' command.
9047	* @returns The VBox status code causing the console termination.
9048	*
9049	* @param pVM VM Handle.
9050	* @param pBack Pointer to the backend structure. This must contain
9051	* a full set of function pointers to service the console.
9052	* @param fFlags Reserved, must be zero.
9053	* @remark A forced termination of the console is easiest done by forcing the
9054	* callbacks to return fatal failures.
9055	*/
9056	DBGDECL(int) DBGCCreate(PVM pVM, PDBGCBACK pBack, unsigned fFlags)
9057	{
9058	/*
9059	* Validate input.
9060	*/
9061	AssertReturn(VALID_PTR(pVM), VERR_INVALID_PARAMETER);
9062	AssertReturn(VALID_PTR(pBack), VERR_INVALID_PARAMETER);
9063	AssertMsgReturn(!fFlags, ("%#x", fFlags), VERR_INVALID_PARAMETER);
9064
9065	/*
9066	* Allocate and initialize instance data
9067	*/
9068	PDBGC pDbgc = (PDBGC)RTMemAllocZ(sizeof(*pDbgc));
9069	if (!pDbgc)
9070	return VERR_NO_MEMORY;
9071
9072	pDbgc->CmdHlp.pfnWrite = dbgcHlpWrite;
9073	pDbgc->CmdHlp.pfnPrintfV = dbgcHlpPrintfV;
9074	pDbgc->CmdHlp.pfnPrintf = dbgcHlpPrintf;
9075	pDbgc->CmdHlp.pfnVBoxErrorV = dbgcHlpVBoxErrorV;
9076	pDbgc->CmdHlp.pfnVBoxError = dbgcHlpVBoxError;
9077	pDbgc->CmdHlp.pfnMemRead = dbgcHlpMemRead;
9078	pDbgc->CmdHlp.pfnMemWrite = dbgcHlpMemWrite;
9079	pDbgc->CmdHlp.pfnEval = dbgcHlpEval;
9080	pDbgc->CmdHlp.pfnExec = dbgcHlpExec;
9081	pDbgc->CmdHlp.pfnVarToDbgfAddr = dbgcHlpVarToDbgfAddr;
9082	pDbgc->CmdHlp.pfnVarToBool = dbgcHlpVarToBool;
9083	pDbgc->pBack = pBack;
9084	pDbgc->pszScratch = &pDbgc->achScratch[0];
9085	pDbgc->fRegTerse = true;
9086	pDbgc->fRegCtxGuest = true;
9087	pDbgc->fLog = false;
9088	pDbgc->iRead = 0;
9089	pDbgc->iWrite = 0;
9090	pDbgc->fReady = true;
9091	pDbgc->fInputOverflow = false;
9092	pDbgc->cInputLines = 0;
9093
9094	dbgcInitOpCharBitMap();
9095
9096	/*
9097	* Print welcome message.
9098	*/
9099	int rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
9100	"Welcome to the VirtualBox Debugger!\n");
9101	if (VBOX_FAILURE(rc))
9102	goto l_failure;
9103
9104	/*
9105	* Attach to the VM.
9106	*/
9107	rc = DBGFR3Attach(pVM);
9108	if (VBOX_FAILURE(rc))
9109	{
9110	rc = pDbgc->CmdHlp.pfnVBoxError(&pDbgc->CmdHlp, rc, "When trying to attach to VM %p\n", pDbgc->pVM);
9111	goto l_failure;
9112	}
9113	pDbgc->pVM = pVM;
9114
9115	/*
9116	* Print commandline and auto select result.
9117	*/
9118	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
9119	"Current VM is %08x\n" /** @todo get and print the VM name! */
9120	"VBoxDbg> ",
9121	pDbgc->pVM);
9122	if (VBOX_FAILURE(rc))
9123	goto l_failure;
9124
9125	/*
9126	* Main Debugger Loop.
9127	*
9128	* This loop will either block on waiting for input or on waiting on
9129	* debug events. If we're forwarding the log we cannot wait for long
9130	* before we must flush the log.
9131	*/
9132	for (rc = 0;;)
9133	{
9134	if (pDbgc->pVM && DBGFR3CanWait(pDbgc->pVM))
9135	{
9136	/*
9137	* Wait for a debug event.
9138	*/
9139	PCDBGFEVENT pEvent;
9140	rc = DBGFR3EventWait(pDbgc->pVM, pDbgc->fLog ? 1 : 32, &pEvent);
9141	if (VBOX_SUCCESS(rc))
9142	{
9143	rc = dbgcProcessEvent(pDbgc, pEvent);
9144	if (VBOX_FAILURE(rc))
9145	break;
9146	}
9147	else if (rc != VERR_TIMEOUT)
9148	break;
9149
9150	/*
9151	* Check for input.
9152	*/
9153	if (pBack->pfnInput(pDbgc->pBack, 0))
9154	{
9155	rc = dbgcProcessInput(pDbgc);
9156	if (VBOX_FAILURE(rc))
9157	break;
9158	}
9159	}
9160	else
9161	{
9162	/*
9163	* Wait for input. If Logging is enabled we'll only wait very briefly.
9164	*/
9165	if (pBack->pfnInput(pDbgc->pBack, pDbgc->fLog ? 1 : 1000))
9166	{
9167	rc = dbgcProcessInput(pDbgc);
9168	if (VBOX_FAILURE(rc))
9169	break;
9170	}
9171	}
9172
9173	/*
9174	* Forward log output.
9175	*/
9176	if (pDbgc->fLog)
9177	{
9178	rc = dbgcProcessLog(pDbgc);
9179	if (VBOX_FAILURE(rc))
9180	break;
9181	}
9182	}
9183
9184
9185	l_failure:
9186	/*
9187	* Cleanup console debugger session.
9188	*/
9189	/* Disable log hook. */
9190	if (pDbgc->fLog)
9191	{
9192
9193	}
9194
9195	/* Detach from the VM. */
9196	if (pDbgc->pVM)
9197	DBGFR3Detach(pDbgc->pVM);
9198
9199	/* finally, free the instance memory. */
9200	RTMemFree(pDbgc);
9201
9202	return rc;
9203	}
9204
9205
9206
9207	/**
9208	* Register one or more external commands.
9209	*
9210	* @returns VBox status.
9211	* @param paCommands Pointer to an array of command descriptors.
9212	* The commands must be unique. It's not possible
9213	* to register the same commands more than once.
9214	* @param cCommands Number of commands.
9215	*/
9216	DBGDECL(int) DBGCRegisterCommands(PCDBGCCMD paCommands, unsigned cCommands)
9217	{
9218	/*
9219	* Lock the list.
9220	*/
9221	DBGCEXTCMDS_LOCK_WR();
9222	PDBGCEXTCMDS pCur = g_pExtCmdsHead;
9223	while (pCur)
9224	{
9225	if (paCommands == pCur->paCmds)
9226	{
9227	DBGCEXTCMDS_UNLOCK_WR();
9228	AssertMsgFailed(("Attempt at re-registering %d command(s)!\n", cCommands));
9229	return VWRN_DBGC_ALREADY_REGISTERED;
9230	}
9231	pCur = pCur->pNext;
9232	}
9233
9234	/*
9235	* Allocate new chunk.
9236	*/
9237	int rc = 0;
9238	pCur = (PDBGCEXTCMDS)RTMemAlloc(sizeof(*pCur));
9239	if (pCur)
9240	{
9241	pCur->cCmds = cCommands;
9242	pCur->paCmds = paCommands;
9243	pCur->pNext = g_pExtCmdsHead;
9244	g_pExtCmdsHead = pCur;
9245	}
9246	else
9247	rc = VERR_NO_MEMORY;
9248	DBGCEXTCMDS_UNLOCK_WR();
9249
9250	return rc;
9251	}
9252
9253
9254	/**
9255	* Deregister one or more external commands previously registered by
9256	* DBGCRegisterCommands().
9257	*
9258	* @returns VBox status.
9259	* @param paCommands Pointer to an array of command descriptors
9260	* as given to DBGCRegisterCommands().
9261	* @param cCommands Number of commands.
9262	*/
9263	DBGDECL(int) DBGCDeregisterCommands(PCDBGCCMD paCommands, unsigned cCommands)
9264	{
9265	/*
9266	* Lock the list.
9267	*/
9268	DBGCEXTCMDS_LOCK_WR();
9269	PDBGCEXTCMDS pPrev = NULL;
9270	PDBGCEXTCMDS pCur = g_pExtCmdsHead;
9271	while (pCur)
9272	{
9273	if (paCommands == pCur->paCmds)
9274	{
9275	if (pPrev)
9276	pPrev->pNext = pCur->pNext;
9277	else
9278	g_pExtCmdsHead = pCur->pNext;
9279	DBGCEXTCMDS_UNLOCK_WR();
9280
9281	RTMemFree(pCur);
9282	return VINF_SUCCESS;
9283	}
9284	pPrev = pCur;
9285	pCur = pCur->pNext;
9286	}
9287	DBGCEXTCMDS_UNLOCK_WR();
9288
9289	NOREF(cCommands);
9290	return VERR_DBGC_COMMANDS_NOT_REGISTERED;
9291	}
9292

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Debugger/DBGConsole.cpp@ 5574

Download in other formats: