DBGCEmulateCodeView.cpp@ 91514

Last change on this file since 91514 was 89980, checked in by vboxsync, 3 years ago
VMM/HMVMX: Add debug event and dtrace probe for the split-lock #ACs. bugref:10052
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 312.2 KB

Line
1	/* $Id: DBGCEmulateCodeView.cpp 89980 2021-06-30 14:22:17Z vboxsync $ */
2	/** @file
3	* DBGC - Debugger Console, CodeView / WinDbg Emulation.
4	*/
5
6	/*
7	* Copyright (C) 2006-2020 Oracle Corporation
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 (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#define LOG_GROUP LOG_GROUP_DBGC
23	#include <VBox/dbg.h>
24	#include <VBox/vmm/dbgf.h>
25	#include <VBox/vmm/dbgfflowtrace.h>
26	#include <VBox/vmm/pgm.h>
27	#include <VBox/vmm/cpum.h>
28	#include <VBox/dis.h>
29	#include <VBox/param.h>
30	#include <VBox/err.h>
31	#include <VBox/log.h>
32
33	#include <iprt/asm.h>
34	#include <iprt/mem.h>
35	#include <iprt/string.h>
36	#include <iprt/assert.h>
37	#include <iprt/ctype.h>
38	#include <iprt/time.h>
39
40	#include <stdlib.h>
41	#include <stdio.h>
42
43	#include "DBGCInternal.h"
44
45
46	/*********************************************************************************************************************************
47	* Internal Functions *
48	*********************************************************************************************************************************/
49	static FNDBGCCMD dbgcCmdBrkAccess;
50	static FNDBGCCMD dbgcCmdBrkClear;
51	static FNDBGCCMD dbgcCmdBrkDisable;
52	static FNDBGCCMD dbgcCmdBrkEnable;
53	static FNDBGCCMD dbgcCmdBrkList;
54	static FNDBGCCMD dbgcCmdBrkSet;
55	static FNDBGCCMD dbgcCmdBrkREM;
56	static FNDBGCCMD dbgcCmdDumpMem;
57	static FNDBGCCMD dbgcCmdDumpDT;
58	static FNDBGCCMD dbgcCmdDumpIDT;
59	static FNDBGCCMD dbgcCmdDumpPageDir;
60	static FNDBGCCMD dbgcCmdDumpPageDirBoth;
61	static FNDBGCCMD dbgcCmdDumpPageHierarchy;
62	static FNDBGCCMD dbgcCmdDumpPageTable;
63	static FNDBGCCMD dbgcCmdDumpPageTableBoth;
64	static FNDBGCCMD dbgcCmdDumpTSS;
65	static FNDBGCCMD dbgcCmdDumpTypeInfo;
66	static FNDBGCCMD dbgcCmdDumpTypedVal;
67	static FNDBGCCMD dbgcCmdEditMem;
68	static FNDBGCCMD dbgcCmdGo;
69	static FNDBGCCMD dbgcCmdGoUp;
70	static FNDBGCCMD dbgcCmdListModules;
71	static FNDBGCCMD dbgcCmdListNear;
72	static FNDBGCCMD dbgcCmdListSource;
73	static FNDBGCCMD dbgcCmdListSymbols;
74	static FNDBGCCMD dbgcCmdMemoryInfo;
75	static FNDBGCCMD dbgcCmdReg;
76	static FNDBGCCMD dbgcCmdRegGuest;
77	static FNDBGCCMD dbgcCmdRegTerse;
78	static FNDBGCCMD dbgcCmdSearchMem;
79	static FNDBGCCMD dbgcCmdSearchMemType;
80	static FNDBGCCMD dbgcCmdStepTrace;
81	static FNDBGCCMD dbgcCmdStepTraceTo;
82	static FNDBGCCMD dbgcCmdStepTraceToggle;
83	static FNDBGCCMD dbgcCmdEventCtrl;
84	static FNDBGCCMD dbgcCmdEventCtrlList;
85	static FNDBGCCMD dbgcCmdEventCtrlReset;
86	static FNDBGCCMD dbgcCmdStack;
87	static FNDBGCCMD dbgcCmdUnassemble;
88	static FNDBGCCMD dbgcCmdUnassembleCfg;
89	static FNDBGCCMD dbgcCmdTraceFlowClear;
90	static FNDBGCCMD dbgcCmdTraceFlowDisable;
91	static FNDBGCCMD dbgcCmdTraceFlowEnable;
92	static FNDBGCCMD dbgcCmdTraceFlowPrint;
93	static FNDBGCCMD dbgcCmdTraceFlowReset;
94
95
96	/*********************************************************************************************************************************
97	* Global Variables *
98	*********************************************************************************************************************************/
99	/** 'ba' arguments. */
100	static const DBGCVARDESC g_aArgBrkAcc[] =
101	{
102	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
103	{ 1, 1, DBGCVAR_CAT_STRING, 0, "access", "The access type: x=execute, rw=read/write (alias r), w=write, i=not implemented." },
104	{ 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." },
105	{ 1, 1, DBGCVAR_CAT_GC_POINTER, 0, "address", "The address." },
106	{ 0, 1, DBGCVAR_CAT_NUMBER, 0, "passes", "The number of passes before we trigger the breakpoint. (0 is default)" },
107	{ 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)" },
108	{ 0, 1, DBGCVAR_CAT_STRING, 0, "cmds", "String of commands to be executed when the breakpoint is hit. Quote it!" },
109	};
110
111
112	/** 'bc', 'bd', 'be' arguments. */
113	static const DBGCVARDESC g_aArgBrks[] =
114	{
115	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
116	{ 0, ~0U, DBGCVAR_CAT_NUMBER, 0, "#bp", "Breakpoint number." },
117	{ 0, 1, DBGCVAR_CAT_STRING, 0, "all", "All breakpoints." },
118	};
119
120
121	/** 'bp' arguments. */
122	static const DBGCVARDESC g_aArgBrkSet[] =
123	{
124	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
125	{ 1, 1, DBGCVAR_CAT_GC_POINTER, 0, "address", "The address." },
126	{ 0, 1, DBGCVAR_CAT_NUMBER, 0, "passes", "The number of passes before we trigger the breakpoint. (0 is default)" },
127	{ 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)" },
128	{ 0, 1, DBGCVAR_CAT_STRING, 0, "cmds", "String of commands to be executed when the breakpoint is hit. Quote it!" },
129	};
130
131
132	/** 'br' arguments. */
133	static const DBGCVARDESC g_aArgBrkREM[] =
134	{
135	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
136	{ 1, 1, DBGCVAR_CAT_GC_POINTER, 0, "address", "The address." },
137	{ 0, 1, DBGCVAR_CAT_NUMBER, 0, "passes", "The number of passes before we trigger the breakpoint. (0 is default)" },
138	{ 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)" },
139	{ 0, 1, DBGCVAR_CAT_STRING, 0, "cmds", "String of commands to be executed when the breakpoint is hit. Quote it!" },
140	};
141
142
143	/** 'd?' arguments. */
144	static const DBGCVARDESC g_aArgDumpMem[] =
145	{
146	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
147	{ 0, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address where to start dumping memory." },
148	};
149
150
151	/** 'dg', 'dga', 'dl', 'dla' arguments. */
152	static const DBGCVARDESC g_aArgDumpDT[] =
153	{
154	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
155	{ 0, ~0U, DBGCVAR_CAT_NUMBER, 0, "sel", "Selector or selector range." },
156	{ 0, ~0U, DBGCVAR_CAT_POINTER, 0, "address", "Far address which selector should be dumped." },
157	};
158
159
160	/** 'di', 'dia' arguments. */
161	static const DBGCVARDESC g_aArgDumpIDT[] =
162	{
163	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
164	{ 0, ~0U, DBGCVAR_CAT_NUMBER, 0, "int", "The interrupt vector or interrupt vector range." },
165	};
166
167
168	/** 'dpd' arguments. /
169	static const DBGCVARDESC g_aArgDumpPD[] =
170	{
171	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
172	{ 0, 1, DBGCVAR_CAT_NUMBER, 0, "index", "Index into the page directory." },
173	{ 0, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address which page directory entry to start dumping from. Range is applied to the page directory." },
174	};
175
176
177	/** 'dpda' arguments. */
178	static const DBGCVARDESC g_aArgDumpPDAddr[] =
179	{
180	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
181	{ 0, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address of the page directory entry to start dumping from." },
182	};
183
184
185	/** 'dph' arguments. /
186	static const DBGCVARDESC g_aArgDumpPH[] =
187	{
188	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
189	{ 0, 1, DBGCVAR_CAT_GC_POINTER, 0, "address", "Where in the address space to start dumping and for how long (range). The default address/range will be used if omitted." },
190	{ 0, 1, DBGCVAR_CAT_NUMBER, DBGCVD_FLAGS_DEP_PREV, "cr3", "The CR3 value to use. The current CR3 of the context will be used if omitted." },
191	{ 0, 1, DBGCVAR_CAT_STRING, DBGCVD_FLAGS_DEP_PREV, "mode", "The paging mode: legacy, pse, pae, long, ept. Append '-np' for nested paging and '-nx' for no-execute. The current mode will be used if omitted." },
192	};
193
194
195	/** 'dpt?' arguments. */
196	static const DBGCVARDESC g_aArgDumpPT[] =
197	{
198	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
199	{ 1, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address which page directory entry to start dumping from." },
200	};
201
202
203	/** 'dpta' arguments. */
204	static const DBGCVARDESC g_aArgDumpPTAddr[] =
205	{
206	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
207	{ 1, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address of the page table entry to start dumping from." },
208	};
209
210
211	/** 'dt' arguments. */
212	static const DBGCVARDESC g_aArgDumpTSS[] =
213	{
214	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
215	{ 0, 1, DBGCVAR_CAT_NUMBER, 0, "tss", "TSS selector number." },
216	{ 0, 1, DBGCVAR_CAT_POINTER, 0, "tss:ign\|addr", "TSS address. If the selector is a TSS selector, the offset will be ignored." }
217	};
218
219
220	/** 'dti' arguments. */
221	static const DBGCVARDESC g_aArgDumpTypeInfo[] =
222	{
223	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
224	{ 1, 1, DBGCVAR_CAT_STRING, 0, "type", "The type to dump" },
225	{ 0, 1, DBGCVAR_CAT_NUMBER, 0, "levels", "How many levels to dump the type information" }
226	};
227
228
229	/** 'dtv' arguments. */
230	static const DBGCVARDESC g_aArgDumpTypedVal[] =
231	{
232	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
233	{ 1, 1, DBGCVAR_CAT_STRING, 0, "type", "The type to use" },
234	{ 1, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address to start dumping from." },
235	{ 0, 1, DBGCVAR_CAT_NUMBER, 0, "levels", "How many levels to dump" }
236	};
237
238
239	/** 'e?' arguments. */
240	static const DBGCVARDESC g_aArgEditMem[] =
241	{
242	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
243	{ 1, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address where to write." },
244	{ 1, ~0U, DBGCVAR_CAT_NUMBER, 0, "value", "Value to write." },
245	};
246
247
248	/** 'g' arguments. */
249	static const DBGCVARDESC g_aArgGo[] =
250	{
251	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
252	{ 0, 1, DBGCVAR_CAT_NUMBER, 0, "idCpu", "CPU ID." },
253	};
254
255
256	/** 'lm' arguments. */
257	static const DBGCVARDESC g_aArgListMods[] =
258	{
259	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
260	{ 0, ~0U, DBGCVAR_CAT_STRING, 0, "module", "Module name." },
261	};
262
263
264	/** 'ln' arguments. */
265	static const DBGCVARDESC g_aArgListNear[] =
266	{
267	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
268	{ 0, ~0U, DBGCVAR_CAT_POINTER, 0, "address", "Address of the symbol to look up." },
269	{ 0, ~0U, DBGCVAR_CAT_SYMBOL, 0, "symbol", "Symbol to lookup." },
270	};
271
272
273	/** 'ls' arguments. */
274	static const DBGCVARDESC g_aArgListSource[] =
275	{
276	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
277	{ 0, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address where to start looking for source lines." },
278	};
279
280
281	/** 'm' argument. */
282	static const DBGCVARDESC g_aArgMemoryInfo[] =
283	{
284	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
285	{ 1, 1, DBGCVAR_CAT_POINTER, 0, "address", "Pointer to obtain info about." },
286	};
287
288
289	/** 'p', 'pc', 'pt', 't', 'tc' and 'tt' arguments. */
290	static const DBGCVARDESC g_aArgStepTrace[] =
291	{
292	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
293	{ 0, 1, DBGCVAR_CAT_NUMBER, 0, "count", "Number of instructions or source lines to step." },
294	{ 0, 1, DBGCVAR_CAT_STRING, 0, "cmds", "String of commands to be executed afterwards. Quote it!" },
295	};
296
297
298	/** 'pa' and 'ta' arguments. */
299	static const DBGCVARDESC g_aArgStepTraceTo[] =
300	{
301	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
302	{ 1, 1, DBGCVAR_CAT_POINTER, 0, "address", "Where to stop" },
303	{ 0, 1, DBGCVAR_CAT_STRING, 0, "cmds", "String of commands to be executed afterwards. Quote it!" },
304	};
305
306
307	/** 'r' arguments. */
308	static const DBGCVARDESC g_aArgReg[] =
309	{
310	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
311	{ 0, 1, DBGCVAR_CAT_SYMBOL, 0, "register", "Register to show or set." },
312	{ 0, 1, DBGCVAR_CAT_STRING, DBGCVD_FLAGS_DEP_PREV, "=", "Equal sign." },
313	{ 0, 1, DBGCVAR_CAT_NUMBER, DBGCVD_FLAGS_DEP_PREV, "value", "New register value." },
314	};
315
316
317	/** 's' arguments. */
318	static const DBGCVARDESC g_aArgSearchMem[] =
319	{
320	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
321	{ 0, 1, DBGCVAR_CAT_OPTION, 0, "-b", "Byte string." },
322	{ 0, 1, DBGCVAR_CAT_OPTION, 0, "-w", "Word string." },
323	{ 0, 1, DBGCVAR_CAT_OPTION, 0, "-d", "DWord string." },
324	{ 0, 1, DBGCVAR_CAT_OPTION, 0, "-q", "QWord string." },
325	{ 0, 1, DBGCVAR_CAT_OPTION, 0, "-a", "ASCII string." },
326	{ 0, 1, DBGCVAR_CAT_OPTION, 0, "-u", "Unicode string." },
327	{ 0, 1, DBGCVAR_CAT_OPTION_NUMBER, 0, "-n <Hits>", "Maximum number of hits." },
328	{ 0, 1, DBGCVAR_CAT_GC_POINTER, 0, "range", "Register to show or set." },
329	{ 0, ~0U, DBGCVAR_CAT_ANY, 0, "pattern", "Pattern to search for." },
330	};
331
332
333	/** 's?' arguments. */
334	static const DBGCVARDESC g_aArgSearchMemType[] =
335	{
336	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
337	{ 1, 1, DBGCVAR_CAT_GC_POINTER, 0, "range", "Register to show or set." },
338	{ 1, ~0U, DBGCVAR_CAT_ANY, 0, "pattern", "Pattern to search for." },
339	};
340
341
342	/** 'sxe', 'sxn', 'sxi', 'sx-' arguments. */
343	static const DBGCVARDESC g_aArgEventCtrl[] =
344	{
345	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
346	{ 0, 1, DBGCVAR_CAT_STRING, 0, "-c", "The -c option, requires <cmds>." },
347	{ 0, 1, DBGCVAR_CAT_STRING, DBGCVD_FLAGS_DEP_PREV, "cmds", "Command to execute on this event." },
348	{ 0 /weird/, ~0U, DBGCVAR_CAT_STRING, 0, "event", "One or more events, 'all' refering to all events." },
349	};
350
351	/** 'sx' and 'sr' arguments. */
352	static const DBGCVARDESC g_aArgEventCtrlOpt[] =
353	{
354	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
355	{ 0, ~0U, DBGCVAR_CAT_STRING, 0, "event", "Zero or more events, 'all' refering to all events and being the default." },
356	};
357
358	/** 'u' arguments. */
359	static const DBGCVARDESC g_aArgUnassemble[] =
360	{
361	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
362	{ 0, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address where to start disassembling." },
363	};
364
365	/** 'ucfg' arguments. */
366	static const DBGCVARDESC g_aArgUnassembleCfg[] =
367	{
368	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
369	{ 0, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address where to start disassembling." },
370	};
371
372	/** 'x' arguments. */
373	static const DBGCVARDESC g_aArgListSyms[] =
374	{
375	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
376	{ 1, 1, DBGCVAR_CAT_STRING, 0, "symbols", "The symbols to list, format is Module!Symbol with wildcards being supoprted." }
377	};
378
379	/** 'tflowc' arguments. */
380	static const DBGCVARDESC g_aArgTraceFlowClear[] =
381	{
382	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
383	{ 0, ~0U, DBGCVAR_CAT_NUMBER, 0, "#tf", "Trace flow module number." },
384	{ 0, 1, DBGCVAR_CAT_STRING, 0, "all", "All trace flow modules." },
385	};
386
387	/** 'tflowd' arguments. */
388	static const DBGCVARDESC g_aArgTraceFlowDisable[] =
389	{
390	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
391	{ 0, ~0U, DBGCVAR_CAT_NUMBER, 0, "#tf", "Trace flow module number." },
392	{ 0, 1, DBGCVAR_CAT_STRING, 0, "all", "All trace flow modules." },
393	};
394
395	/** 'tflowe' arguments. */
396	static const DBGCVARDESC g_aArgTraceFlowEnable[] =
397	{
398	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
399	{ 0, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address where to start tracing." },
400	{ 0, 1, DBGCVAR_CAT_OPTION_NUMBER, 0, "<Hits>", "Maximum number of hits before the module is disabled." }
401	};
402
403	/** 'tflowp', 'tflowr' arguments. */
404	static const DBGCVARDESC g_aArgTraceFlowPrintReset[] =
405	{
406	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
407	{ 0, ~0U, DBGCVAR_CAT_NUMBER, 0, "#tf", "Trace flow module number." },
408	{ 0, 1, DBGCVAR_CAT_STRING, 0, "all", "All trace flow modules." },
409	};
410
411	/** Command descriptors for the CodeView / WinDbg emulation.
412	* The emulation isn't attempting to be identical, only somewhat similar.
413	*/
414	const DBGCCMD g_aCmdsCodeView[] =
415	{
416	/* pszCmd, cArgsMin, cArgsMax, paArgDescs, cArgDescs, fFlags, pfnHandler pszSyntax, ....pszDescription */
417	{ "ba", 3, 6, &g_aArgBrkAcc[0], RT_ELEMENTS(g_aArgBrkAcc), 0, dbgcCmdBrkAccess, "<access> <size> <address> [passes [max passes]] [cmds]",
418	"Sets a data access breakpoint." },
419	{ "bc", 1, ~0U, &g_aArgBrks[0], RT_ELEMENTS(g_aArgBrks), 0, dbgcCmdBrkClear, "all \| <bp#> [bp# []]", "Deletes a set of breakpoints." },
420	{ "bd", 1, ~0U, &g_aArgBrks[0], RT_ELEMENTS(g_aArgBrks), 0, dbgcCmdBrkDisable, "all \| <bp#> [bp# []]", "Disables a set of breakpoints." },
421	{ "be", 1, ~0U, &g_aArgBrks[0], RT_ELEMENTS(g_aArgBrks), 0, dbgcCmdBrkEnable, "all \| <bp#> [bp# []]", "Enables a set of breakpoints." },
422	{ "bl", 0, 0, NULL, 0, 0, dbgcCmdBrkList, "", "Lists all the breakpoints." },
423	{ "bp", 1, 4, &g_aArgBrkSet[0], RT_ELEMENTS(g_aArgBrkSet), 0, dbgcCmdBrkSet, "<address> [passes [max passes]] [cmds]",
424	"Sets a breakpoint (int 3)." },
425	{ "br", 1, 4, &g_aArgBrkREM[0], RT_ELEMENTS(g_aArgBrkREM), 0, dbgcCmdBrkREM, "<address> [passes [max passes]] [cmds]",
426	"Sets a recompiler specific breakpoint." },
427	{ "d", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), 0, dbgcCmdDumpMem, "[addr]", "Dump memory using last element size and type." },
428	{ "dF", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), 0, dbgcCmdDumpMem, "[addr]", "Dump memory as far 16:16." },
429	{ "dFs", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), 0, dbgcCmdDumpMem, "[addr]", "Dump memory as far 16:16 with near symbols." },
430	{ "da", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), 0, dbgcCmdDumpMem, "[addr]", "Dump memory as ascii string." },
431	{ "db", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), 0, dbgcCmdDumpMem, "[addr]", "Dump memory in bytes." },
432	{ "dd", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), 0, dbgcCmdDumpMem, "[addr]", "Dump memory in double words." },
433	{ "dds", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), 0, dbgcCmdDumpMem, "[addr]", "Dump memory as double words with near symbols." },
434	{ "da", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), 0, dbgcCmdDumpMem, "[addr]", "Dump memory as ascii string." },
435	{ "dg", 0, ~0U, &g_aArgDumpDT[0], RT_ELEMENTS(g_aArgDumpDT), 0, dbgcCmdDumpDT, "[sel [..]]", "Dump the global descriptor table (GDT)." },
436	{ "dga", 0, ~0U, &g_aArgDumpDT[0], RT_ELEMENTS(g_aArgDumpDT), 0, dbgcCmdDumpDT, "[sel [..]]", "Dump the global descriptor table (GDT) including not-present entries." },
437	{ "di", 0, ~0U, &g_aArgDumpIDT[0], RT_ELEMENTS(g_aArgDumpIDT), 0, dbgcCmdDumpIDT, "[int [..]]", "Dump the interrupt descriptor table (IDT)." },
438	{ "dia", 0, ~0U, &g_aArgDumpIDT[0], RT_ELEMENTS(g_aArgDumpIDT), 0, dbgcCmdDumpIDT, "[int [..]]", "Dump the interrupt descriptor table (IDT) including not-present entries." },
439	{ "dl", 0, ~0U, &g_aArgDumpDT[0], RT_ELEMENTS(g_aArgDumpDT), 0, dbgcCmdDumpDT, "[sel [..]]", "Dump the local descriptor table (LDT)." },
440	{ "dla", 0, ~0U, &g_aArgDumpDT[0], RT_ELEMENTS(g_aArgDumpDT), 0, dbgcCmdDumpDT, "[sel [..]]", "Dump the local descriptor table (LDT) including not-present entries." },
441	{ "dpd", 0, 1, &g_aArgDumpPD[0], RT_ELEMENTS(g_aArgDumpPD), 0, dbgcCmdDumpPageDir, "[addr\|index]", "Dumps page directory entries of the default context." },
442	{ "dpda", 0, 1, &g_aArgDumpPDAddr[0],RT_ELEMENTS(g_aArgDumpPDAddr), 0, dbgcCmdDumpPageDir, "[addr]", "Dumps memory at given address as a page directory." },
443	{ "dpdb", 0, 1, &g_aArgDumpPD[0], RT_ELEMENTS(g_aArgDumpPD), 0, dbgcCmdDumpPageDirBoth, "[addr\|index]", "Dumps page directory entries of the guest and the hypervisor. " },
444	{ "dpdg", 0, 1, &g_aArgDumpPD[0], RT_ELEMENTS(g_aArgDumpPD), 0, dbgcCmdDumpPageDir, "[addr\|index]", "Dumps page directory entries of the guest." },
445	{ "dpdh", 0, 1, &g_aArgDumpPD[0], RT_ELEMENTS(g_aArgDumpPD), 0, dbgcCmdDumpPageDir, "[addr\|index]", "Dumps page directory entries of the hypervisor. " },
446	{ "dph", 0, 3, &g_aArgDumpPH[0], RT_ELEMENTS(g_aArgDumpPH), 0, dbgcCmdDumpPageHierarchy, "[addr [cr3 [mode]]", "Dumps the paging hierarchy at for specfied address range. Default context." },
447	{ "dphg", 0, 3, &g_aArgDumpPH[0], RT_ELEMENTS(g_aArgDumpPH), 0, dbgcCmdDumpPageHierarchy, "[addr [cr3 [mode]]", "Dumps the paging hierarchy at for specfied address range. Guest context." },
448	{ "dphh", 0, 3, &g_aArgDumpPH[0], RT_ELEMENTS(g_aArgDumpPH), 0, dbgcCmdDumpPageHierarchy, "[addr [cr3 [mode]]", "Dumps the paging hierarchy at for specfied address range. Hypervisor context." },
449	{ "dp", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), 0, dbgcCmdDumpMem, "[addr]", "Dump memory in mode sized words." },
450	{ "dps", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), 0, dbgcCmdDumpMem, "[addr]", "Dump memory in mode sized words with near symbols." },
451	{ "dpt", 1, 1, &g_aArgDumpPT[0], RT_ELEMENTS(g_aArgDumpPT), 0, dbgcCmdDumpPageTable,"<addr>", "Dumps page table entries of the default context." },
452	{ "dpta", 1, 1, &g_aArgDumpPTAddr[0],RT_ELEMENTS(g_aArgDumpPTAddr), 0, dbgcCmdDumpPageTable,"<addr>", "Dumps memory at given address as a page table." },
453	{ "dptb", 1, 1, &g_aArgDumpPT[0], RT_ELEMENTS(g_aArgDumpPT), 0, dbgcCmdDumpPageTableBoth,"<addr>", "Dumps page table entries of the guest and the hypervisor." },
454	{ "dptg", 1, 1, &g_aArgDumpPT[0], RT_ELEMENTS(g_aArgDumpPT), 0, dbgcCmdDumpPageTable,"<addr>", "Dumps page table entries of the guest." },
455	{ "dpth", 1, 1, &g_aArgDumpPT[0], RT_ELEMENTS(g_aArgDumpPT), 0, dbgcCmdDumpPageTable,"<addr>", "Dumps page table entries of the hypervisor." },
456	{ "dq", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), 0, dbgcCmdDumpMem, "[addr]", "Dump memory in quad words." },
457	{ "dqs", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), 0, dbgcCmdDumpMem, "[addr]", "Dump memory as quad words with near symbols." },
458	{ "dt", 0, 1, &g_aArgDumpTSS[0], RT_ELEMENTS(g_aArgDumpTSS), 0, dbgcCmdDumpTSS, "[tss\|tss:ign\|addr]", "Dump the task state segment (TSS)." },
459	{ "dt16", 0, 1, &g_aArgDumpTSS[0], RT_ELEMENTS(g_aArgDumpTSS), 0, dbgcCmdDumpTSS, "[tss\|tss:ign\|addr]", "Dump the 16-bit task state segment (TSS)." },
460	{ "dt32", 0, 1, &g_aArgDumpTSS[0], RT_ELEMENTS(g_aArgDumpTSS), 0, dbgcCmdDumpTSS, "[tss\|tss:ign\|addr]", "Dump the 32-bit task state segment (TSS)." },
461	{ "dt64", 0, 1, &g_aArgDumpTSS[0], RT_ELEMENTS(g_aArgDumpTSS), 0, dbgcCmdDumpTSS, "[tss\|tss:ign\|addr]", "Dump the 64-bit task state segment (TSS)." },
462	{ "dti", 1, 2, &g_aArgDumpTypeInfo[0],RT_ELEMENTS(g_aArgDumpTypeInfo), 0, dbgcCmdDumpTypeInfo,"<type> [levels]", "Dump type information." },
463	{ "dtv", 2, 3, &g_aArgDumpTypedVal[0],RT_ELEMENTS(g_aArgDumpTypedVal), 0, dbgcCmdDumpTypedVal,"<type> <addr> [levels]", "Dump a memory buffer using the information in the given type." },
464	{ "du", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), 0, dbgcCmdDumpMem, "[addr]", "Dump memory as unicode string (little endian)." },
465	{ "dw", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), 0, dbgcCmdDumpMem, "[addr]", "Dump memory in words." },
466	/** @todo add 'e', 'ea str', 'eza str', 'eu str' and 'ezu str'. See also
467	* dbgcCmdSearchMem and its dbgcVarsToBytes usage. */
468	{ "eb", 2, 2, &g_aArgEditMem[0], RT_ELEMENTS(g_aArgEditMem), 0, dbgcCmdEditMem, "<addr> <value>", "Write a 1-byte value to memory." },
469	{ "ew", 2, 2, &g_aArgEditMem[0], RT_ELEMENTS(g_aArgEditMem), 0, dbgcCmdEditMem, "<addr> <value>", "Write a 2-byte value to memory." },
470	{ "ed", 2, 2, &g_aArgEditMem[0], RT_ELEMENTS(g_aArgEditMem), 0, dbgcCmdEditMem, "<addr> <value>", "Write a 4-byte value to memory." },
471	{ "eq", 2, 2, &g_aArgEditMem[0], RT_ELEMENTS(g_aArgEditMem), 0, dbgcCmdEditMem, "<addr> <value>", "Write a 8-byte value to memory." },
472	{ "g", 0, 1, &g_aArgGo[0], RT_ELEMENTS(g_aArgGo), 0, dbgcCmdGo, "[idCpu]", "Continue execution of all or the specified CPU. (The latter is not recommended unless you know exactly what you're doing.)" },
473	{ "gu", 0, 0, NULL, 0, 0, dbgcCmdGoUp, "", "Go up - continue execution till after return." },
474	{ "k", 0, 0, NULL, 0, 0, dbgcCmdStack, "", "Callstack." },
475	{ "kv", 0, 0, NULL, 0, 0, dbgcCmdStack, "", "Verbose callstack." },
476	{ "kg", 0, 0, NULL, 0, 0, dbgcCmdStack, "", "Callstack - guest." },
477	{ "kgv", 0, 0, NULL, 0, 0, dbgcCmdStack, "", "Verbose callstack - guest." },
478	{ "kh", 0, 0, NULL, 0, 0, dbgcCmdStack, "", "Callstack - hypervisor." },
479	{ "lm", 0, ~0U, &g_aArgListMods[0], RT_ELEMENTS(g_aArgListMods), 0, dbgcCmdListModules, "[module [..]]", "List modules." },
480	{ "lmv", 0, ~0U, &g_aArgListMods[0], RT_ELEMENTS(g_aArgListMods), 0, dbgcCmdListModules, "[module [..]]", "List modules, verbose." },
481	{ "lmo", 0, ~0U, &g_aArgListMods[0], RT_ELEMENTS(g_aArgListMods), 0, dbgcCmdListModules, "[module [..]]", "List modules and their segments." },
482	{ "lmov", 0, ~0U, &g_aArgListMods[0], RT_ELEMENTS(g_aArgListMods), 0, dbgcCmdListModules, "[module [..]]", "List modules and their segments, verbose." },
483	{ "ln", 0, ~0U, &g_aArgListNear[0], RT_ELEMENTS(g_aArgListNear), 0, dbgcCmdListNear, "[addr/sym [..]]", "List symbols near to the address. Default address is CS:EIP." },
484	{ "ls", 0, 1, &g_aArgListSource[0],RT_ELEMENTS(g_aArgListSource), 0, dbgcCmdListSource, "[addr]", "Source." },
485	{ "m", 1, 1, &g_aArgMemoryInfo[0],RT_ELEMENTS(g_aArgMemoryInfo), 0, dbgcCmdMemoryInfo, "<addr>", "Display information about that piece of memory." },
486	{ "p", 0, 2, &g_aArgStepTrace[0], RT_ELEMENTS(g_aArgStepTrace), 0, dbgcCmdStepTrace, "[count] [cmds]", "Step over." },
487	{ "pr", 0, 0, NULL, 0, 0, dbgcCmdStepTraceToggle, "", "Toggle displaying registers for tracing & stepping (no code executed)." },
488	{ "pa", 1, 1, &g_aArgStepTraceTo[0], RT_ELEMENTS(g_aArgStepTraceTo), 0, dbgcCmdStepTraceTo, "<addr> [count] [cmds]","Step to the given address." },
489	{ "pc", 0, 0, &g_aArgStepTrace[0], RT_ELEMENTS(g_aArgStepTrace), 0, dbgcCmdStepTrace, "[count] [cmds]", "Step to the next call instruction." },
490	{ "pt", 0, 0, &g_aArgStepTrace[0], RT_ELEMENTS(g_aArgStepTrace), 0, dbgcCmdStepTrace, "[count] [cmds]", "Step to the next return instruction." },
491	{ "r", 0, 3, &g_aArgReg[0], RT_ELEMENTS(g_aArgReg), 0, dbgcCmdReg, "[reg [[=] newval]]", "Show or set register(s) - active reg set." },
492	{ "rg", 0, 3, &g_aArgReg[0], RT_ELEMENTS(g_aArgReg), 0, dbgcCmdRegGuest, "[reg [[=] newval]]", "Show or set register(s) - guest reg set." },
493	{ "rg32", 0, 0, NULL, 0, 0, dbgcCmdRegGuest, "", "Show 32-bit guest registers." },
494	{ "rg64", 0, 0, NULL, 0, 0, dbgcCmdRegGuest, "", "Show 64-bit guest registers." },
495	{ "rt", 0, 0, NULL, 0, 0, dbgcCmdRegTerse, "", "Toggles terse / verbose register info." },
496	{ "s", 0, ~0U, &g_aArgSearchMem[0], RT_ELEMENTS(g_aArgSearchMem), 0, dbgcCmdSearchMem, "[options] <range> <pattern>", "Continue last search." },
497	{ "sa", 2, ~0U, &g_aArgSearchMemType[0], RT_ELEMENTS(g_aArgSearchMemType),0, dbgcCmdSearchMemType, "<range> <pattern>", "Search memory for an ascii string." },
498	{ "sb", 2, ~0U, &g_aArgSearchMemType[0], RT_ELEMENTS(g_aArgSearchMemType),0, dbgcCmdSearchMemType, "<range> <pattern>", "Search memory for one or more bytes." },
499	{ "sd", 2, ~0U, &g_aArgSearchMemType[0], RT_ELEMENTS(g_aArgSearchMemType),0, dbgcCmdSearchMemType, "<range> <pattern>", "Search memory for one or more double words." },
500	{ "sq", 2, ~0U, &g_aArgSearchMemType[0], RT_ELEMENTS(g_aArgSearchMemType),0, dbgcCmdSearchMemType, "<range> <pattern>", "Search memory for one or more quad words." },
501	{ "su", 2, ~0U, &g_aArgSearchMemType[0], RT_ELEMENTS(g_aArgSearchMemType),0, dbgcCmdSearchMemType, "<range> <pattern>", "Search memory for an unicode string." },
502	{ "sw", 2, ~0U, &g_aArgSearchMemType[0], RT_ELEMENTS(g_aArgSearchMemType),0, dbgcCmdSearchMemType, "<range> <pattern>", "Search memory for one or more words." },
503	{ "sx", 0, ~0U, &g_aArgEventCtrlOpt[0], RT_ELEMENTS(g_aArgEventCtrlOpt), 0, dbgcCmdEventCtrlList, "[<event> [..]]", "Lists settings for exceptions, exits and other events. All if no filter is specified." },
504	{ "sx-", 3, ~0U, &g_aArgEventCtrl[0], RT_ELEMENTS(g_aArgEventCtrl), 0, dbgcCmdEventCtrl, "-c <cmd> <event> [..]", "Modifies the command for one or more exceptions, exits or other event. 'all' addresses all." },
505	{ "sxe", 1, ~0U, &g_aArgEventCtrl[0], RT_ELEMENTS(g_aArgEventCtrl), 0, dbgcCmdEventCtrl, "[-c <cmd>] <event> [..]", "Enable: Break into the debugger on the specified exceptions, exits and other events. 'all' addresses all." },
506	{ "sxn", 1, ~0U, &g_aArgEventCtrl[0], RT_ELEMENTS(g_aArgEventCtrl), 0, dbgcCmdEventCtrl, "[-c <cmd>] <event> [..]", "Notify: Display info in the debugger and continue on the specified exceptions, exits and other events. 'all' addresses all." },
507	{ "sxi", 1, ~0U, &g_aArgEventCtrl[0], RT_ELEMENTS(g_aArgEventCtrl), 0, dbgcCmdEventCtrl, "[-c <cmd>] <event> [..]", "Ignore: Ignore the specified exceptions, exits and other events ('all' = all of them). Without the -c option, the guest runs like normal." },
508	{ "sxr", 0, 0, &g_aArgEventCtrlOpt[0], RT_ELEMENTS(g_aArgEventCtrlOpt), 0, dbgcCmdEventCtrlReset, "", "Reset the settings to default for exceptions, exits and other events. All if no filter is specified." },
509	{ "t", 0, 2, &g_aArgStepTrace[0], RT_ELEMENTS(g_aArgStepTrace), 0, dbgcCmdStepTrace, "[count] [cmds]", "Trace ." },
510	{ "tflowc", 1, ~0U, &g_aArgTraceFlowClear[0], RT_ELEMENTS(g_aArgTraceFlowClear), 0, dbgcCmdTraceFlowClear, "all \| <tf#> [tf# []]", "Clears trace execution flow for the given method." },
511	{ "tflowd", 0, 1, &g_aArgTraceFlowDisable[0], RT_ELEMENTS(g_aArgTraceFlowDisable), 0, dbgcCmdTraceFlowDisable, "all \| <tf#> [tf# []]", "Disables trace execution flow for the given method." },
512	{ "tflowe", 0, 2, &g_aArgTraceFlowEnable[0], RT_ELEMENTS(g_aArgTraceFlowEnable), 0, dbgcCmdTraceFlowEnable, "<addr> <hits>", "Enable trace execution flow of the given method." },
513	{ "tflowp", 0, 1, &g_aArgTraceFlowPrintReset[0], RT_ELEMENTS(g_aArgTraceFlowPrintReset), 0, dbgcCmdTraceFlowPrint, "all \| <tf#> [tf# []]", "Prints the collected trace data of the given method." },
514	{ "tflowr", 0, 1, &g_aArgTraceFlowPrintReset[0], RT_ELEMENTS(g_aArgTraceFlowPrintReset), 0, dbgcCmdTraceFlowReset, "all \| <tf#> [tf# []]", "Resets the collected trace data of the given trace flow module." },
515	{ "tr", 0, 0, NULL, 0, 0, dbgcCmdStepTraceToggle, "", "Toggle displaying registers for tracing & stepping (no code executed)." },
516	{ "ta", 1, 1, &g_aArgStepTraceTo[0], RT_ELEMENTS(g_aArgStepTraceTo), 0, dbgcCmdStepTraceTo, "<addr> [count] [cmds]","Trace to the given address." },
517	{ "tc", 0, 0, &g_aArgStepTrace[0], RT_ELEMENTS(g_aArgStepTrace), 0, dbgcCmdStepTrace, "[count] [cmds]", "Trace to the next call instruction." },
518	{ "tt", 0, 0, &g_aArgStepTrace[0], RT_ELEMENTS(g_aArgStepTrace), 0, dbgcCmdStepTrace, "[count] [cmds]", "Trace to the next return instruction." },
519	{ "u", 0, 1, &g_aArgUnassemble[0],RT_ELEMENTS(g_aArgUnassemble), 0, dbgcCmdUnassemble, "[addr]", "Unassemble." },
520	{ "u64", 0, 1, &g_aArgUnassemble[0],RT_ELEMENTS(g_aArgUnassemble), 0, dbgcCmdUnassemble, "[addr]", "Unassemble 64-bit code." },
521	{ "u32", 0, 1, &g_aArgUnassemble[0],RT_ELEMENTS(g_aArgUnassemble), 0, dbgcCmdUnassemble, "[addr]", "Unassemble 32-bit code." },
522	{ "u16", 0, 1, &g_aArgUnassemble[0],RT_ELEMENTS(g_aArgUnassemble), 0, dbgcCmdUnassemble, "[addr]", "Unassemble 16-bit code." },
523	{ "uv86", 0, 1, &g_aArgUnassemble[0],RT_ELEMENTS(g_aArgUnassemble), 0, dbgcCmdUnassemble, "[addr]", "Unassemble 16-bit code with v8086/real mode addressing." },
524	{ "ucfg", 0, 1, &g_aArgUnassembleCfg[0], RT_ELEMENTS(g_aArgUnassembleCfg), 0, dbgcCmdUnassembleCfg, "[addr]", "Unassemble creating a control flow graph." },
525	{ "ucfgc", 0, 1, &g_aArgUnassembleCfg[0], RT_ELEMENTS(g_aArgUnassembleCfg), 0, dbgcCmdUnassembleCfg, "[addr]", "Unassemble creating a control flow graph with colors." },
526	{ "x", 1, 1, &g_aArgListSyms[0], RT_ELEMENTS(g_aArgListSyms), 0, dbgcCmdListSymbols, "* \| <Module!Symbol>", "Examine symbols." },
527	};
528
529	/** The number of commands in the CodeView/WinDbg emulation. */
530	const uint32_t g_cCmdsCodeView = RT_ELEMENTS(g_aCmdsCodeView);
531
532
533	/**
534	* Selectable debug event descriptors.
535	*
536	* @remarks Sorted by DBGCSXEVT::enmType value.
537	*/
538	const DBGCSXEVT g_aDbgcSxEvents[] =
539	{
540	{ DBGFEVENT_INTERRUPT_HARDWARE, "hwint", NULL, kDbgcSxEventKind_Interrupt, kDbgcEvtState_Disabled, 0, "Hardware interrupt" },
541	{ DBGFEVENT_INTERRUPT_SOFTWARE, "swint", NULL, kDbgcSxEventKind_Interrupt, kDbgcEvtState_Disabled, 0, "Software interrupt" },
542	{ DBGFEVENT_TRIPLE_FAULT, "triplefault", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Enabled, 0, "Triple fault "},
543	{ DBGFEVENT_XCPT_DE, "xcpt_de", "de", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, "#DE (integer divide error)" },
544	{ DBGFEVENT_XCPT_DB, "xcpt_db", "db", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, "#DB (debug)" },
545	{ DBGFEVENT_XCPT_02, "xcpt_02", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
546	{ DBGFEVENT_XCPT_BP, "xcpt_bp", "bp", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, "#BP (breakpoint)" },
547	{ DBGFEVENT_XCPT_OF, "xcpt_of", "of", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, "#OF (overflow (INTO))" },
548	{ DBGFEVENT_XCPT_BR, "xcpt_br", "br", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, "#BR (bound range exceeded)" },
549	{ DBGFEVENT_XCPT_UD, "xcpt_ud", "ud", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, "#UD (undefined opcode)" },
550	{ DBGFEVENT_XCPT_NM, "xcpt_nm", "nm", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, "#NM (FPU not available)" },
551	{ DBGFEVENT_XCPT_DF, "xcpt_df", "df", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, "#DF (double fault)" },
552	{ DBGFEVENT_XCPT_09, "xcpt_09", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, "Coprocessor segment overrun" },
553	{ DBGFEVENT_XCPT_TS, "xcpt_ts", "ts", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, DBGCSXEVT_F_TAKE_ARG, "#TS (task switch)" },
554	{ DBGFEVENT_XCPT_NP, "xcpt_np", "np", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, DBGCSXEVT_F_TAKE_ARG, "#NP (segment not present)" },
555	{ DBGFEVENT_XCPT_SS, "xcpt_ss", "ss", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, DBGCSXEVT_F_TAKE_ARG, "#SS (stack segment fault)" },
556	{ DBGFEVENT_XCPT_GP, "xcpt_gp", "gp", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, DBGCSXEVT_F_TAKE_ARG, "#GP (general protection fault)" },
557	{ DBGFEVENT_XCPT_PF, "xcpt_pf", "pf", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, DBGCSXEVT_F_TAKE_ARG, "#PF (page fault)" },
558	{ DBGFEVENT_XCPT_0f, "xcpt_0f", "xcpt0f", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
559	{ DBGFEVENT_XCPT_MF, "xcpt_mf", "mf", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, "#MF (math fault)" },
560	{ DBGFEVENT_XCPT_AC, "xcpt_ac", "ac", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, "#AC (alignment check)" },
561	{ DBGFEVENT_XCPT_MC, "xcpt_mc", "mc", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, "#MC (machine check)" },
562	{ DBGFEVENT_XCPT_XF, "xcpt_xf", "xf", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, "#XF (SIMD floating-point exception)" },
563	{ DBGFEVENT_XCPT_VE, "xcpt_vd", "ve", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, "#VE (virtualization exception)" },
564	{ DBGFEVENT_XCPT_15, "xcpt_15", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
565	{ DBGFEVENT_XCPT_16, "xcpt_16", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
566	{ DBGFEVENT_XCPT_17, "xcpt_17", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
567	{ DBGFEVENT_XCPT_18, "xcpt_18", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
568	{ DBGFEVENT_XCPT_19, "xcpt_19", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
569	{ DBGFEVENT_XCPT_1a, "xcpt_1a", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
570	{ DBGFEVENT_XCPT_1b, "xcpt_1b", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
571	{ DBGFEVENT_XCPT_1c, "xcpt_1c", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
572	{ DBGFEVENT_XCPT_1d, "xcpt_1d", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
573	{ DBGFEVENT_XCPT_SX, "xcpt_sx", "sx", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, DBGCSXEVT_F_TAKE_ARG, "#SX (security exception)" },
574	{ DBGFEVENT_XCPT_1f, "xcpt_1f", "xcpt1f", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
575	{ DBGFEVENT_INSTR_HALT, "instr_halt", "hlt", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
576	{ DBGFEVENT_INSTR_MWAIT, "instr_mwait", "mwait", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
577	{ DBGFEVENT_INSTR_MONITOR, "instr_monitor", "monitor", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
578	{ DBGFEVENT_INSTR_CPUID, "instr_cpuid", "cpuid", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
579	{ DBGFEVENT_INSTR_INVD, "instr_invd", "invd", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
580	{ DBGFEVENT_INSTR_WBINVD, "instr_wbinvd", "wbinvd", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
581	{ DBGFEVENT_INSTR_INVLPG, "instr_invlpg", "invlpg", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
582	{ DBGFEVENT_INSTR_RDTSC, "instr_rdtsc", "rdtsc", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
583	{ DBGFEVENT_INSTR_RDTSCP, "instr_rdtscp", "rdtscp", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
584	{ DBGFEVENT_INSTR_RDPMC, "instr_rdpmc", "rdpmc", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
585	{ DBGFEVENT_INSTR_RDMSR, "instr_rdmsr", "rdmsr", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
586	{ DBGFEVENT_INSTR_WRMSR, "instr_wrmsr", "wrmsr", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
587	{ DBGFEVENT_INSTR_CRX_READ, "instr_crx_read", "crx_read", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, DBGCSXEVT_F_TAKE_ARG, NULL },
588	{ DBGFEVENT_INSTR_CRX_WRITE, "instr_crx_write", "crx_write",kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, DBGCSXEVT_F_TAKE_ARG, NULL },
589	{ DBGFEVENT_INSTR_DRX_READ, "instr_drx_read", "drx_read", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, DBGCSXEVT_F_TAKE_ARG, NULL },
590	{ DBGFEVENT_INSTR_DRX_WRITE, "instr_drx_write", "drx_write",kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, DBGCSXEVT_F_TAKE_ARG, NULL },
591	{ DBGFEVENT_INSTR_PAUSE, "instr_pause", "pause", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
592	{ DBGFEVENT_INSTR_XSETBV, "instr_xsetbv", "xsetbv", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
593	{ DBGFEVENT_INSTR_SIDT, "instr_sidt", "sidt", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
594	{ DBGFEVENT_INSTR_LIDT, "instr_lidt", "lidt", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
595	{ DBGFEVENT_INSTR_SGDT, "instr_sgdt", "sgdt", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
596	{ DBGFEVENT_INSTR_LGDT, "instr_lgdt", "lgdt", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
597	{ DBGFEVENT_INSTR_SLDT, "instr_sldt", "sldt", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
598	{ DBGFEVENT_INSTR_LLDT, "instr_lldt", "lldt", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
599	{ DBGFEVENT_INSTR_STR, "instr_str", "str", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
600	{ DBGFEVENT_INSTR_LTR, "instr_ltr", "ltr", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
601	{ DBGFEVENT_INSTR_GETSEC, "instr_getsec", "getsec", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
602	{ DBGFEVENT_INSTR_RSM, "instr_rsm", "rsm", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
603	{ DBGFEVENT_INSTR_RDRAND, "instr_rdrand", "rdrand", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
604	{ DBGFEVENT_INSTR_RDSEED, "instr_rdseed", "rdseed", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
605	{ DBGFEVENT_INSTR_XSAVES, "instr_xsaves", "xsaves", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
606	{ DBGFEVENT_INSTR_XRSTORS, "instr_xrstors", "xrstors", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
607	{ DBGFEVENT_INSTR_VMM_CALL, "instr_vmm_call", "vmm_call", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
608	{ DBGFEVENT_INSTR_VMX_VMCLEAR, "instr_vmx_vmclear", "vmclear", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
609	{ DBGFEVENT_INSTR_VMX_VMLAUNCH, "instr_vmx_vmlaunch", "vmlaunch", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
610	{ DBGFEVENT_INSTR_VMX_VMPTRLD, "instr_vmx_vmptrld", "vmptrld", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
611	{ DBGFEVENT_INSTR_VMX_VMPTRST, "instr_vmx_vmptrst", "vmptrst", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
612	{ DBGFEVENT_INSTR_VMX_VMREAD, "instr_vmx_vmread", "vmread", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
613	{ DBGFEVENT_INSTR_VMX_VMRESUME, "instr_vmx_vmresume", "vmresume", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
614	{ DBGFEVENT_INSTR_VMX_VMWRITE, "instr_vmx_vmwrite", "vmwrite", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
615	{ DBGFEVENT_INSTR_VMX_VMXOFF, "instr_vmx_vmxoff", "vmxoff", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
616	{ DBGFEVENT_INSTR_VMX_VMXON, "instr_vmx_vmxon", "vmxon", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
617	{ DBGFEVENT_INSTR_VMX_VMFUNC, "instr_vmx_vmfunc", "vmfunc", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
618	{ DBGFEVENT_INSTR_VMX_INVEPT, "instr_vmx_invept", "invept", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
619	{ DBGFEVENT_INSTR_VMX_INVVPID, "instr_vmx_invvpid", "invvpid", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
620	{ DBGFEVENT_INSTR_VMX_INVPCID, "instr_vmx_invpcid", "invpcid", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
621	{ DBGFEVENT_INSTR_SVM_VMRUN, "instr_svm_vmrun", "vmrun", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
622	{ DBGFEVENT_INSTR_SVM_VMLOAD, "instr_svm_vmload", "vmload", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
623	{ DBGFEVENT_INSTR_SVM_VMSAVE, "instr_svm_vmsave", "vmsave", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
624	{ DBGFEVENT_INSTR_SVM_STGI, "instr_svm_stgi", "stgi", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
625	{ DBGFEVENT_INSTR_SVM_CLGI, "instr_svm_clgi", "clgi", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
626	{ DBGFEVENT_EXIT_TASK_SWITCH, "exit_task_switch", "task_switch", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
627	{ DBGFEVENT_EXIT_HALT, "exit_halt", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
628	{ DBGFEVENT_EXIT_MWAIT, "exit_mwait", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
629	{ DBGFEVENT_EXIT_MONITOR, "exit_monitor", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
630	{ DBGFEVENT_EXIT_CPUID, "exit_cpuid", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
631	{ DBGFEVENT_EXIT_INVD, "exit_invd", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
632	{ DBGFEVENT_EXIT_WBINVD, "exit_wbinvd", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
633	{ DBGFEVENT_EXIT_INVLPG, "exit_invlpg", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
634	{ DBGFEVENT_EXIT_RDTSC, "exit_rdtsc", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
635	{ DBGFEVENT_EXIT_RDTSCP, "exit_rdtscp", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
636	{ DBGFEVENT_EXIT_RDPMC, "exit_rdpmc", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
637	{ DBGFEVENT_EXIT_RDMSR, "exit_rdmsr", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
638	{ DBGFEVENT_EXIT_WRMSR, "exit_wrmsr", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
639	{ DBGFEVENT_EXIT_CRX_READ, "exit_crx_read", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
640	{ DBGFEVENT_EXIT_CRX_WRITE, "exit_crx_write", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
641	{ DBGFEVENT_EXIT_DRX_READ, "exit_drx_read", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
642	{ DBGFEVENT_EXIT_DRX_WRITE, "exit_drx_write", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
643	{ DBGFEVENT_EXIT_PAUSE, "exit_pause", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
644	{ DBGFEVENT_EXIT_XSETBV, "exit_xsetbv", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
645	{ DBGFEVENT_EXIT_SIDT, "exit_sidt", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
646	{ DBGFEVENT_EXIT_LIDT, "exit_lidt", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
647	{ DBGFEVENT_EXIT_SGDT, "exit_sgdt", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
648	{ DBGFEVENT_EXIT_LGDT, "exit_lgdt", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
649	{ DBGFEVENT_EXIT_SLDT, "exit_sldt", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
650	{ DBGFEVENT_EXIT_LLDT, "exit_lldt", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
651	{ DBGFEVENT_EXIT_STR, "exit_str", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
652	{ DBGFEVENT_EXIT_LTR, "exit_ltr", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
653	{ DBGFEVENT_EXIT_GETSEC, "exit_getsec", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
654	{ DBGFEVENT_EXIT_RSM, "exit_rsm", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
655	{ DBGFEVENT_EXIT_RDRAND, "exit_rdrand", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
656	{ DBGFEVENT_EXIT_RDSEED, "exit_rdseed", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
657	{ DBGFEVENT_EXIT_XSAVES, "exit_xsaves", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
658	{ DBGFEVENT_EXIT_XRSTORS, "exit_xrstors", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
659	{ DBGFEVENT_EXIT_VMM_CALL, "exit_vmm_call", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
660	{ DBGFEVENT_EXIT_VMX_VMCLEAR, "exit_vmx_vmclear", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
661	{ DBGFEVENT_EXIT_VMX_VMLAUNCH, "exit_vmx_vmlaunch", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
662	{ DBGFEVENT_EXIT_VMX_VMPTRLD, "exit_vmx_vmptrld", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
663	{ DBGFEVENT_EXIT_VMX_VMPTRST, "exit_vmx_vmptrst", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
664	{ DBGFEVENT_EXIT_VMX_VMREAD, "exit_vmx_vmread", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
665	{ DBGFEVENT_EXIT_VMX_VMRESUME, "exit_vmx_vmresume", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
666	{ DBGFEVENT_EXIT_VMX_VMWRITE, "exit_vmx_vmwrite", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
667	{ DBGFEVENT_EXIT_VMX_VMXOFF, "exit_vmx_vmxoff", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
668	{ DBGFEVENT_EXIT_VMX_VMXON, "exit_vmx_vmxon", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
669	{ DBGFEVENT_EXIT_VMX_VMFUNC, "exit_vmx_vmfunc", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
670	{ DBGFEVENT_EXIT_VMX_INVEPT, "exit_vmx_invept", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
671	{ DBGFEVENT_EXIT_VMX_INVVPID, "exit_vmx_invvpid", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
672	{ DBGFEVENT_EXIT_VMX_INVPCID, "exit_vmx_invpcid", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
673	{ DBGFEVENT_EXIT_VMX_EPT_VIOLATION, "exit_vmx_ept_violation", "eptvio", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
674	{ DBGFEVENT_EXIT_VMX_EPT_MISCONFIG, "exit_vmx_ept_misconfig", "eptmis", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
675	{ DBGFEVENT_EXIT_VMX_VAPIC_ACCESS, "exit_vmx_vapic_access", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
676	{ DBGFEVENT_EXIT_VMX_VAPIC_WRITE, "exit_vmx_vapic_write", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
677	{ DBGFEVENT_EXIT_SVM_VMRUN, "exit_svm_vmrun", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
678	{ DBGFEVENT_EXIT_SVM_VMLOAD, "exit_svm_vmload", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
679	{ DBGFEVENT_EXIT_SVM_VMSAVE, "exit_svm_vmsave", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
680	{ DBGFEVENT_EXIT_SVM_STGI, "exit_svm_stgi", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
681	{ DBGFEVENT_EXIT_SVM_CLGI, "exit_svm_clgi", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
682	{ DBGFEVENT_VMX_SPLIT_LOCK, "vmx_split_lock", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
683	{ DBGFEVENT_IOPORT_UNASSIGNED, "pio_unassigned", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
684	{ DBGFEVENT_IOPORT_UNUSED, "pio_unused", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
685	{ DBGFEVENT_MEMORY_UNASSIGNED, "mmio_unassigned", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
686	{ DBGFEVENT_MEMORY_ROM_WRITE, "rom_write", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
687	{ DBGFEVENT_BSOD_MSR, "bsod_msr", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, DBGCSXEVT_F_BUGCHECK, NULL },
688	{ DBGFEVENT_BSOD_EFI, "bsod_efi", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, DBGCSXEVT_F_BUGCHECK, NULL },
689	{ DBGFEVENT_BSOD_VMMDEV, "bsod_vmmdev", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, DBGCSXEVT_F_BUGCHECK, NULL },
690	};
691	/** Number of entries in g_aDbgcSxEvents. */
692	const uint32_t g_cDbgcSxEvents = RT_ELEMENTS(g_aDbgcSxEvents);
693
694
695
696	/**
697	* @callback_method_impl{FNDBGCCMD, The 'g' command.}
698	*/
699	static DECLCALLBACK(int) dbgcCmdGo(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
700	{
701	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
702
703	/*
704	* Parse arguments.
705	*/
706	VMCPUID idCpu = VMCPUID_ALL;
707	if (cArgs == 1)
708	{
709	VMCPUID cCpus = DBGFR3CpuGetCount(pUVM);
710	if (paArgs[0].u.u64Number >= cCpus)
711	return DBGCCmdHlpFail(pCmdHlp, pCmd, "idCpu %RU64 is out of range! Highest valid ID is %u.\n",
712	paArgs[0].u.u64Number, cCpus - 1);
713	idCpu = (VMCPUID)paArgs[0].u.u64Number;
714	}
715	else
716	Assert(cArgs == 0);
717
718	/*
719	* Try resume the VM or CPU.
720	*/
721	int rc = DBGFR3Resume(pUVM, idCpu);
722	if (RT_SUCCESS(rc))
723	{
724	Assert(rc == VINF_SUCCESS \|\| rc == VWRN_DBGF_ALREADY_RUNNING);
725	if (rc != VWRN_DBGF_ALREADY_RUNNING)
726	return VINF_SUCCESS;
727	if (idCpu == VMCPUID_ALL)
728	return DBGCCmdHlpFail(pCmdHlp, pCmd, "The VM is already running");
729	return DBGCCmdHlpFail(pCmdHlp, pCmd, "CPU %u is already running", idCpu);
730	}
731	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGFR3Resume");
732	}
733
734
735	/**
736	* @callback_method_impl{FNDBGCCMD, The 'gu' command.}
737	*/
738	static DECLCALLBACK(int) dbgcCmdGoUp(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
739	{
740	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
741	RT_NOREF(pCmd, paArgs, cArgs);
742
743	/* The simple way out. */
744	PDBGFADDRESS pStackPop = NULL; /** @todo try set up some stack limitations */
745	RTGCPTR cbStackPop = 0;
746	int rc = DBGFR3StepEx(pUVM, pDbgc->idCpu, DBGF_STEP_F_OVER \| DBGF_STEP_F_STOP_AFTER_RET, NULL, pStackPop, cbStackPop, _512K);
747	if (RT_SUCCESS(rc))
748	pDbgc->fReady = false;
749	else
750	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGFR3StepEx(,,DBGF_STEP_F_OVER \| DBGF_STEP_F_STOP_AFTER_RET,) failed");
751	return rc;
752	}
753
754
755	/**
756	* @callback_method_impl{FNDBGCCMD, The 'ba' command.}
757	*/
758	static DECLCALLBACK(int) dbgcCmdBrkAccess(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
759	{
760	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
761
762	/*
763	* Interpret access type.
764	*/
765	if ( !strchr("xrwi", paArgs[0].u.pszString[0])
766	\|\| paArgs[0].u.pszString[1])
767	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Invalid access type '%s' for '%s'. Valid types are 'e', 'r', 'w' and 'i'",
768	paArgs[0].u.pszString, pCmd->pszCmd);
769	uint8_t fType = 0;
770	switch (paArgs[0].u.pszString[0])
771	{
772	case 'x': fType = X86_DR7_RW_EO; break;
773	case 'r': fType = X86_DR7_RW_RW; break;
774	case 'w': fType = X86_DR7_RW_WO; break;
775	case 'i': fType = X86_DR7_RW_IO; break;
776	}
777
778	/*
779	* Validate size.
780	*/
781	if (fType == X86_DR7_RW_EO && paArgs[1].u.u64Number != 1)
782	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Invalid access size %RX64 for '%s'. 'x' access type requires size 1!",
783	paArgs[1].u.u64Number, pCmd->pszCmd);
784	switch (paArgs[1].u.u64Number)
785	{
786	case 1:
787	case 2:
788	case 4:
789	break;
790	/case 8: - later/
791	default:
792	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Invalid access size %RX64 for '%s'. 1, 2 or 4!",
793	paArgs[1].u.u64Number, pCmd->pszCmd);
794	}
795	uint8_t cb = (uint8_t)paArgs[1].u.u64Number;
796
797	/*
798	* Convert the pointer to a DBGF address.
799	*/
800	DBGFADDRESS Address;
801	int rc = DBGCCmdHlpVarToDbgfAddr(pCmdHlp, &paArgs[2], &Address);
802	if (RT_FAILURE(rc))
803	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGCCmdHlpVarToDbgfAddr(,%DV,)", &paArgs[2]);
804
805	/*
806	* Pick out the optional arguments.
807	*/
808	uint64_t iHitTrigger = 0;
809	uint64_t iHitDisable = UINT64_MAX;
810	const char *pszCmds = NULL;
811	unsigned iArg = 3;
812	if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_NUMBER)
813	{
814	iHitTrigger = paArgs[iArg].u.u64Number;
815	iArg++;
816	if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_NUMBER)
817	{
818	iHitDisable = paArgs[iArg].u.u64Number;
819	iArg++;
820	}
821	}
822	if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_STRING)
823	{
824	pszCmds = paArgs[iArg].u.pszString;
825	iArg++;
826	}
827
828	/*
829	* Try set the breakpoint.
830	*/
831	uint32_t iBp;
832	rc = DBGFR3BpSetReg(pUVM, &Address, iHitTrigger, iHitDisable, fType, cb, &iBp);
833	if (RT_SUCCESS(rc))
834	{
835	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
836	rc = dbgcBpAdd(pDbgc, iBp, pszCmds);
837	if (RT_SUCCESS(rc))
838	return DBGCCmdHlpPrintf(pCmdHlp, "Set access breakpoint %u at %RGv\n", iBp, Address.FlatPtr);
839	if (rc == VERR_DBGC_BP_EXISTS)
840	{
841	rc = dbgcBpUpdate(pDbgc, iBp, pszCmds);
842	if (RT_SUCCESS(rc))
843	return DBGCCmdHlpPrintf(pCmdHlp, "Updated access breakpoint %u at %RGv\n", iBp, Address.FlatPtr);
844	}
845	int rc2 = DBGFR3BpClear(pDbgc->pUVM, iBp);
846	AssertRC(rc2);
847	}
848	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "Failed to set access breakpoint at %RGv", Address.FlatPtr);
849	}
850
851
852	/**
853	* @callback_method_impl{FNDBGCCMD, The 'bc' command.}
854	*/
855	static DECLCALLBACK(int) dbgcCmdBrkClear(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
856	{
857	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
858
859	/*
860	* Enumerate the arguments.
861	*/
862	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
863	int rc = VINF_SUCCESS;
864	for (unsigned iArg = 0; iArg < cArgs && RT_SUCCESS(rc); iArg++)
865	{
866	if (paArgs[iArg].enmType != DBGCVAR_TYPE_STRING)
867	{
868	/* one */
869	uint32_t iBp = (uint32_t)paArgs[iArg].u.u64Number;
870	if (iBp == paArgs[iArg].u.u64Number)
871	{
872	int rc2 = DBGFR3BpClear(pUVM, iBp);
873	if (RT_FAILURE(rc2))
874	rc = DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc2, "DBGFR3BpClear(,%#x)", iBp);
875	if (RT_SUCCESS(rc2) \|\| rc2 == VERR_DBGF_BP_NOT_FOUND)
876	dbgcBpDelete(pDbgc, iBp);
877	}
878	else
879	rc = DBGCCmdHlpFail(pCmdHlp, pCmd, "Breakpoint id %RX64 is too large", paArgs[iArg].u.u64Number);
880	}
881	else if (!strcmp(paArgs[iArg].u.pszString, "all"))
882	{
883	/* all */
884	PDBGCBP pBp = pDbgc->pFirstBp;
885	while (pBp)
886	{
887	uint32_t iBp = pBp->iBp;
888	pBp = pBp->pNext;
889
890	int rc2 = DBGFR3BpClear(pUVM, iBp);
891	if (RT_FAILURE(rc2))
892	rc = DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc2, "DBGFR3BpClear(,%#x)", iBp);
893	if (RT_SUCCESS(rc2) \|\| rc2 == VERR_DBGF_BP_NOT_FOUND)
894	dbgcBpDelete(pDbgc, iBp);
895	}
896	}
897	else
898	rc = DBGCCmdHlpFail(pCmdHlp, pCmd, "Invalid argument '%s'", paArgs[iArg].u.pszString);
899	}
900	return rc;
901	}
902
903
904	/**
905	* @callback_method_impl{FNDBGCCMD, The 'bd' command.}
906	*/
907	static DECLCALLBACK(int) dbgcCmdBrkDisable(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
908	{
909	/*
910	* Enumerate the arguments.
911	*/
912	int rc = VINF_SUCCESS;
913	for (unsigned iArg = 0; iArg < cArgs && RT_SUCCESS(rc); iArg++)
914	{
915	if (paArgs[iArg].enmType != DBGCVAR_TYPE_STRING)
916	{
917	/* one */
918	uint32_t iBp = (uint32_t)paArgs[iArg].u.u64Number;
919	if (iBp == paArgs[iArg].u.u64Number)
920	{
921	rc = DBGFR3BpDisable(pUVM, iBp);
922	if (RT_FAILURE(rc))
923	rc = DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGFR3BpDisable failed for breakpoint %#x", iBp);
924	}
925	else
926	rc = DBGCCmdHlpFail(pCmdHlp, pCmd, "Breakpoint id %RX64 is too large", paArgs[iArg].u.u64Number);
927	}
928	else if (!strcmp(paArgs[iArg].u.pszString, "all"))
929	{
930	/* all */
931	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
932	for (PDBGCBP pBp = pDbgc->pFirstBp; pBp; pBp = pBp->pNext)
933	{
934	int rc2 = DBGFR3BpDisable(pUVM, pBp->iBp);
935	if (RT_FAILURE(rc2))
936	rc = DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc2, "DBGFR3BpDisable failed for breakpoint %#x", pBp->iBp);
937	}
938	}
939	else
940	rc = DBGCCmdHlpFail(pCmdHlp, pCmd, "Invalid argument '%s'", paArgs[iArg].u.pszString);
941	}
942	return rc;
943	}
944
945
946	/**
947	* @callback_method_impl{FNDBGCCMD, The 'be' command.}
948	*/
949	static DECLCALLBACK(int) dbgcCmdBrkEnable(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
950	{
951	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
952
953	/*
954	* Enumerate the arguments.
955	*/
956	int rc = VINF_SUCCESS;
957	for (unsigned iArg = 0; iArg < cArgs && RT_SUCCESS(rc); iArg++)
958	{
959	if (paArgs[iArg].enmType != DBGCVAR_TYPE_STRING)
960	{
961	/* one */
962	uint32_t iBp = (uint32_t)paArgs[iArg].u.u64Number;
963	if (iBp == paArgs[iArg].u.u64Number)
964	{
965	rc = DBGFR3BpEnable(pUVM, iBp);
966	if (RT_FAILURE(rc))
967	rc = DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGFR3BpEnable failed for breakpoint %#x", iBp);
968	}
969	else
970	rc = DBGCCmdHlpFail(pCmdHlp, pCmd, "Breakpoint id %RX64 is too large", paArgs[iArg].u.u64Number);
971	}
972	else if (!strcmp(paArgs[iArg].u.pszString, "all"))
973	{
974	/* all */
975	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
976	for (PDBGCBP pBp = pDbgc->pFirstBp; pBp; pBp = pBp->pNext)
977	{
978	int rc2 = DBGFR3BpEnable(pUVM, pBp->iBp);
979	if (RT_FAILURE(rc2))
980	rc = DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc2, "DBGFR3BpEnable failed for breakpoint %#x", pBp->iBp);
981	}
982	}
983	else
984	rc = DBGCCmdHlpFail(pCmdHlp, pCmd, "Invalid argument '%s'", paArgs[iArg].u.pszString);
985	}
986	return rc;
987	}
988
989
990	/**
991	* Breakpoint enumeration callback function.
992	*
993	* @returns VBox status code. Any failure will stop the enumeration.
994	* @param pUVM The user mode VM handle.
995	* @param pvUser The user argument.
996	* @param hBp The DBGF breakpoint handle.
997	* @param pBp Pointer to the breakpoint information. (readonly)
998	*/
999	static DECLCALLBACK(int) dbgcEnumBreakpointsCallback(PUVM pUVM, void *pvUser, DBGFBP hBp, PCDBGFBPPUB pBp)
1000	{
1001	PDBGC pDbgc = (PDBGC)pvUser;
1002	PDBGCBP pDbgcBp = dbgcBpGet(pDbgc, hBp);
1003
1004	/*
1005	* BP type and size.
1006	*/
1007	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "%#4x %c ", hBp, DBGF_BP_PUB_IS_ENABLED(pBp) ? 'e' : 'd');
1008	bool fHasAddress = false;
1009	switch (DBGF_BP_PUB_GET_TYPE(pBp))
1010	{
1011	case DBGFBPTYPE_INT3:
1012	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, " p %RGv", pBp->u.Int3.GCPtr);
1013	fHasAddress = true;
1014	break;
1015	case DBGFBPTYPE_REG:
1016	{
1017	char chType;
1018	switch (pBp->u.Reg.fType)
1019	{
1020	case X86_DR7_RW_EO: chType = 'x'; break;
1021	case X86_DR7_RW_WO: chType = 'w'; break;
1022	case X86_DR7_RW_IO: chType = 'i'; break;
1023	case X86_DR7_RW_RW: chType = 'r'; break;
1024	default: chType = '?'; break;
1025
1026	}
1027	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "%d %c %RGv", pBp->u.Reg.cb, chType, pBp->u.Reg.GCPtr);
1028	fHasAddress = true;
1029	break;
1030	}
1031
1032	/** @todo realign the list when I/O and MMIO breakpoint command have been added and it's possible to test this code. */
1033	case DBGFBPTYPE_PORT_IO:
1034	case DBGFBPTYPE_MMIO:
1035	{
1036	uint32_t fAccess = DBGF_BP_PUB_GET_TYPE(pBp) == DBGFBPTYPE_PORT_IO ? pBp->u.PortIo.fAccess : pBp->u.Mmio.fAccess;
1037	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, DBGF_BP_PUB_GET_TYPE(pBp) == DBGFBPTYPE_PORT_IO ? " i" : " m");
1038	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, " %c%c%c%c%c%c",
1039	fAccess & DBGFBPIOACCESS_READ_MASK ? 'r' : '-',
1040	fAccess & DBGFBPIOACCESS_READ_BYTE ? '1' : '-',
1041	fAccess & DBGFBPIOACCESS_READ_WORD ? '2' : '-',
1042	fAccess & DBGFBPIOACCESS_READ_DWORD ? '4' : '-',
1043	fAccess & DBGFBPIOACCESS_READ_QWORD ? '8' : '-',
1044	fAccess & DBGFBPIOACCESS_READ_OTHER ? '+' : '-');
1045	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, " %c%c%c%c%c%c",
1046	fAccess & DBGFBPIOACCESS_WRITE_MASK ? 'w' : '-',
1047	fAccess & DBGFBPIOACCESS_WRITE_BYTE ? '1' : '-',
1048	fAccess & DBGFBPIOACCESS_WRITE_WORD ? '2' : '-',
1049	fAccess & DBGFBPIOACCESS_WRITE_DWORD ? '4' : '-',
1050	fAccess & DBGFBPIOACCESS_WRITE_QWORD ? '8' : '-',
1051	fAccess & DBGFBPIOACCESS_WRITE_OTHER ? '+' : '-');
1052	if (DBGF_BP_PUB_GET_TYPE(pBp) == DBGFBPTYPE_PORT_IO)
1053	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, " %04x-%04x",
1054	pBp->u.PortIo.uPort, pBp->u.PortIo.uPort + pBp->u.PortIo.cPorts - 1);
1055	else
1056	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "%RGp LB %03x", pBp->u.Mmio.PhysAddr, pBp->u.Mmio.cb);
1057	break;
1058	}
1059
1060	default:
1061	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, " unknown type %d!!", DBGF_BP_PUB_GET_TYPE(pBp));
1062	AssertFailed();
1063	break;
1064
1065	}
1066	if (pBp->iHitDisable == ~(uint64_t)0)
1067	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, " %04RX64 (%04RX64 to ~0) ", pBp->cHits, pBp->iHitTrigger);
1068	else
1069	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, " %04RX64 (%04RX64 to %04RX64)", pBp->cHits, pBp->iHitTrigger, pBp->iHitDisable);
1070
1071	/*
1072	* Try resolve the address if it has one.
1073	*/
1074	if (fHasAddress)
1075	{
1076	RTDBGSYMBOL Sym;
1077	RTINTPTR off;
1078	DBGFADDRESS Addr;
1079	int rc = DBGFR3AsSymbolByAddr(pUVM, pDbgc->hDbgAs, DBGFR3AddrFromFlat(pDbgc->pUVM, &Addr, pBp->u.GCPtr),
1080	RTDBGSYMADDR_FLAGS_LESS_OR_EQUAL \| RTDBGSYMADDR_FLAGS_SKIP_ABS_IN_DEFERRED,
1081	&off, &Sym, NULL);
1082	if (RT_SUCCESS(rc))
1083	{
1084	if (!off)
1085	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "%s", Sym.szName);
1086	else if (off > 0)
1087	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "%s+%RGv", Sym.szName, off);
1088	else
1089	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "%s-%RGv", Sym.szName, -off);
1090	}
1091	}
1092
1093	/*
1094	* The commands.
1095	*/
1096	if (pDbgcBp)
1097	{
1098	if (pDbgcBp->cchCmd)
1099	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "\n cmds: '%s'\n", pDbgcBp->szCmd);
1100	else
1101	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "\n");
1102	}
1103	else
1104	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, " [unknown bp]\n");
1105
1106	return VINF_SUCCESS;
1107	}
1108
1109
1110	/**
1111	* @callback_method_impl{FNDBGCCMD, The 'bl' command.}
1112	*/
1113	static DECLCALLBACK(int) dbgcCmdBrkList(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
1114	{
1115	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
1116	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, -1, cArgs == 0);
1117	NOREF(paArgs);
1118
1119	/*
1120	* Enumerate the breakpoints.
1121	*/
1122	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1123	int rc = DBGFR3BpEnum(pUVM, dbgcEnumBreakpointsCallback, pDbgc);
1124	if (RT_FAILURE(rc))
1125	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGFR3BpEnum");
1126	return rc;
1127	}
1128
1129
1130	/**
1131	* @callback_method_impl{FNDBGCCMD, The 'bp' command.}
1132	*/
1133	static DECLCALLBACK(int) dbgcCmdBrkSet(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
1134	{
1135	/*
1136	* Convert the pointer to a DBGF address.
1137	*/
1138	DBGFADDRESS Address;
1139	int rc = DBGCCmdHlpVarToDbgfAddr(pCmdHlp, &paArgs[0], &Address);
1140	if (RT_FAILURE(rc))
1141	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGCCmdHlpVarToDbgfAddr(,'%DV',)", &paArgs[0]);
1142
1143	/*
1144	* Pick out the optional arguments.
1145	*/
1146	uint64_t iHitTrigger = 0;
1147	uint64_t iHitDisable = UINT64_MAX;
1148	const char *pszCmds = NULL;
1149	unsigned iArg = 1;
1150	if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_NUMBER)
1151	{
1152	iHitTrigger = paArgs[iArg].u.u64Number;
1153	iArg++;
1154	if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_NUMBER)
1155	{
1156	iHitDisable = paArgs[iArg].u.u64Number;
1157	iArg++;
1158	}
1159	}
1160	if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_STRING)
1161	{
1162	pszCmds = paArgs[iArg].u.pszString;
1163	iArg++;
1164	}
1165
1166	/*
1167	* Try set the breakpoint.
1168	*/
1169	uint32_t iBp;
1170	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1171	rc = DBGFR3BpSetInt3(pUVM, pDbgc->idCpu, &Address, iHitTrigger, iHitDisable, &iBp);
1172	if (RT_SUCCESS(rc))
1173	{
1174	rc = dbgcBpAdd(pDbgc, iBp, pszCmds);
1175	if (RT_SUCCESS(rc))
1176	return DBGCCmdHlpPrintf(pCmdHlp, "Set breakpoint %u at %RGv\n", iBp, Address.FlatPtr);
1177	if (rc == VERR_DBGC_BP_EXISTS)
1178	{
1179	rc = dbgcBpUpdate(pDbgc, iBp, pszCmds);
1180	if (RT_SUCCESS(rc))
1181	return DBGCCmdHlpPrintf(pCmdHlp, "Updated breakpoint %u at %RGv\n", iBp, Address.FlatPtr);
1182	}
1183	int rc2 = DBGFR3BpClear(pDbgc->pUVM, iBp);
1184	AssertRC(rc2);
1185	}
1186	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "Failed to set breakpoint at %RGv", Address.FlatPtr);
1187	}
1188
1189
1190	/**
1191	* @callback_method_impl{FNDBGCCMD, The 'br' command.}
1192	*/
1193	static DECLCALLBACK(int) dbgcCmdBrkREM(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
1194	{
1195	/*
1196	* Convert the pointer to a DBGF address.
1197	*/
1198	DBGFADDRESS Address;
1199	int rc = DBGCCmdHlpVarToDbgfAddr(pCmdHlp, &paArgs[0], &Address);
1200	if (RT_FAILURE(rc))
1201	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGCCmdHlpVarToDbgfAddr(,'%DV',)", &paArgs[0]);
1202
1203	/*
1204	* Pick out the optional arguments.
1205	*/
1206	uint64_t iHitTrigger = 0;
1207	uint64_t iHitDisable = UINT64_MAX;
1208	const char *pszCmds = NULL;
1209	unsigned iArg = 1;
1210	if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_NUMBER)
1211	{
1212	iHitTrigger = paArgs[iArg].u.u64Number;
1213	iArg++;
1214	if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_NUMBER)
1215	{
1216	iHitDisable = paArgs[iArg].u.u64Number;
1217	iArg++;
1218	}
1219	}
1220	if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_STRING)
1221	{
1222	pszCmds = paArgs[iArg].u.pszString;
1223	iArg++;
1224	}
1225
1226	/*
1227	* Try set the breakpoint.
1228	*/
1229	uint32_t iBp;
1230	rc = DBGFR3BpSetREM(pUVM, &Address, iHitTrigger, iHitDisable, &iBp);
1231	if (RT_SUCCESS(rc))
1232	{
1233	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1234	rc = dbgcBpAdd(pDbgc, iBp, pszCmds);
1235	if (RT_SUCCESS(rc))
1236	return DBGCCmdHlpPrintf(pCmdHlp, "Set REM breakpoint %u at %RGv\n", iBp, Address.FlatPtr);
1237	if (rc == VERR_DBGC_BP_EXISTS)
1238	{
1239	rc = dbgcBpUpdate(pDbgc, iBp, pszCmds);
1240	if (RT_SUCCESS(rc))
1241	return DBGCCmdHlpPrintf(pCmdHlp, "Updated REM breakpoint %u at %RGv\n", iBp, Address.FlatPtr);
1242	}
1243	int rc2 = DBGFR3BpClear(pDbgc->pUVM, iBp);
1244	AssertRC(rc2);
1245	}
1246	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "Failed to set REM breakpoint at %RGv", Address.FlatPtr);
1247	}
1248
1249
1250	/**
1251	* Helps the unassmble ('u') command display symbols it starts at and passes.
1252	*
1253	* @param pUVM The user mode VM handle.
1254	* @param pCmdHlp The command helpers for printing via.
1255	* @param hDbgAs The address space to look up addresses in.
1256	* @param pAddress The current address.
1257	* @param pcbCallAgain Where to return the distance to the next check (in
1258	* instruction bytes).
1259	*/
1260	static void dbgcCmdUnassambleHelpListNear(PUVM pUVM, PDBGCCMDHLP pCmdHlp, RTDBGAS hDbgAs, PCDBGFADDRESS pAddress,
1261	PRTUINTPTR pcbCallAgain)
1262	{
1263	RTDBGSYMBOL Symbol;
1264	RTGCINTPTR offDispSym;
1265	int rc = DBGFR3AsSymbolByAddr(pUVM, hDbgAs, pAddress,
1266	RTDBGSYMADDR_FLAGS_LESS_OR_EQUAL \| RTDBGSYMADDR_FLAGS_SKIP_ABS_IN_DEFERRED,
1267	&offDispSym, &Symbol, NULL);
1268	if (RT_FAILURE(rc) \|\| offDispSym > _1G)
1269	rc = DBGFR3AsSymbolByAddr(pUVM, hDbgAs, pAddress,
1270	RTDBGSYMADDR_FLAGS_GREATER_OR_EQUAL \| RTDBGSYMADDR_FLAGS_SKIP_ABS_IN_DEFERRED,
1271	&offDispSym, &Symbol, NULL);
1272	if (RT_SUCCESS(rc) && offDispSym < _1G)
1273	{
1274	if (!offDispSym)
1275	{
1276	DBGCCmdHlpPrintf(pCmdHlp, "%s:\n", Symbol.szName);
1277	*pcbCallAgain = !Symbol.cb ? 64 : Symbol.cb;
1278	}
1279	else if (offDispSym > 0)
1280	{
1281	DBGCCmdHlpPrintf(pCmdHlp, "%s+%#llx:\n", Symbol.szName, (uint64_t)offDispSym);
1282	*pcbCallAgain = !Symbol.cb ? 64 : Symbol.cb > (RTGCUINTPTR)offDispSym ? Symbol.cb - (RTGCUINTPTR)offDispSym : 1;
1283	}
1284	else
1285	{
1286	DBGCCmdHlpPrintf(pCmdHlp, "%s-%#llx:\n", Symbol.szName, (uint64_t)-offDispSym);
1287	*pcbCallAgain = !Symbol.cb ? 64 : (RTGCUINTPTR)-offDispSym + Symbol.cb;
1288	}
1289	}
1290	else
1291	*pcbCallAgain = UINT32_MAX;
1292	}
1293
1294
1295	/**
1296	* @callback_method_impl{FNDBGCCMD, The 'u' command.}
1297	*/
1298	static DECLCALLBACK(int) dbgcCmdUnassemble(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
1299	{
1300	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1301
1302	/*
1303	* Validate input.
1304	*/
1305	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
1306	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, -1, cArgs <= 1);
1307	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, cArgs == 0 \|\| DBGCVAR_ISPOINTER(paArgs[0].enmType));
1308
1309	if (!cArgs && !DBGCVAR_ISPOINTER(pDbgc->DisasmPos.enmType))
1310	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Don't know where to start disassembling");
1311
1312	/*
1313	* Check the desired mode.
1314	*/
1315	unsigned fFlags = DBGF_DISAS_FLAGS_NO_ADDRESS \| DBGF_DISAS_FLAGS_UNPATCHED_BYTES \| DBGF_DISAS_FLAGS_ANNOTATE_PATCHED;
1316	switch (pCmd->pszCmd[1])
1317	{
1318	default: AssertFailed(); RT_FALL_THRU();
1319	case '\0': fFlags \|= DBGF_DISAS_FLAGS_DEFAULT_MODE; break;
1320	case '6': fFlags \|= DBGF_DISAS_FLAGS_64BIT_MODE; break;
1321	case '3': fFlags \|= DBGF_DISAS_FLAGS_32BIT_MODE; break;
1322	case '1': fFlags \|= DBGF_DISAS_FLAGS_16BIT_MODE; break;
1323	case 'v': fFlags \|= DBGF_DISAS_FLAGS_16BIT_REAL_MODE; break;
1324	}
1325
1326	/** @todo should use DBGFADDRESS for everything */
1327
1328	/*
1329	* Find address.
1330	*/
1331	if (!cArgs)
1332	{
1333	if (!DBGCVAR_ISPOINTER(pDbgc->DisasmPos.enmType))
1334	{
1335	/** @todo Batch query CS, RIP, CPU mode and flags. */
1336	PVMCPU pVCpu = VMMR3GetCpuByIdU(pUVM, pDbgc->idCpu);
1337	if (CPUMIsGuestIn64BitCode(pVCpu))
1338	{
1339	pDbgc->DisasmPos.enmType = DBGCVAR_TYPE_GC_FLAT;
1340	pDbgc->SourcePos.u.GCFlat = CPUMGetGuestRIP(pVCpu);
1341	}
1342	else
1343	{
1344	pDbgc->DisasmPos.enmType = DBGCVAR_TYPE_GC_FAR;
1345	pDbgc->SourcePos.u.GCFar.off = CPUMGetGuestEIP(pVCpu);
1346	pDbgc->SourcePos.u.GCFar.sel = CPUMGetGuestCS(pVCpu);
1347	if ( (fFlags & DBGF_DISAS_FLAGS_MODE_MASK) == DBGF_DISAS_FLAGS_DEFAULT_MODE
1348	&& (CPUMGetGuestEFlags(pVCpu) & X86_EFL_VM))
1349	{
1350	fFlags &= ~DBGF_DISAS_FLAGS_MODE_MASK;
1351	fFlags \|= DBGF_DISAS_FLAGS_16BIT_REAL_MODE;
1352	}
1353	}
1354
1355	fFlags \|= DBGF_DISAS_FLAGS_CURRENT_GUEST;
1356	}
1357	else if ((fFlags & DBGF_DISAS_FLAGS_MODE_MASK) == DBGF_DISAS_FLAGS_DEFAULT_MODE && pDbgc->fDisasm)
1358	{
1359	fFlags &= ~DBGF_DISAS_FLAGS_MODE_MASK;
1360	fFlags \|= pDbgc->fDisasm & DBGF_DISAS_FLAGS_MODE_MASK;
1361	}
1362	pDbgc->DisasmPos.enmRangeType = DBGCVAR_RANGE_NONE;
1363	}
1364	else
1365	pDbgc->DisasmPos = paArgs[0];
1366	pDbgc->pLastPos = &pDbgc->DisasmPos;
1367
1368	/*
1369	* Range.
1370	*/
1371	switch (pDbgc->DisasmPos.enmRangeType)
1372	{
1373	case DBGCVAR_RANGE_NONE:
1374	pDbgc->DisasmPos.enmRangeType = DBGCVAR_RANGE_ELEMENTS;
1375	pDbgc->DisasmPos.u64Range = 10;
1376	break;
1377
1378	case DBGCVAR_RANGE_ELEMENTS:
1379	if (pDbgc->DisasmPos.u64Range > 2048)
1380	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Too many lines requested. Max is 2048 lines");
1381	break;
1382
1383	case DBGCVAR_RANGE_BYTES:
1384	if (pDbgc->DisasmPos.u64Range > 65536)
1385	return DBGCCmdHlpFail(pCmdHlp, pCmd, "The requested range is too big. Max is 64KB");
1386	break;
1387
1388	default:
1389	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Unknown range type %d", pDbgc->DisasmPos.enmRangeType);
1390	}
1391
1392	/*
1393	* Convert physical and host addresses to guest addresses.
1394	*/
1395	RTDBGAS hDbgAs = pDbgc->hDbgAs;
1396	int rc;
1397	switch (pDbgc->DisasmPos.enmType)
1398	{
1399	case DBGCVAR_TYPE_GC_FLAT:
1400	case DBGCVAR_TYPE_GC_FAR:
1401	break;
1402	case DBGCVAR_TYPE_GC_PHYS:
1403	hDbgAs = DBGF_AS_PHYS;
1404	RT_FALL_THRU();
1405	case DBGCVAR_TYPE_HC_FLAT:
1406	case DBGCVAR_TYPE_HC_PHYS:
1407	{
1408	DBGCVAR VarTmp;
1409	rc = DBGCCmdHlpEval(pCmdHlp, &VarTmp, "%%(%Dv)", &pDbgc->DisasmPos);
1410	if (RT_FAILURE(rc))
1411	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "failed to evaluate '%%(%Dv)'", &pDbgc->DisasmPos);
1412	pDbgc->DisasmPos = VarTmp;
1413	break;
1414	}
1415	default: AssertFailed(); break;
1416	}
1417
1418	DBGFADDRESS CurAddr;
1419	if ( (fFlags & DBGF_DISAS_FLAGS_MODE_MASK) == DBGF_DISAS_FLAGS_16BIT_REAL_MODE
1420	&& pDbgc->DisasmPos.enmType == DBGCVAR_TYPE_GC_FAR)
1421	DBGFR3AddrFromFlat(pUVM, &CurAddr, ((uint32_t)pDbgc->DisasmPos.u.GCFar.sel << 4) + pDbgc->DisasmPos.u.GCFar.off);
1422	else
1423	{
1424	rc = DBGCCmdHlpVarToDbgfAddr(pCmdHlp, &pDbgc->DisasmPos, &CurAddr);
1425	if (RT_FAILURE(rc))
1426	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGCCmdHlpVarToDbgfAddr failed on '%Dv'", &pDbgc->DisasmPos);
1427	}
1428
1429	pDbgc->fDisasm = fFlags;
1430
1431	/*
1432	* Figure out where we are and display it. Also calculate when we need to
1433	* check for a new symbol if possible.
1434	*/
1435	RTGCUINTPTR cbCheckSymbol;
1436	dbgcCmdUnassambleHelpListNear(pUVM, pCmdHlp, hDbgAs, &CurAddr, &cbCheckSymbol);
1437
1438	/*
1439	* Do the disassembling.
1440	*/
1441	unsigned cTries = 32;
1442	int iRangeLeft = (int)pDbgc->DisasmPos.u64Range;
1443	if (iRangeLeft == 0) /* kludge for 'r'. */
1444	iRangeLeft = -1;
1445	for (;;)
1446	{
1447	/*
1448	* Disassemble the instruction.
1449	*/
1450	char szDis[256];
1451	uint32_t cbInstr = 1;
1452	if (pDbgc->DisasmPos.enmType == DBGCVAR_TYPE_GC_FLAT)
1453	rc = DBGFR3DisasInstrEx(pUVM, pDbgc->idCpu, DBGF_SEL_FLAT, pDbgc->DisasmPos.u.GCFlat, fFlags,
1454	&szDis[0], sizeof(szDis), &cbInstr);
1455	else
1456	rc = DBGFR3DisasInstrEx(pUVM, pDbgc->idCpu, pDbgc->DisasmPos.u.GCFar.sel, pDbgc->DisasmPos.u.GCFar.off, fFlags,
1457	&szDis[0], sizeof(szDis), &cbInstr);
1458	if (RT_SUCCESS(rc))
1459	{
1460	/* print it */
1461	rc = DBGCCmdHlpPrintf(pCmdHlp, "%-16DV %s\n", &pDbgc->DisasmPos, &szDis[0]);
1462	if (RT_FAILURE(rc))
1463	return rc;
1464	}
1465	else
1466	{
1467	/* bitch. */
1468	int rc2 = DBGCCmdHlpPrintf(pCmdHlp, "Failed to disassemble instruction, skipping one byte.\n");
1469	if (RT_FAILURE(rc2))
1470	return rc2;
1471	if (cTries-- > 0)
1472	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "Too many disassembly failures. Giving up");
1473	cbInstr = 1;
1474	}
1475
1476	/* advance */
1477	if (iRangeLeft < 0) /* 'r' */
1478	break;
1479	if (pDbgc->DisasmPos.enmRangeType == DBGCVAR_RANGE_ELEMENTS)
1480	iRangeLeft--;
1481	else
1482	iRangeLeft -= cbInstr;
1483	rc = DBGCCmdHlpEval(pCmdHlp, &pDbgc->DisasmPos, "(%Dv) + %x", &pDbgc->DisasmPos, cbInstr);
1484	if (RT_FAILURE(rc))
1485	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGCCmdHlpEval(,,'(%Dv) + %x')", &pDbgc->DisasmPos, cbInstr);
1486	if (iRangeLeft <= 0)
1487	break;
1488	fFlags &= ~DBGF_DISAS_FLAGS_CURRENT_GUEST;
1489
1490	/* Print next symbol? */
1491	if (cbCheckSymbol <= cbInstr)
1492	{
1493	if ( (fFlags & DBGF_DISAS_FLAGS_MODE_MASK) == DBGF_DISAS_FLAGS_16BIT_REAL_MODE
1494	&& pDbgc->DisasmPos.enmType == DBGCVAR_TYPE_GC_FAR)
1495	DBGFR3AddrFromFlat(pUVM, &CurAddr, ((uint32_t)pDbgc->DisasmPos.u.GCFar.sel << 4) + pDbgc->DisasmPos.u.GCFar.off);
1496	else
1497	rc = DBGCCmdHlpVarToDbgfAddr(pCmdHlp, &pDbgc->DisasmPos, &CurAddr);
1498	if (RT_SUCCESS(rc))
1499	dbgcCmdUnassambleHelpListNear(pUVM, pCmdHlp, hDbgAs, &CurAddr, &cbCheckSymbol);
1500	else
1501	cbCheckSymbol = UINT32_MAX;
1502	}
1503	else
1504	cbCheckSymbol -= cbInstr;
1505	}
1506
1507	NOREF(pCmd);
1508	return VINF_SUCCESS;
1509	}
1510
1511
1512	/**
1513	* @callback_method_impl{FNDGCSCREENBLIT}
1514	*/
1515	static DECLCALLBACK(int) dbgcCmdUnassembleCfgBlit(const char psz, void pvUser)
1516	{
1517	PDBGCCMDHLP pCmdHlp = (PDBGCCMDHLP)pvUser;
1518	return DBGCCmdHlpPrintf(pCmdHlp, "%s", psz);
1519	}
1520
1521
1522	/**
1523	* Checks whether both addresses are equal.
1524	*
1525	* @returns true if both addresses point to the same location, false otherwise.
1526	* @param pAddr1 First address.
1527	* @param pAddr2 Second address.
1528	*/
1529	static bool dbgcCmdUnassembleCfgAddrEqual(PDBGFADDRESS pAddr1, PDBGFADDRESS pAddr2)
1530	{
1531	return pAddr1->Sel == pAddr2->Sel
1532	&& pAddr1->off == pAddr2->off;
1533	}
1534
1535
1536	/**
1537	* Checks whether the first given address is lower than the second one.
1538	*
1539	* @returns true if both addresses point to the same location, false otherwise.
1540	* @param pAddr1 First address.
1541	* @param pAddr2 Second address.
1542	*/
1543	static bool dbgcCmdUnassembleCfgAddrLower(PDBGFADDRESS pAddr1, PDBGFADDRESS pAddr2)
1544	{
1545	return pAddr1->Sel == pAddr2->Sel
1546	&& pAddr1->off < pAddr2->off;
1547	}
1548
1549
1550	/**
1551	* Calculates the size required for the given basic block including the
1552	* border and spacing on the edges.
1553	*
1554	* @returns nothing.
1555	* @param hFlowBb The basic block handle.
1556	* @param pDumpBb The dumper state to fill in for the basic block.
1557	*/
1558	static void dbgcCmdUnassembleCfgDumpCalcBbSize(DBGFFLOWBB hFlowBb, PDBGCFLOWBBDUMP pDumpBb)
1559	{
1560	uint32_t fFlags = DBGFR3FlowBbGetFlags(hFlowBb);
1561	uint32_t cInstr = DBGFR3FlowBbGetInstrCount(hFlowBb);
1562
1563	pDumpBb->hFlowBb = hFlowBb;
1564	pDumpBb->cchHeight = cInstr + 4; /* Include spacing and border top and bottom. */
1565	pDumpBb->cchWidth = 0;
1566	DBGFR3FlowBbGetStartAddress(hFlowBb, &pDumpBb->AddrStart);
1567
1568	DBGFFLOWBBENDTYPE enmType = DBGFR3FlowBbGetType(hFlowBb);
1569	if ( enmType == DBGFFLOWBBENDTYPE_COND
1570	\|\| enmType == DBGFFLOWBBENDTYPE_UNCOND_JMP
1571	\|\| enmType == DBGFFLOWBBENDTYPE_UNCOND_INDIRECT_JMP)
1572	DBGFR3FlowBbGetBranchAddress(hFlowBb, &pDumpBb->AddrTarget);
1573
1574	if (fFlags & DBGF_FLOW_BB_F_INCOMPLETE_ERR)
1575	{
1576	const char *pszErr = NULL;
1577	DBGFR3FlowBbQueryError(hFlowBb, &pszErr);
1578	if (pszErr)
1579	{
1580	pDumpBb->cchHeight++;
1581	pDumpBb->cchWidth = RT_MAX(pDumpBb->cchWidth, (uint32_t)strlen(pszErr));
1582	}
1583	}
1584	for (unsigned i = 0; i < cInstr; i++)
1585	{
1586	const char *pszInstr = NULL;
1587	int rc = DBGFR3FlowBbQueryInstr(hFlowBb, i, NULL, NULL, &pszInstr);
1588	AssertRC(rc);
1589	pDumpBb->cchWidth = RT_MAX(pDumpBb->cchWidth, (uint32_t)strlen(pszInstr));
1590	}
1591	pDumpBb->cchWidth += 4; /* Include spacing and border left and right. */
1592	}
1593
1594
1595	/**
1596	* Dumps a top or bottom boundary line.
1597	*
1598	* @returns nothing.
1599	* @param hScreen The screen to draw to.
1600	* @param uStartX Where to start drawing the boundary.
1601	* @param uStartY Y coordinate.
1602	* @param cchWidth Width of the boundary.
1603	* @param enmColor The color to use for drawing.
1604	*/
1605	static void dbgcCmdUnassembleCfgDumpBbBoundary(DBGCSCREEN hScreen, uint32_t uStartX, uint32_t uStartY, uint32_t cchWidth,
1606	DBGCSCREENCOLOR enmColor)
1607	{
1608	dbgcScreenAsciiDrawCharacter(hScreen, uStartX, uStartY, '+', enmColor);
1609	dbgcScreenAsciiDrawLineHorizontal(hScreen, uStartX + 1, uStartX + 1 + cchWidth - 2,
1610	uStartY, '-', enmColor);
1611	dbgcScreenAsciiDrawCharacter(hScreen, uStartX + cchWidth - 1, uStartY, '+', enmColor);
1612	}
1613
1614
1615	/**
1616	* Dumps a spacing line between the top or bottom boundary and the actual disassembly.
1617	*
1618	* @returns nothing.
1619	* @param hScreen The screen to draw to.
1620	* @param uStartX Where to start drawing the spacing.
1621	* @param uStartY Y coordinate.
1622	* @param cchWidth Width of the spacing.
1623	* @param enmColor The color to use for drawing.
1624	*/
1625	static void dbgcCmdUnassembleCfgDumpBbSpacing(DBGCSCREEN hScreen, uint32_t uStartX, uint32_t uStartY, uint32_t cchWidth,
1626	DBGCSCREENCOLOR enmColor)
1627	{
1628	dbgcScreenAsciiDrawCharacter(hScreen, uStartX, uStartY, '\|', enmColor);
1629	dbgcScreenAsciiDrawLineHorizontal(hScreen, uStartX + 1, uStartX + 1 + cchWidth - 2,
1630	uStartY, ' ', enmColor);
1631	dbgcScreenAsciiDrawCharacter(hScreen, uStartX + cchWidth - 1, uStartY, '\|', enmColor);
1632	}
1633
1634
1635	/**
1636	* Writes a given text to the screen.
1637	*
1638	* @returns nothing.
1639	* @param hScreen The screen to draw to.
1640	* @param uStartX Where to start drawing the line.
1641	* @param uStartY Y coordinate.
1642	* @param cchWidth Maximum width of the text.
1643	* @param pszText The text to write.
1644	* @param enmTextColor The color to use for drawing the text.
1645	* @param enmBorderColor The color to use for drawing the border.
1646	*/
1647	static void dbgcCmdUnassembleCfgDumpBbText(DBGCSCREEN hScreen, uint32_t uStartX, uint32_t uStartY,
1648	uint32_t cchWidth, const char *pszText,
1649	DBGCSCREENCOLOR enmTextColor, DBGCSCREENCOLOR enmBorderColor)
1650	{
1651	dbgcScreenAsciiDrawCharacter(hScreen, uStartX, uStartY, '\|', enmBorderColor);
1652	dbgcScreenAsciiDrawCharacter(hScreen, uStartX + 1, uStartY, ' ', enmTextColor);
1653	dbgcScreenAsciiDrawString(hScreen, uStartX + 2, uStartY, pszText, enmTextColor);
1654	dbgcScreenAsciiDrawCharacter(hScreen, uStartX + cchWidth - 1, uStartY, '\|', enmBorderColor);
1655	}
1656
1657
1658	/**
1659	* Dumps one basic block using the dumper callback.
1660	*
1661	* @returns nothing.
1662	* @param pDumpBb The basic block dump state to dump.
1663	* @param hScreen The screen to draw to.
1664	*/
1665	static void dbgcCmdUnassembleCfgDumpBb(PDBGCFLOWBBDUMP pDumpBb, DBGCSCREEN hScreen)
1666	{
1667	uint32_t uStartY = pDumpBb->uStartY;
1668	bool fError = RT_BOOL(DBGFR3FlowBbGetFlags(pDumpBb->hFlowBb) & DBGF_FLOW_BB_F_INCOMPLETE_ERR);
1669	DBGCSCREENCOLOR enmColor = fError ? DBGCSCREENCOLOR_RED_BRIGHT : DBGCSCREENCOLOR_DEFAULT;
1670
1671	dbgcCmdUnassembleCfgDumpBbBoundary(hScreen, pDumpBb->uStartX, uStartY, pDumpBb->cchWidth, enmColor);
1672	uStartY++;
1673	dbgcCmdUnassembleCfgDumpBbSpacing(hScreen, pDumpBb->uStartX, uStartY, pDumpBb->cchWidth, enmColor);
1674	uStartY++;
1675
1676	uint32_t cInstr = DBGFR3FlowBbGetInstrCount(pDumpBb->hFlowBb);
1677	for (unsigned i = 0; i < cInstr; i++)
1678	{
1679	const char *pszInstr = NULL;
1680	DBGFR3FlowBbQueryInstr(pDumpBb->hFlowBb, i, NULL, NULL, &pszInstr);
1681	dbgcCmdUnassembleCfgDumpBbText(hScreen, pDumpBb->uStartX, uStartY + i,
1682	pDumpBb->cchWidth, pszInstr, DBGCSCREENCOLOR_DEFAULT,
1683	enmColor);
1684	}
1685	uStartY += cInstr;
1686
1687	if (fError)
1688	{
1689	const char *pszErr = NULL;
1690	DBGFR3FlowBbQueryError(pDumpBb->hFlowBb, &pszErr);
1691	if (pszErr)
1692	dbgcCmdUnassembleCfgDumpBbText(hScreen, pDumpBb->uStartX, uStartY,
1693	pDumpBb->cchWidth, pszErr, enmColor,
1694	enmColor);
1695	uStartY++;
1696	}
1697
1698	dbgcCmdUnassembleCfgDumpBbSpacing(hScreen, pDumpBb->uStartX, uStartY, pDumpBb->cchWidth, enmColor);
1699	uStartY++;
1700	dbgcCmdUnassembleCfgDumpBbBoundary(hScreen, pDumpBb->uStartX, uStartY, pDumpBb->cchWidth, enmColor);
1701	uStartY++;
1702	}
1703
1704
1705	/**
1706	* Dumps one branch table using the dumper callback.
1707	*
1708	* @returns nothing.
1709	* @param pDumpBranchTbl The basic block dump state to dump.
1710	* @param hScreen The screen to draw to.
1711	*/
1712	static void dbgcCmdUnassembleCfgDumpBranchTbl(PDBGCFLOWBRANCHTBLDUMP pDumpBranchTbl, DBGCSCREEN hScreen)
1713	{
1714	uint32_t uStartY = pDumpBranchTbl->uStartY;
1715	DBGCSCREENCOLOR enmColor = DBGCSCREENCOLOR_CYAN_BRIGHT;
1716
1717	dbgcCmdUnassembleCfgDumpBbBoundary(hScreen, pDumpBranchTbl->uStartX, uStartY, pDumpBranchTbl->cchWidth, enmColor);
1718	uStartY++;
1719	dbgcCmdUnassembleCfgDumpBbSpacing(hScreen, pDumpBranchTbl->uStartX, uStartY, pDumpBranchTbl->cchWidth, enmColor);
1720	uStartY++;
1721
1722	uint32_t cSlots = DBGFR3FlowBranchTblGetSlots(pDumpBranchTbl->hFlowBranchTbl);
1723	for (unsigned i = 0; i < cSlots; i++)
1724	{
1725	DBGFADDRESS Addr;
1726	char szAddr[128];
1727
1728	RT_ZERO(szAddr);
1729	DBGFR3FlowBranchTblGetAddrAtSlot(pDumpBranchTbl->hFlowBranchTbl, i, &Addr);
1730
1731	if (Addr.Sel == DBGF_SEL_FLAT)
1732	RTStrPrintf(&szAddr[0], sizeof(szAddr), "%RGv", Addr.FlatPtr);
1733	else
1734	RTStrPrintf(&szAddr[0], sizeof(szAddr), "%04x:%RGv", Addr.Sel, Addr.off);
1735
1736	dbgcCmdUnassembleCfgDumpBbText(hScreen, pDumpBranchTbl->uStartX, uStartY + i,
1737	pDumpBranchTbl->cchWidth, &szAddr[0], DBGCSCREENCOLOR_DEFAULT,
1738	enmColor);
1739	}
1740	uStartY += cSlots;
1741
1742	dbgcCmdUnassembleCfgDumpBbSpacing(hScreen, pDumpBranchTbl->uStartX, uStartY, pDumpBranchTbl->cchWidth, enmColor);
1743	uStartY++;
1744	dbgcCmdUnassembleCfgDumpBbBoundary(hScreen, pDumpBranchTbl->uStartX, uStartY, pDumpBranchTbl->cchWidth, enmColor);
1745	uStartY++;
1746	}
1747
1748
1749	/**
1750	* Fills in the dump states for the basic blocks and branch tables.
1751	*
1752	* @returns VBox status code.
1753	* @param hFlowIt The control flow graph iterator handle.
1754	* @param hFlowBranchTblIt The control flow graph branch table iterator handle.
1755	* @param paDumpBb The array of basic block dump states.
1756	* @param paDumpBranchTbl The array of branch table dump states.
1757	* @param cBbs Number of basic blocks.
1758	* @param cBranchTbls Number of branch tables.
1759	*/
1760	static int dbgcCmdUnassembleCfgDumpCalcDimensions(DBGFFLOWIT hFlowIt, DBGFFLOWBRANCHTBLIT hFlowBranchTblIt,
1761	PDBGCFLOWBBDUMP paDumpBb, PDBGCFLOWBRANCHTBLDUMP paDumpBranchTbl,
1762	uint32_t cBbs, uint32_t cBranchTbls)
1763	{
1764	RT_NOREF2(cBbs, cBranchTbls);
1765
1766	/* Calculate the sizes of each basic block first. */
1767	DBGFFLOWBB hFlowBb = DBGFR3FlowItNext(hFlowIt);
1768	uint32_t idx = 0;
1769	while (hFlowBb)
1770	{
1771	dbgcCmdUnassembleCfgDumpCalcBbSize(hFlowBb, &paDumpBb[idx]);
1772	idx++;
1773	hFlowBb = DBGFR3FlowItNext(hFlowIt);
1774	}
1775
1776	if (paDumpBranchTbl)
1777	{
1778	idx = 0;
1779	DBGFFLOWBRANCHTBL hFlowBranchTbl = DBGFR3FlowBranchTblItNext(hFlowBranchTblIt);
1780	while (hFlowBranchTbl)
1781	{
1782	paDumpBranchTbl[idx].hFlowBranchTbl = hFlowBranchTbl;
1783	paDumpBranchTbl[idx].cchHeight = DBGFR3FlowBranchTblGetSlots(hFlowBranchTbl) + 4; /* Spacing and border. */
1784	paDumpBranchTbl[idx].cchWidth = 25 + 4; /* Spacing and border. */
1785	idx++;
1786	hFlowBranchTbl = DBGFR3FlowBranchTblItNext(hFlowBranchTblIt);
1787	}
1788	}
1789
1790	return VINF_SUCCESS;
1791	}
1792
1793	/**
1794	* Dumps the given control flow graph to the output.
1795	*
1796	* @returns VBox status code.
1797	* @param hCfg The control flow graph handle.
1798	* @param fUseColor Flag whether the output should be colorized.
1799	* @param pCmdHlp The command helper callback table.
1800	*/
1801	static int dbgcCmdUnassembleCfgDump(DBGFFLOW hCfg, bool fUseColor, PDBGCCMDHLP pCmdHlp)
1802	{
1803	int rc = VINF_SUCCESS;
1804	DBGFFLOWIT hCfgIt = NULL;
1805	DBGFFLOWBRANCHTBLIT hFlowBranchTblIt = NULL;
1806	uint32_t cBbs = DBGFR3FlowGetBbCount(hCfg);
1807	uint32_t cBranchTbls = DBGFR3FlowGetBranchTblCount(hCfg);
1808	PDBGCFLOWBBDUMP paDumpBb = (PDBGCFLOWBBDUMP)RTMemTmpAllocZ(cBbs * sizeof(DBGCFLOWBBDUMP));
1809	PDBGCFLOWBRANCHTBLDUMP paDumpBranchTbl = NULL;
1810
1811	if (cBranchTbls)
1812	paDumpBranchTbl = (PDBGCFLOWBRANCHTBLDUMP)RTMemAllocZ(cBranchTbls * sizeof(DBGCFLOWBRANCHTBLDUMP));
1813
1814	if (RT_UNLIKELY(!paDumpBb \|\| (!paDumpBranchTbl && cBranchTbls > 0)))
1815	rc = VERR_NO_MEMORY;
1816	if (RT_SUCCESS(rc))
1817	rc = DBGFR3FlowItCreate(hCfg, DBGFFLOWITORDER_BY_ADDR_LOWEST_FIRST, &hCfgIt);
1818	if (RT_SUCCESS(rc) && cBranchTbls > 0)
1819	rc = DBGFR3FlowBranchTblItCreate(hCfg, DBGFFLOWITORDER_BY_ADDR_LOWEST_FIRST, &hFlowBranchTblIt);
1820
1821	if (RT_SUCCESS(rc))
1822	{
1823	rc = dbgcCmdUnassembleCfgDumpCalcDimensions(hCfgIt, hFlowBranchTblIt, paDumpBb, paDumpBranchTbl,
1824	cBbs, cBranchTbls);
1825
1826	/* Calculate the ASCII screen dimensions and create one. */
1827	uint32_t cchWidth = 0;
1828	uint32_t cchLeftExtra = 5;
1829	uint32_t cchRightExtra = 5;
1830	uint32_t cchHeight = 0;
1831	for (unsigned i = 0; i < cBbs; i++)
1832	{
1833	PDBGCFLOWBBDUMP pDumpBb = &paDumpBb[i];
1834	cchWidth = RT_MAX(cchWidth, pDumpBb->cchWidth);
1835	cchHeight += pDumpBb->cchHeight;
1836
1837	/* Incomplete blocks don't have a successor. */
1838	if (DBGFR3FlowBbGetFlags(pDumpBb->hFlowBb) & DBGF_FLOW_BB_F_INCOMPLETE_ERR)
1839	continue;
1840
1841	switch (DBGFR3FlowBbGetType(pDumpBb->hFlowBb))
1842	{
1843	case DBGFFLOWBBENDTYPE_EXIT:
1844	case DBGFFLOWBBENDTYPE_LAST_DISASSEMBLED:
1845	break;
1846	case DBGFFLOWBBENDTYPE_UNCOND_JMP:
1847	if ( dbgcCmdUnassembleCfgAddrLower(&pDumpBb->AddrTarget, &pDumpBb->AddrStart)
1848	\|\| dbgcCmdUnassembleCfgAddrEqual(&pDumpBb->AddrTarget, &pDumpBb->AddrStart))
1849	cchLeftExtra++;
1850	else
1851	cchRightExtra++;
1852	break;
1853	case DBGFFLOWBBENDTYPE_UNCOND:
1854	cchHeight += 2; /* For the arrow down to the next basic block. */
1855	break;
1856	case DBGFFLOWBBENDTYPE_COND:
1857	cchHeight += 2; /* For the arrow down to the next basic block. */
1858	if ( dbgcCmdUnassembleCfgAddrLower(&pDumpBb->AddrTarget, &pDumpBb->AddrStart)
1859	\|\| dbgcCmdUnassembleCfgAddrEqual(&pDumpBb->AddrTarget, &pDumpBb->AddrStart))
1860	cchLeftExtra++;
1861	else
1862	cchRightExtra++;
1863	break;
1864	case DBGFFLOWBBENDTYPE_UNCOND_INDIRECT_JMP:
1865	default:
1866	AssertFailed();
1867	}
1868	}
1869
1870	for (unsigned i = 0; i < cBranchTbls; i++)
1871	{
1872	PDBGCFLOWBRANCHTBLDUMP pDumpBranchTbl = &paDumpBranchTbl[i];
1873	cchWidth = RT_MAX(cchWidth, pDumpBranchTbl->cchWidth);
1874	cchHeight += pDumpBranchTbl->cchHeight;
1875	}
1876
1877	cchWidth += 2;
1878
1879	DBGCSCREEN hScreen = NULL;
1880	rc = dbgcScreenAsciiCreate(&hScreen, cchWidth + cchLeftExtra + cchRightExtra, cchHeight);
1881	if (RT_SUCCESS(rc))
1882	{
1883	uint32_t uY = 0;
1884
1885	/* Dump the branch tables first. */
1886	for (unsigned i = 0; i < cBranchTbls; i++)
1887	{
1888	paDumpBranchTbl[i].uStartX = cchLeftExtra + (cchWidth - paDumpBranchTbl[i].cchWidth) / 2;
1889	paDumpBranchTbl[i].uStartY = uY;
1890	dbgcCmdUnassembleCfgDumpBranchTbl(&paDumpBranchTbl[i], hScreen);
1891	uY += paDumpBranchTbl[i].cchHeight;
1892	}
1893
1894	/* Dump the basic blocks and connections to the immediate successor. */
1895	for (unsigned i = 0; i < cBbs; i++)
1896	{
1897	paDumpBb[i].uStartX = cchLeftExtra + (cchWidth - paDumpBb[i].cchWidth) / 2;
1898	paDumpBb[i].uStartY = uY;
1899	dbgcCmdUnassembleCfgDumpBb(&paDumpBb[i], hScreen);
1900	uY += paDumpBb[i].cchHeight;
1901
1902	/* Incomplete blocks don't have a successor. */
1903	if (DBGFR3FlowBbGetFlags(paDumpBb[i].hFlowBb) & DBGF_FLOW_BB_F_INCOMPLETE_ERR)
1904	continue;
1905
1906	switch (DBGFR3FlowBbGetType(paDumpBb[i].hFlowBb))
1907	{
1908	case DBGFFLOWBBENDTYPE_EXIT:
1909	case DBGFFLOWBBENDTYPE_LAST_DISASSEMBLED:
1910	case DBGFFLOWBBENDTYPE_UNCOND_JMP:
1911	case DBGFFLOWBBENDTYPE_UNCOND_INDIRECT_JMP:
1912	break;
1913	case DBGFFLOWBBENDTYPE_UNCOND:
1914	/* Draw the arrow down to the next block. */
1915	dbgcScreenAsciiDrawCharacter(hScreen, cchLeftExtra + cchWidth / 2, uY,
1916	'\|', DBGCSCREENCOLOR_BLUE_BRIGHT);
1917	uY++;
1918	dbgcScreenAsciiDrawCharacter(hScreen, cchLeftExtra + cchWidth / 2, uY,
1919	'V', DBGCSCREENCOLOR_BLUE_BRIGHT);
1920	uY++;
1921	break;
1922	case DBGFFLOWBBENDTYPE_COND:
1923	/* Draw the arrow down to the next block. */
1924	dbgcScreenAsciiDrawCharacter(hScreen, cchLeftExtra + cchWidth / 2, uY,
1925	'\|', DBGCSCREENCOLOR_RED_BRIGHT);
1926	uY++;
1927	dbgcScreenAsciiDrawCharacter(hScreen, cchLeftExtra + cchWidth / 2, uY,
1928	'V', DBGCSCREENCOLOR_RED_BRIGHT);
1929	uY++;
1930	break;
1931	default:
1932	AssertFailed();
1933	}
1934	}
1935
1936	/* Last pass, connect all remaining branches. */
1937	uint32_t uBackConns = 0;
1938	uint32_t uFwdConns = 0;
1939	for (unsigned i = 0; i < cBbs; i++)
1940	{
1941	PDBGCFLOWBBDUMP pDumpBb = &paDumpBb[i];
1942	DBGFFLOWBBENDTYPE enmEndType = DBGFR3FlowBbGetType(pDumpBb->hFlowBb);
1943
1944	/* Incomplete blocks don't have a successor. */
1945	if (DBGFR3FlowBbGetFlags(pDumpBb->hFlowBb) & DBGF_FLOW_BB_F_INCOMPLETE_ERR)
1946	continue;
1947
1948	switch (enmEndType)
1949	{
1950	case DBGFFLOWBBENDTYPE_EXIT:
1951	case DBGFFLOWBBENDTYPE_LAST_DISASSEMBLED:
1952	case DBGFFLOWBBENDTYPE_UNCOND:
1953	break;
1954	case DBGFFLOWBBENDTYPE_COND:
1955	case DBGFFLOWBBENDTYPE_UNCOND_JMP:
1956	{
1957	/* Find the target first to get the coordinates. */
1958	PDBGCFLOWBBDUMP pDumpBbTgt = NULL;
1959	for (unsigned idxDumpBb = 0; idxDumpBb < cBbs; idxDumpBb++)
1960	{
1961	pDumpBbTgt = &paDumpBb[idxDumpBb];
1962	if (dbgcCmdUnassembleCfgAddrEqual(&pDumpBb->AddrTarget, &pDumpBbTgt->AddrStart))
1963	break;
1964	}
1965
1966	DBGCSCREENCOLOR enmColor = enmEndType == DBGFFLOWBBENDTYPE_UNCOND_JMP
1967	? DBGCSCREENCOLOR_YELLOW_BRIGHT
1968	: DBGCSCREENCOLOR_GREEN_BRIGHT;
1969
1970	/*
1971	* Use the right side for targets with higher addresses,
1972	* left when jumping backwards.
1973	*/
1974	if ( dbgcCmdUnassembleCfgAddrLower(&pDumpBb->AddrTarget, &pDumpBb->AddrStart)
1975	\|\| dbgcCmdUnassembleCfgAddrEqual(&pDumpBb->AddrTarget, &pDumpBb->AddrStart))
1976	{
1977	/* Going backwards. */
1978	uint32_t uXVerLine = /cchLeftExtra - 1 -/ uBackConns + 1;
1979	uint32_t uYHorLine = pDumpBb->uStartY + pDumpBb->cchHeight - 1 - 2;
1980	uBackConns++;
1981
1982	/* Draw the arrow pointing to the target block. */
1983	dbgcScreenAsciiDrawCharacter(hScreen, pDumpBbTgt->uStartX - 1, pDumpBbTgt->uStartY,
1984	'>', enmColor);
1985	/* Draw the horizontal line. */
1986	dbgcScreenAsciiDrawLineHorizontal(hScreen, uXVerLine + 1, pDumpBbTgt->uStartX - 2,
1987	pDumpBbTgt->uStartY, '-', enmColor);
1988	dbgcScreenAsciiDrawCharacter(hScreen, uXVerLine, pDumpBbTgt->uStartY, '+',
1989	enmColor);
1990	/* Draw the vertical line down to the source block. */
1991	dbgcScreenAsciiDrawLineVertical(hScreen, uXVerLine, pDumpBbTgt->uStartY + 1, uYHorLine - 1,
1992	'\|', enmColor);
1993	dbgcScreenAsciiDrawCharacter(hScreen, uXVerLine, uYHorLine, '+', enmColor);
1994	/* Draw the horizontal connection between the source block and vertical part. */
1995	dbgcScreenAsciiDrawLineHorizontal(hScreen, uXVerLine + 1, pDumpBb->uStartX - 1,
1996	uYHorLine, '-', enmColor);
1997
1998	}
1999	else
2000	{
2001	/* Going forward. */
2002	uint32_t uXVerLine = cchWidth + cchLeftExtra + (cchRightExtra - uFwdConns) - 1;
2003	uint32_t uYHorLine = pDumpBb->uStartY + pDumpBb->cchHeight - 1 - 2;
2004	uFwdConns++;
2005
2006	/* Draw the horizontal line. */
2007	dbgcScreenAsciiDrawLineHorizontal(hScreen, pDumpBb->uStartX + pDumpBb->cchWidth,
2008	uXVerLine - 1, uYHorLine, '-', enmColor);
2009	dbgcScreenAsciiDrawCharacter(hScreen, uXVerLine, uYHorLine, '+', enmColor);
2010	/* Draw the vertical line down to the target block. */
2011	dbgcScreenAsciiDrawLineVertical(hScreen, uXVerLine, uYHorLine + 1, pDumpBbTgt->uStartY - 1,
2012	'\|', enmColor);
2013	/* Draw the horizontal connection between the target block and vertical part. */
2014	dbgcScreenAsciiDrawLineHorizontal(hScreen, pDumpBbTgt->uStartX + pDumpBbTgt->cchWidth,
2015	uXVerLine, pDumpBbTgt->uStartY, '-', enmColor);
2016	dbgcScreenAsciiDrawCharacter(hScreen, uXVerLine, pDumpBbTgt->uStartY, '+',
2017	enmColor);
2018	/* Draw the arrow pointing to the target block. */
2019	dbgcScreenAsciiDrawCharacter(hScreen, pDumpBbTgt->uStartX + pDumpBbTgt->cchWidth,
2020	pDumpBbTgt->uStartY, '<', enmColor);
2021	}
2022	break;
2023	}
2024	case DBGFFLOWBBENDTYPE_UNCOND_INDIRECT_JMP:
2025	default:
2026	AssertFailed();
2027	}
2028	}
2029
2030	rc = dbgcScreenAsciiBlit(hScreen, dbgcCmdUnassembleCfgBlit, pCmdHlp, fUseColor);
2031	dbgcScreenAsciiDestroy(hScreen);
2032	}
2033	}
2034
2035	if (paDumpBb)
2036	{
2037	for (unsigned i = 0; i < cBbs; i++)
2038	DBGFR3FlowBbRelease(paDumpBb[i].hFlowBb);
2039	RTMemTmpFree(paDumpBb);
2040	}
2041
2042	if (paDumpBranchTbl)
2043	{
2044	for (unsigned i = 0; i < cBranchTbls; i++)
2045	DBGFR3FlowBranchTblRelease(paDumpBranchTbl[i].hFlowBranchTbl);
2046	RTMemTmpFree(paDumpBranchTbl);
2047	}
2048
2049	if (hCfgIt)
2050	DBGFR3FlowItDestroy(hCfgIt);
2051	if (hFlowBranchTblIt)
2052	DBGFR3FlowBranchTblItDestroy(hFlowBranchTblIt);
2053
2054	return rc;
2055	}
2056
2057
2058	/**
2059	* @callback_method_impl{FNDBGCCMD, The 'ucfg' command.}
2060	*/
2061	static DECLCALLBACK(int) dbgcCmdUnassembleCfg(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
2062	{
2063	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2064
2065	/*
2066	* Validate input.
2067	*/
2068	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
2069	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, -1, cArgs <= 1);
2070	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, cArgs == 0 \|\| DBGCVAR_ISPOINTER(paArgs[0].enmType));
2071
2072	if (!cArgs && !DBGCVAR_ISPOINTER(pDbgc->DisasmPos.enmType))
2073	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Don't know where to start disassembling");
2074
2075	/*
2076	* Check the desired mode.
2077	*/
2078	unsigned fFlags = DBGF_DISAS_FLAGS_UNPATCHED_BYTES \| DBGF_DISAS_FLAGS_ANNOTATE_PATCHED;
2079	bool fUseColor = false;
2080	switch (pCmd->pszCmd[4])
2081	{
2082	default: AssertFailed(); RT_FALL_THRU();
2083	case '\0': fFlags \|= DBGF_DISAS_FLAGS_DEFAULT_MODE; break;
2084	case '6': fFlags \|= DBGF_DISAS_FLAGS_64BIT_MODE; break;
2085	case '3': fFlags \|= DBGF_DISAS_FLAGS_32BIT_MODE; break;
2086	case '1': fFlags \|= DBGF_DISAS_FLAGS_16BIT_MODE; break;
2087	case 'v': fFlags \|= DBGF_DISAS_FLAGS_16BIT_REAL_MODE; break;
2088	case 'c': fUseColor = true; break;
2089	}
2090
2091	/** @todo should use DBGFADDRESS for everything */
2092
2093	/*
2094	* Find address.
2095	*/
2096	if (!cArgs)
2097	{
2098	if (!DBGCVAR_ISPOINTER(pDbgc->DisasmPos.enmType))
2099	{
2100	/** @todo Batch query CS, RIP, CPU mode and flags. */
2101	PVMCPU pVCpu = VMMR3GetCpuByIdU(pUVM, pDbgc->idCpu);
2102	if (CPUMIsGuestIn64BitCode(pVCpu))
2103	{
2104	pDbgc->DisasmPos.enmType = DBGCVAR_TYPE_GC_FLAT;
2105	pDbgc->SourcePos.u.GCFlat = CPUMGetGuestRIP(pVCpu);
2106	}
2107	else
2108	{
2109	pDbgc->DisasmPos.enmType = DBGCVAR_TYPE_GC_FAR;
2110	pDbgc->SourcePos.u.GCFar.off = CPUMGetGuestEIP(pVCpu);
2111	pDbgc->SourcePos.u.GCFar.sel = CPUMGetGuestCS(pVCpu);
2112	if ( (fFlags & DBGF_DISAS_FLAGS_MODE_MASK) == DBGF_DISAS_FLAGS_DEFAULT_MODE
2113	&& (CPUMGetGuestEFlags(pVCpu) & X86_EFL_VM))
2114	{
2115	fFlags &= ~DBGF_DISAS_FLAGS_MODE_MASK;
2116	fFlags \|= DBGF_DISAS_FLAGS_16BIT_REAL_MODE;
2117	}
2118	}
2119
2120	fFlags \|= DBGF_DISAS_FLAGS_CURRENT_GUEST;
2121	}
2122	else if ((fFlags & DBGF_DISAS_FLAGS_MODE_MASK) == DBGF_DISAS_FLAGS_DEFAULT_MODE && pDbgc->fDisasm)
2123	{
2124	fFlags &= ~DBGF_DISAS_FLAGS_MODE_MASK;
2125	fFlags \|= pDbgc->fDisasm & DBGF_DISAS_FLAGS_MODE_MASK;
2126	}
2127	pDbgc->DisasmPos.enmRangeType = DBGCVAR_RANGE_NONE;
2128	}
2129	else
2130	pDbgc->DisasmPos = paArgs[0];
2131	pDbgc->pLastPos = &pDbgc->DisasmPos;
2132
2133	/*
2134	* Range.
2135	*/
2136	switch (pDbgc->DisasmPos.enmRangeType)
2137	{
2138	case DBGCVAR_RANGE_NONE:
2139	pDbgc->DisasmPos.enmRangeType = DBGCVAR_RANGE_ELEMENTS;
2140	pDbgc->DisasmPos.u64Range = 10;
2141	break;
2142
2143	case DBGCVAR_RANGE_ELEMENTS:
2144	if (pDbgc->DisasmPos.u64Range > 2048)
2145	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Too many lines requested. Max is 2048 lines");
2146	break;
2147
2148	case DBGCVAR_RANGE_BYTES:
2149	if (pDbgc->DisasmPos.u64Range > 65536)
2150	return DBGCCmdHlpFail(pCmdHlp, pCmd, "The requested range is too big. Max is 64KB");
2151	break;
2152
2153	default:
2154	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Unknown range type %d", pDbgc->DisasmPos.enmRangeType);
2155	}
2156
2157	/*
2158	* Convert physical and host addresses to guest addresses.
2159	*/
2160	RTDBGAS hDbgAs = pDbgc->hDbgAs;
2161	int rc;
2162	switch (pDbgc->DisasmPos.enmType)
2163	{
2164	case DBGCVAR_TYPE_GC_FLAT:
2165	case DBGCVAR_TYPE_GC_FAR:
2166	break;
2167	case DBGCVAR_TYPE_GC_PHYS:
2168	hDbgAs = DBGF_AS_PHYS;
2169	RT_FALL_THRU();
2170	case DBGCVAR_TYPE_HC_FLAT:
2171	case DBGCVAR_TYPE_HC_PHYS:
2172	{
2173	DBGCVAR VarTmp;
2174	rc = DBGCCmdHlpEval(pCmdHlp, &VarTmp, "%%(%Dv)", &pDbgc->DisasmPos);
2175	if (RT_FAILURE(rc))
2176	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "failed to evaluate '%%(%Dv)'", &pDbgc->DisasmPos);
2177	pDbgc->DisasmPos = VarTmp;
2178	break;
2179	}
2180	default: AssertFailed(); break;
2181	}
2182
2183	DBGFADDRESS CurAddr;
2184	if ( (fFlags & DBGF_DISAS_FLAGS_MODE_MASK) == DBGF_DISAS_FLAGS_16BIT_REAL_MODE
2185	&& pDbgc->DisasmPos.enmType == DBGCVAR_TYPE_GC_FAR)
2186	DBGFR3AddrFromFlat(pUVM, &CurAddr, ((uint32_t)pDbgc->DisasmPos.u.GCFar.sel << 4) + pDbgc->DisasmPos.u.GCFar.off);
2187	else
2188	{
2189	rc = DBGCCmdHlpVarToDbgfAddr(pCmdHlp, &pDbgc->DisasmPos, &CurAddr);
2190	if (RT_FAILURE(rc))
2191	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGCCmdHlpVarToDbgfAddr failed on '%Dv'", &pDbgc->DisasmPos);
2192	}
2193
2194	DBGFFLOW hCfg;
2195	rc = DBGFR3FlowCreate(pUVM, pDbgc->idCpu, &CurAddr, 0 /cbDisasmMax/,
2196	DBGF_FLOW_CREATE_F_TRY_RESOLVE_INDIRECT_BRANCHES, fFlags, &hCfg);
2197	if (RT_SUCCESS(rc))
2198	{
2199	/* Dump the graph. */
2200	rc = dbgcCmdUnassembleCfgDump(hCfg, fUseColor, pCmdHlp);
2201	DBGFR3FlowRelease(hCfg);
2202	}
2203	else
2204	rc = DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGFR3FlowCreate failed on '%Dv'", &pDbgc->DisasmPos);
2205
2206	NOREF(pCmd);
2207	return rc;
2208	}
2209
2210
2211	/**
2212	* @callback_method_impl{FNDBGCCMD, The 'ls' command.}
2213	*/
2214	static DECLCALLBACK(int) dbgcCmdListSource(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
2215	{
2216	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2217
2218	/*
2219	* Validate input.
2220	*/
2221	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, cArgs <= 1);
2222	if (cArgs == 1)
2223	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, DBGCVAR_ISPOINTER(paArgs[0].enmType));
2224	if (!pUVM && !cArgs && !DBGCVAR_ISPOINTER(pDbgc->SourcePos.enmType))
2225	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Don't know where to start listing...");
2226	if (!pUVM && cArgs && DBGCVAR_ISGCPOINTER(paArgs[0].enmType))
2227	return DBGCCmdHlpFail(pCmdHlp, pCmd, "GC address but no VM");
2228
2229	/*
2230	* Find address.
2231	*/
2232	if (!cArgs)
2233	{
2234	if (!DBGCVAR_ISPOINTER(pDbgc->SourcePos.enmType))
2235	{
2236	PVMCPU pVCpu = VMMR3GetCpuByIdU(pUVM, pDbgc->idCpu);
2237	pDbgc->SourcePos.enmType = DBGCVAR_TYPE_GC_FAR;
2238	pDbgc->SourcePos.u.GCFar.off = CPUMGetGuestEIP(pVCpu);
2239	pDbgc->SourcePos.u.GCFar.sel = CPUMGetGuestCS(pVCpu);
2240	}
2241	pDbgc->SourcePos.enmRangeType = DBGCVAR_RANGE_NONE;
2242	}
2243	else
2244	pDbgc->SourcePos = paArgs[0];
2245	pDbgc->pLastPos = &pDbgc->SourcePos;
2246
2247	/*
2248	* Ensure the source address is flat GC.
2249	*/
2250	switch (pDbgc->SourcePos.enmType)
2251	{
2252	case DBGCVAR_TYPE_GC_FLAT:
2253	break;
2254	case DBGCVAR_TYPE_GC_PHYS:
2255	case DBGCVAR_TYPE_GC_FAR:
2256	case DBGCVAR_TYPE_HC_FLAT:
2257	case DBGCVAR_TYPE_HC_PHYS:
2258	{
2259	int rc = DBGCCmdHlpEval(pCmdHlp, &pDbgc->SourcePos, "%%(%Dv)", &pDbgc->SourcePos);
2260	if (RT_FAILURE(rc))
2261	return DBGCCmdHlpPrintf(pCmdHlp, "error: Invalid address or address type. (rc=%d)\n", rc);
2262	break;
2263	}
2264	default: AssertFailed(); break;
2265	}
2266
2267	/*
2268	* Range.
2269	*/
2270	switch (pDbgc->SourcePos.enmRangeType)
2271	{
2272	case DBGCVAR_RANGE_NONE:
2273	pDbgc->SourcePos.enmRangeType = DBGCVAR_RANGE_ELEMENTS;
2274	pDbgc->SourcePos.u64Range = 10;
2275	break;
2276
2277	case DBGCVAR_RANGE_ELEMENTS:
2278	if (pDbgc->SourcePos.u64Range > 2048)
2279	return DBGCCmdHlpPrintf(pCmdHlp, "error: Too many lines requested. Max is 2048 lines.\n");
2280	break;
2281
2282	case DBGCVAR_RANGE_BYTES:
2283	if (pDbgc->SourcePos.u64Range > 65536)
2284	return DBGCCmdHlpPrintf(pCmdHlp, "error: The requested range is too big. Max is 64KB.\n");
2285	break;
2286
2287	default:
2288	return DBGCCmdHlpPrintf(pCmdHlp, "internal error: Unknown range type %d.\n", pDbgc->SourcePos.enmRangeType);
2289	}
2290
2291	/*
2292	* Do the disassembling.
2293	*/
2294	bool fFirst = 1;
2295	RTDBGLINE LinePrev = { 0, 0, 0, 0, 0, "" };
2296	int iRangeLeft = (int)pDbgc->SourcePos.u64Range;
2297	if (iRangeLeft == 0) /* kludge for 'r'. */
2298	iRangeLeft = -1;
2299	for (;;)
2300	{
2301	/*
2302	* Get line info.
2303	*/
2304	RTDBGLINE Line;
2305	RTGCINTPTR off;
2306	DBGFADDRESS SourcePosAddr;
2307	int rc = DBGCCmdHlpVarToDbgfAddr(pCmdHlp, &pDbgc->SourcePos, &SourcePosAddr);
2308	if (RT_FAILURE(rc))
2309	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGCCmdHlpVarToDbgfAddr(,%Dv)", &pDbgc->SourcePos);
2310	rc = DBGFR3AsLineByAddr(pUVM, pDbgc->hDbgAs, &SourcePosAddr, &off, &Line, NULL);
2311	if (RT_FAILURE(rc))
2312	return VINF_SUCCESS;
2313
2314	unsigned cLines = 0;
2315	if (memcmp(&Line, &LinePrev, sizeof(Line)))
2316	{
2317	/*
2318	* Print filenamename
2319	*/
2320	if (!fFirst && strcmp(Line.szFilename, LinePrev.szFilename))
2321	fFirst = true;
2322	if (fFirst)
2323	{
2324	rc = DBGCCmdHlpPrintf(pCmdHlp, "[%s @ %d]\n", Line.szFilename, Line.uLineNo);
2325	if (RT_FAILURE(rc))
2326	return rc;
2327	}
2328
2329	/*
2330	* Try open the file and read the line.
2331	*/
2332	FILE *phFile = fopen(Line.szFilename, "r");
2333	if (phFile)
2334	{
2335	/* Skip ahead to the desired line. */
2336	char szLine[4096];
2337	unsigned cBefore = fFirst ? RT_MIN(2, Line.uLineNo - 1) : Line.uLineNo - LinePrev.uLineNo - 1;
2338	if (cBefore > 7)
2339	cBefore = 0;
2340	unsigned cLeft = Line.uLineNo - cBefore;
2341	while (cLeft > 0)
2342	{
2343	szLine[0] = '\0';
2344	if (!fgets(szLine, sizeof(szLine), phFile))
2345	break;
2346	cLeft--;
2347	}
2348	if (!cLeft)
2349	{
2350	/* print the before lines */
2351	for (;;)
2352	{
2353	size_t cch = strlen(szLine);
2354	while (cch > 0 && (szLine[cch - 1] == '\r' \|\| szLine[cch - 1] == '\n' \|\| RT_C_IS_SPACE(szLine[cch - 1])) )
2355	szLine[--cch] = '\0';
2356	if (cBefore-- <= 0)
2357	break;
2358
2359	rc = DBGCCmdHlpPrintf(pCmdHlp, " %4d: %s\n", Line.uLineNo - cBefore - 1, szLine);
2360	szLine[0] = '\0';
2361	const char *pszShutUpGcc = fgets(szLine, sizeof(szLine), phFile); NOREF(pszShutUpGcc);
2362	cLines++;
2363	}
2364	/* print the actual line */
2365	rc = DBGCCmdHlpPrintf(pCmdHlp, "%08llx %4d: %s\n", Line.Address, Line.uLineNo, szLine);
2366	}
2367	fclose(phFile);
2368	if (RT_FAILURE(rc))
2369	return rc;
2370	fFirst = false;
2371	}
2372	else
2373	return DBGCCmdHlpPrintf(pCmdHlp, "Warning: couldn't open source file '%s'\n", Line.szFilename);
2374
2375	LinePrev = Line;
2376	}
2377
2378
2379	/*
2380	* Advance
2381	*/
2382	if (iRangeLeft < 0) /* 'r' */
2383	break;
2384	if (pDbgc->SourcePos.enmRangeType == DBGCVAR_RANGE_ELEMENTS)
2385	iRangeLeft -= cLines;
2386	else
2387	iRangeLeft -= 1;
2388	rc = DBGCCmdHlpEval(pCmdHlp, &pDbgc->SourcePos, "(%Dv) + %x", &pDbgc->SourcePos, 1);
2389	if (RT_FAILURE(rc))
2390	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Expression: (%Dv) + %x\n", &pDbgc->SourcePos, 1);
2391	if (iRangeLeft <= 0)
2392	break;
2393	}
2394
2395	NOREF(pCmd);
2396	return 0;
2397	}
2398
2399
2400	/**
2401	* @callback_method_impl{FNDBGCCMD, The 'r' command.}
2402	*/
2403	static DECLCALLBACK(int) dbgcCmdReg(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
2404	{
2405	return dbgcCmdRegGuest(pCmd, pCmdHlp, pUVM, paArgs, cArgs);
2406	}
2407
2408
2409	/**
2410	* @callback_method_impl{FNDBGCCMD, Common worker for the dbgcCmdReg*()
2411	* commands.}
2412	*/
2413	static DECLCALLBACK(int) dbgcCmdRegCommon(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs,
2414	const char *pszPrefix)
2415	{
2416	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2417	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, cArgs == 1 \|\| cArgs == 2 \|\| cArgs == 3);
2418	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, paArgs[0].enmType == DBGCVAR_TYPE_STRING
2419	\|\| paArgs[0].enmType == DBGCVAR_TYPE_SYMBOL);
2420
2421	/*
2422	* Parse the register name and kind.
2423	*/
2424	const char *pszReg = paArgs[0].u.pszString;
2425	if (*pszReg == '@')
2426	pszReg++;
2427	VMCPUID idCpu = pDbgc->idCpu;
2428	if (*pszPrefix)
2429	idCpu \|= DBGFREG_HYPER_VMCPUID;
2430	if (*pszReg == '.')
2431	{
2432	pszReg++;
2433	idCpu \|= DBGFREG_HYPER_VMCPUID;
2434	}
2435	const char * const pszActualPrefix = idCpu & DBGFREG_HYPER_VMCPUID ? "." : "";
2436
2437	/*
2438	* Query the register type & value (the setter needs the type).
2439	*/
2440	DBGFREGVALTYPE enmType;
2441	DBGFREGVAL Value;
2442	int rc = DBGFR3RegNmQuery(pUVM, idCpu, pszReg, &Value, &enmType);
2443	if (RT_FAILURE(rc))
2444	{
2445	if (rc == VERR_DBGF_REGISTER_NOT_FOUND)
2446	return DBGCCmdHlpVBoxError(pCmdHlp, VERR_INVALID_PARAMETER, "Unknown register: '%s%s'.\n",
2447	pszActualPrefix, pszReg);
2448	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "DBGFR3RegNmQuery failed querying '%s%s': %Rrc.\n",
2449	pszActualPrefix, pszReg, rc);
2450	}
2451	if (cArgs == 1)
2452	{
2453	/*
2454	* Show the register.
2455	*/
2456	char szValue[160];
2457	rc = DBGFR3RegFormatValue(szValue, sizeof(szValue), &Value, enmType, true /fSpecial/);
2458	if (RT_SUCCESS(rc))
2459	rc = DBGCCmdHlpPrintf(pCmdHlp, "%s%s=%s\n", pszActualPrefix, pszReg, szValue);
2460	else
2461	rc = DBGCCmdHlpVBoxError(pCmdHlp, rc, "DBGFR3RegFormatValue failed: %Rrc.\n", rc);
2462	}
2463	else
2464	{
2465	DBGCVAR NewValueTmp;
2466	PCDBGCVAR pNewValue;
2467	if (cArgs == 3)
2468	{
2469	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 1, paArgs[1].enmType == DBGCVAR_TYPE_STRING);
2470	if (strcmp(paArgs[1].u.pszString, "="))
2471	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Second argument must be '='.");
2472	pNewValue = &paArgs[2];
2473	}
2474	else
2475	{
2476	/* Not possible to convince the parser to support both codeview and
2477	windbg syntax and make the equal sign optional. Try help it. */
2478	/** @todo make DBGCCmdHlpConvert do more with strings. */
2479	rc = DBGCCmdHlpConvert(pCmdHlp, &paArgs[1], DBGCVAR_TYPE_NUMBER, true /fConvSyms/, &NewValueTmp);
2480	if (RT_FAILURE(rc))
2481	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "The last argument must be a value or valid symbol.");
2482	pNewValue = &NewValueTmp;
2483	}
2484
2485	/*
2486	* Modify the register.
2487	*/
2488	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 1, pNewValue->enmType == DBGCVAR_TYPE_NUMBER);
2489	if (enmType != DBGFREGVALTYPE_DTR)
2490	{
2491	enmType = DBGFREGVALTYPE_U64;
2492	rc = DBGCCmdHlpVarToNumber(pCmdHlp, pNewValue, &Value.u64);
2493	}
2494	else
2495	{
2496	enmType = DBGFREGVALTYPE_DTR;
2497	rc = DBGCCmdHlpVarToNumber(pCmdHlp, pNewValue, &Value.dtr.u64Base);
2498	if (RT_SUCCESS(rc) && pNewValue->enmRangeType != DBGCVAR_RANGE_NONE)
2499	Value.dtr.u32Limit = (uint32_t)pNewValue->u64Range;
2500	}
2501	if (RT_SUCCESS(rc))
2502	{
2503	rc = DBGFR3RegNmSet(pUVM, idCpu, pszReg, &Value, enmType);
2504	if (RT_FAILURE(rc))
2505	rc = DBGCCmdHlpVBoxError(pCmdHlp, rc, "DBGFR3RegNmSet failed settings '%s%s': %Rrc\n",
2506	pszActualPrefix, pszReg, rc);
2507	if (rc != VINF_SUCCESS)
2508	DBGCCmdHlpPrintf(pCmdHlp, "%s: warning: %Rrc\n", pCmd->pszCmd, rc);
2509	}
2510	else
2511	rc = DBGCCmdHlpVBoxError(pCmdHlp, rc, "DBGFR3RegFormatValue failed: %Rrc.\n", rc);
2512	}
2513	return rc;
2514	}
2515
2516
2517	/**
2518	* @callback_method_impl{FNDBGCCMD,
2519	* The 'rg'\, 'rg64' and 'rg32' commands\, worker for 'r'.}
2520	*/
2521	static DECLCALLBACK(int) dbgcCmdRegGuest(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
2522	{
2523	/*
2524	* Show all registers our selves.
2525	*/
2526	if (cArgs == 0)
2527	{
2528	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2529	bool const f64BitMode = !strcmp(pCmd->pszCmd, "rg64")
2530	\|\| ( strcmp(pCmd->pszCmd, "rg32") != 0
2531	&& DBGFR3CpuIsIn64BitCode(pUVM, pDbgc->idCpu));
2532	return DBGCCmdHlpRegPrintf(pCmdHlp, pDbgc->idCpu, f64BitMode, pDbgc->fRegTerse);
2533	}
2534	return dbgcCmdRegCommon(pCmd, pCmdHlp, pUVM, paArgs, cArgs, "");
2535	}
2536
2537
2538	/**
2539	* @callback_method_impl{FNDBGCCMD, The 'rt' command.}
2540	*/
2541	static DECLCALLBACK(int) dbgcCmdRegTerse(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
2542	{
2543	NOREF(pCmd); NOREF(pUVM); NOREF(paArgs); NOREF(cArgs);
2544
2545	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2546	pDbgc->fRegTerse = !pDbgc->fRegTerse;
2547	return DBGCCmdHlpPrintf(pCmdHlp, pDbgc->fRegTerse ? "info: Terse register info.\n" : "info: Verbose register info.\n");
2548	}
2549
2550
2551	/**
2552	* @callback_method_impl{FNDBGCCMD, The 'pr' and 'tr' commands.}
2553	*/
2554	static DECLCALLBACK(int) dbgcCmdStepTraceToggle(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
2555	{
2556	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2557	Assert(cArgs == 0); NOREF(pCmd); NOREF(pUVM); NOREF(paArgs); NOREF(cArgs);
2558
2559	/* Note! windbg accepts 'r' as a flag to 'p', 'pa', 'pc', 'pt', 't',
2560	'ta', 'tc' and 'tt'. We've simplified it. */
2561	pDbgc->fStepTraceRegs = !pDbgc->fStepTraceRegs;
2562	return VINF_SUCCESS;
2563	}
2564
2565
2566	/**
2567	* @callback_method_impl{FNDBGCCMD, The 'p'\, 'pc'\, 'pt'\, 't'\, 'tc'\, and 'tt' commands.}
2568	*/
2569	static DECLCALLBACK(int) dbgcCmdStepTrace(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
2570	{
2571	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2572	if (cArgs != 0)
2573	return DBGCCmdHlpFail(pCmdHlp, pCmd,
2574	"Sorry, but the '%s' command does not currently implement any arguments.\n", pCmd->pszCmd);
2575
2576	/* The 'count' has to be implemented by DBGC, whereas the
2577	filtering is taken care of by DBGF. */
2578
2579	/*
2580	* Convert the command to DBGF_STEP_F_XXX and other API input.
2581	*/
2582	//DBGFADDRESS StackPop;
2583	PDBGFADDRESS pStackPop = NULL;
2584	RTGCPTR cbStackPop = 0;
2585	uint32_t cMaxSteps = pCmd->pszCmd[0] == 'p' ? _512K : _64K;
2586	uint32_t fFlags = pCmd->pszCmd[0] == 'p' ? DBGF_STEP_F_OVER : DBGF_STEP_F_INTO;
2587	if (pCmd->pszCmd[1] == 'c')
2588	fFlags \|= DBGF_STEP_F_STOP_ON_CALL;
2589	else if (pCmd->pszCmd[1] == 't')
2590	fFlags \|= DBGF_STEP_F_STOP_ON_RET;
2591	else if (pCmd->pszCmd[0] != 'p')
2592	cMaxSteps = 1;
2593	else
2594	{
2595	/** @todo consider passing RSP + 1 in for 'p' and something else sensible for
2596	* the 'pt' command. */
2597	}
2598
2599	int rc = DBGFR3StepEx(pUVM, pDbgc->idCpu, fFlags, NULL, pStackPop, cbStackPop, cMaxSteps);
2600	if (RT_SUCCESS(rc))
2601	pDbgc->fReady = false;
2602	else
2603	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGFR3StepEx(,,%#x,) failed", fFlags);
2604
2605	NOREF(pCmd); NOREF(paArgs); NOREF(cArgs);
2606	return rc;
2607	}
2608
2609
2610	/**
2611	* @callback_method_impl{FNDBGCCMD, The 'pa' and 'ta' commands.}
2612	*/
2613	static DECLCALLBACK(int) dbgcCmdStepTraceTo(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
2614	{
2615	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2616	if (cArgs != 1)
2617	return DBGCCmdHlpFail(pCmdHlp, pCmd,
2618	"Sorry, but the '%s' command only implements a single argument at present.\n", pCmd->pszCmd);
2619	DBGFADDRESS Address;
2620	int rc = pCmdHlp->pfnVarToDbgfAddr(pCmdHlp, &paArgs[0], &Address);
2621	if (RT_FAILURE(rc))
2622	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "VarToDbgfAddr(,%Dv,)\n", &paArgs[0]);
2623
2624	uint32_t cMaxSteps = pCmd->pszCmd[0] == 'p' ? _512K : 1;
2625	uint32_t fFlags = pCmd->pszCmd[0] == 'p' ? DBGF_STEP_F_OVER : DBGF_STEP_F_INTO;
2626	rc = DBGFR3StepEx(pUVM, pDbgc->idCpu, fFlags, &Address, NULL, 0, cMaxSteps);
2627	if (RT_SUCCESS(rc))
2628	pDbgc->fReady = false;
2629	else
2630	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGFR3StepEx(,,%#x,) failed", fFlags);
2631	return rc;
2632	}
2633
2634
2635	/**
2636	* Helper that tries to resolve a far address to a symbol and formats it.
2637	*
2638	* @returns Pointer to symbol string on success, NULL if not resolved.
2639	* Free using RTStrFree.
2640	* @param pCmdHlp The command helper structure.
2641	* @param hAs The address space to use. NIL_RTDBGAS means no symbol resolving.
2642	* @param sel The selector part of the address.
2643	* @param off The offset part of the address.
2644	* @param pszPrefix How to prefix the symbol string.
2645	* @param pszSuffix How to suffix the symbol string.
2646	*/
2647	static char *dbgcCmdHlpFarAddrToSymbol(PDBGCCMDHLP pCmdHlp, RTDBGAS hAs, RTSEL sel, uint64_t off,
2648	const char pszPrefix, const char pszSuffix)
2649	{
2650	char *pszRet = NULL;
2651	if (hAs != NIL_RTDBGAS)
2652	{
2653	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2654	DBGFADDRESS Addr;
2655	int rc = DBGFR3AddrFromSelOff(pDbgc->pUVM, pDbgc->idCpu, &Addr, sel, off);
2656	if (RT_SUCCESS(rc))
2657	{
2658	RTGCINTPTR offDispSym = 0;
2659	PRTDBGSYMBOL pSymbol = DBGFR3AsSymbolByAddrA(pDbgc->pUVM, hAs, &Addr,
2660	RTDBGSYMADDR_FLAGS_GREATER_OR_EQUAL
2661	\| RTDBGSYMADDR_FLAGS_SKIP_ABS_IN_DEFERRED,
2662	&offDispSym, NULL);
2663	if (pSymbol)
2664	{
2665	if (offDispSym == 0)
2666	pszRet = RTStrAPrintf2("%s%s%s", pszPrefix, pSymbol->szName, pszSuffix);
2667	else if (offDispSym > 0)
2668	pszRet = RTStrAPrintf2("%s%s+%llx%s", pszPrefix, pSymbol->szName, (int64_t)offDispSym, pszSuffix);
2669	else
2670	pszRet = RTStrAPrintf2("%s%s-%llx%s", pszPrefix, pSymbol->szName, -(int64_t)offDispSym, pszSuffix);
2671	RTDbgSymbolFree(pSymbol);
2672	}
2673	}
2674	}
2675	return pszRet;
2676	}
2677
2678
2679	/**
2680	* @callback_method_impl{FNDBGCCMD, The 'k'\, 'kg' and 'kh' commands.}
2681	*/
2682	static DECLCALLBACK(int) dbgcCmdStack(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
2683	{
2684	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2685
2686	/*
2687	* Figure which context we're called for and start walking that stack.
2688	*/
2689	int rc;
2690	PCDBGFSTACKFRAME pFirstFrame;
2691	bool const fGuest = true;
2692	bool const fVerbose = pCmd->pszCmd[1] == 'v'
2693	\|\| (pCmd->pszCmd[1] != '\0' && pCmd->pszCmd[2] == 'v');
2694	rc = DBGFR3StackWalkBegin(pUVM, pDbgc->idCpu, fGuest ? DBGFCODETYPE_GUEST : DBGFCODETYPE_HYPER, &pFirstFrame);
2695	if (RT_FAILURE(rc))
2696	return DBGCCmdHlpPrintf(pCmdHlp, "Failed to begin stack walk, rc=%Rrc\n", rc);
2697
2698	/*
2699	* Print the frames.
2700	*/
2701	char szTmp[1024];
2702	uint32_t fBitFlags = 0;
2703	for (PCDBGFSTACKFRAME pFrame = pFirstFrame;
2704	pFrame;
2705	pFrame = DBGFR3StackWalkNext(pFrame))
2706	{
2707	uint32_t const fCurBitFlags = pFrame->fFlags & (DBGFSTACKFRAME_FLAGS_16BIT \| DBGFSTACKFRAME_FLAGS_32BIT \| DBGFSTACKFRAME_FLAGS_64BIT);
2708	if (fCurBitFlags & DBGFSTACKFRAME_FLAGS_16BIT)
2709	{
2710	if (fCurBitFlags != fBitFlags)
2711	pCmdHlp->pfnPrintf(pCmdHlp, NULL, "# SS:BP Ret SS:BP Ret CS:EIP Arg0 Arg1 Arg2 Arg3 CS:EIP / Symbol [line]\n");
2712	rc = DBGCCmdHlpPrintf(pCmdHlp, "%02x %04RX16:%04RX16 %04RX16:%04RX16 %04RX32:%08RX32 %08RX32 %08RX32 %08RX32 %08RX32",
2713	pFrame->iFrame,
2714	pFrame->AddrFrame.Sel,
2715	(uint16_t)pFrame->AddrFrame.off,
2716	pFrame->AddrReturnFrame.Sel,
2717	(uint16_t)pFrame->AddrReturnFrame.off,
2718	(uint32_t)pFrame->AddrReturnPC.Sel,
2719	(uint32_t)pFrame->AddrReturnPC.off,
2720	pFrame->Args.au32[0],
2721	pFrame->Args.au32[1],
2722	pFrame->Args.au32[2],
2723	pFrame->Args.au32[3]);
2724	}
2725	else if (fCurBitFlags & DBGFSTACKFRAME_FLAGS_32BIT)
2726	{
2727	if (fCurBitFlags != fBitFlags)
2728	pCmdHlp->pfnPrintf(pCmdHlp, NULL, "# EBP Ret EBP Ret CS:EIP Arg0 Arg1 Arg2 Arg3 CS:EIP / Symbol [line]\n");
2729	rc = DBGCCmdHlpPrintf(pCmdHlp, "%02x %08RX32 %08RX32 %04RX32:%08RX32 %08RX32 %08RX32 %08RX32 %08RX32",
2730	pFrame->iFrame,
2731	(uint32_t)pFrame->AddrFrame.off,
2732	(uint32_t)pFrame->AddrReturnFrame.off,
2733	(uint32_t)pFrame->AddrReturnPC.Sel,
2734	(uint32_t)pFrame->AddrReturnPC.off,
2735	pFrame->Args.au32[0],
2736	pFrame->Args.au32[1],
2737	pFrame->Args.au32[2],
2738	pFrame->Args.au32[3]);
2739	}
2740	else if (fCurBitFlags & DBGFSTACKFRAME_FLAGS_64BIT)
2741	{
2742	if (fCurBitFlags != fBitFlags)
2743	pCmdHlp->pfnPrintf(pCmdHlp, NULL, "# RBP Ret SS:RBP Ret RIP CS:RIP / Symbol [line]\n");
2744	rc = DBGCCmdHlpPrintf(pCmdHlp, "%02x %016RX64 %04RX16:%016RX64 %016RX64",
2745	pFrame->iFrame,
2746	(uint64_t)pFrame->AddrFrame.off,
2747	pFrame->AddrReturnFrame.Sel,
2748	(uint64_t)pFrame->AddrReturnFrame.off,
2749	(uint64_t)pFrame->AddrReturnPC.off);
2750	}
2751	if (RT_FAILURE(rc))
2752	break;
2753	if (!pFrame->pSymPC)
2754	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
2755	fCurBitFlags & DBGFSTACKFRAME_FLAGS_64BIT
2756	? " %RTsel:%016RGv"
2757	: fCurBitFlags & DBGFSTACKFRAME_FLAGS_32BIT
2758	? " %RTsel:%08RGv"
2759	: " %RTsel:%04RGv"
2760	, pFrame->AddrPC.Sel, pFrame->AddrPC.off);
2761	else
2762	{
2763	RTGCINTPTR offDisp = pFrame->AddrPC.FlatPtr - pFrame->pSymPC->Value; /** @todo this isn't 100% correct for segmented stuff. */
2764	if (offDisp > 0)
2765	rc = DBGCCmdHlpPrintf(pCmdHlp, " %s+%llx", pFrame->pSymPC->szName, (int64_t)offDisp);
2766	else if (offDisp < 0)
2767	rc = DBGCCmdHlpPrintf(pCmdHlp, " %s-%llx", pFrame->pSymPC->szName, -(int64_t)offDisp);
2768	else
2769	rc = DBGCCmdHlpPrintf(pCmdHlp, " %s", pFrame->pSymPC->szName);
2770	}
2771	if (RT_SUCCESS(rc) && pFrame->pLinePC)
2772	rc = DBGCCmdHlpPrintf(pCmdHlp, " [%s @ 0i%d]", pFrame->pLinePC->szFilename, pFrame->pLinePC->uLineNo);
2773	if (RT_SUCCESS(rc))
2774	rc = DBGCCmdHlpPrintf(pCmdHlp, "\n");
2775
2776	if (fVerbose && RT_SUCCESS(rc))
2777	{
2778	/*
2779	* Display verbose frame info.
2780	*/
2781	const char *pszRetType = "invalid";
2782	switch (pFrame->enmReturnType)
2783	{
2784	case RTDBGRETURNTYPE_NEAR16: pszRetType = "retn/16"; break;
2785	case RTDBGRETURNTYPE_NEAR32: pszRetType = "retn/32"; break;
2786	case RTDBGRETURNTYPE_NEAR64: pszRetType = "retn/64"; break;
2787	case RTDBGRETURNTYPE_FAR16: pszRetType = "retf/16"; break;
2788	case RTDBGRETURNTYPE_FAR32: pszRetType = "retf/32"; break;
2789	case RTDBGRETURNTYPE_FAR64: pszRetType = "retf/64"; break;
2790	case RTDBGRETURNTYPE_IRET16: pszRetType = "iret-16"; break;
2791	case RTDBGRETURNTYPE_IRET32: pszRetType = "iret/32s"; break;
2792	case RTDBGRETURNTYPE_IRET32_PRIV: pszRetType = "iret/32p"; break;
2793	case RTDBGRETURNTYPE_IRET32_V86: pszRetType = "iret/v86"; break;
2794	case RTDBGRETURNTYPE_IRET64: pszRetType = "iret/64"; break;
2795
2796	case RTDBGRETURNTYPE_END:
2797	case RTDBGRETURNTYPE_INVALID:
2798	case RTDBGRETURNTYPE_32BIT_HACK:
2799	break;
2800	}
2801	size_t cchLine = DBGCCmdHlpPrintfLen(pCmdHlp, " %s", pszRetType);
2802	if (pFrame->fFlags & DBGFSTACKFRAME_FLAGS_USED_UNWIND_INFO)
2803	cchLine += DBGCCmdHlpPrintfLen(pCmdHlp, " used-unwind-info");
2804	if (pFrame->fFlags & DBGFSTACKFRAME_FLAGS_USED_ODD_EVEN)
2805	cchLine += DBGCCmdHlpPrintfLen(pCmdHlp, " used-odd-even");
2806	if (pFrame->fFlags & DBGFSTACKFRAME_FLAGS_REAL_V86)
2807	cchLine += DBGCCmdHlpPrintfLen(pCmdHlp, " real-v86");
2808	if (pFrame->fFlags & DBGFSTACKFRAME_FLAGS_MAX_DEPTH)
2809	cchLine += DBGCCmdHlpPrintfLen(pCmdHlp, " max-depth");
2810	if (pFrame->fFlags & DBGFSTACKFRAME_FLAGS_TRAP_FRAME)
2811	cchLine += DBGCCmdHlpPrintfLen(pCmdHlp, " trap-frame");
2812
2813	if (pFrame->cSureRegs > 0)
2814	{
2815	cchLine = 1024; /* force new line */
2816	for (uint32_t i = 0; i < pFrame->cSureRegs; i++)
2817	{
2818	if (cchLine > 80)
2819	{
2820	DBGCCmdHlpPrintf(pCmdHlp, "\n ");
2821	cchLine = 2;
2822	}
2823
2824	szTmp[0] = '\0';
2825	DBGFR3RegFormatValue(szTmp, sizeof(szTmp), &pFrame->paSureRegs[i].Value,
2826	pFrame->paSureRegs[i].enmType, false);
2827	const char *pszName = pFrame->paSureRegs[i].enmReg != DBGFREG_END
2828	? DBGFR3RegCpuName(pUVM, pFrame->paSureRegs[i].enmReg, pFrame->paSureRegs[i].enmType)
2829	: pFrame->paSureRegs[i].pszName;
2830	cchLine += DBGCCmdHlpPrintfLen(pCmdHlp, " %s=%s", pszName, szTmp);
2831	}
2832	}
2833
2834	if (RT_SUCCESS(rc))
2835	rc = DBGCCmdHlpPrintf(pCmdHlp, "\n");
2836	}
2837
2838	if (RT_FAILURE(rc))
2839	break;
2840
2841	fBitFlags = fCurBitFlags;
2842	}
2843
2844	DBGFR3StackWalkEnd(pFirstFrame);
2845
2846	NOREF(paArgs); NOREF(cArgs);
2847	return rc;
2848	}
2849
2850
2851	/**
2852	* Worker function that displays one descriptor entry (GDT, LDT, IDT).
2853	*
2854	* @returns pfnPrintf status code.
2855	* @param pCmdHlp The DBGC command helpers.
2856	* @param pDesc The descriptor to display.
2857	* @param iEntry The descriptor entry number.
2858	* @param fHyper Whether the selector belongs to the hypervisor or not.
2859	* @param hAs Address space to use when resolving symbols.
2860	* @param pfDblEntry Where to indicate whether the entry is two entries wide.
2861	* Optional.
2862	*/
2863	static int dbgcCmdDumpDTWorker64(PDBGCCMDHLP pCmdHlp, PCX86DESC64 pDesc, unsigned iEntry, bool fHyper, RTDBGAS hAs,
2864	bool *pfDblEntry)
2865	{
2866	/* GUEST64 */
2867	int rc;
2868
2869	const char *pszHyper = fHyper ? " HYPER" : "";
2870	const char *pszPresent = pDesc->Gen.u1Present ? "P " : "NP";
2871	if (pDesc->Gen.u1DescType)
2872	{
2873	static const char * const s_apszTypes[] =
2874	{
2875	"DataRO", /* 0 Read-Only */
2876	"DataRO", /* 1 Read-Only - Accessed */
2877	"DataRW", /* 2 Read/Write */
2878	"DataRW", /* 3 Read/Write - Accessed */
2879	"DownRO", /* 4 Expand-down, Read-Only */
2880	"DownRO", /* 5 Expand-down, Read-Only - Accessed */
2881	"DownRW", /* 6 Expand-down, Read/Write */
2882	"DownRW", /* 7 Expand-down, Read/Write - Accessed */
2883	"CodeEO", /* 8 Execute-Only */
2884	"CodeEO", /* 9 Execute-Only - Accessed */
2885	"CodeER", /* A Execute/Readable */
2886	"CodeER", /* B Execute/Readable - Accessed */
2887	"ConfE0", /* C Conforming, Execute-Only */
2888	"ConfE0", /* D Conforming, Execute-Only - Accessed */
2889	"ConfER", /* E Conforming, Execute/Readable */
2890	"ConfER" /* F Conforming, Execute/Readable - Accessed */
2891	};
2892	const char *pszAccessed = pDesc->Gen.u4Type & RT_BIT(0) ? "A " : "NA";
2893	const char *pszGranularity = pDesc->Gen.u1Granularity ? "G" : " ";
2894	const char *pszBig = pDesc->Gen.u1DefBig ? "BIG" : " ";
2895	uint32_t u32Base = X86DESC_BASE(pDesc);
2896	uint32_t cbLimit = X86DESC_LIMIT_G(pDesc);
2897
2898	rc = DBGCCmdHlpPrintf(pCmdHlp, "%04x %s Bas=%08x Lim=%08x DPL=%d %s %s %s %s AVL=%d L=%d%s\n",
2899	iEntry, s_apszTypes[pDesc->Gen.u4Type], u32Base, cbLimit,
2900	pDesc->Gen.u2Dpl, pszPresent, pszAccessed, pszGranularity, pszBig,
2901	pDesc->Gen.u1Available, pDesc->Gen.u1Long, pszHyper);
2902	}
2903	else
2904	{
2905	static const char * const s_apszTypes[] =
2906	{
2907	"Ill-0 ", /* 0 0000 Reserved (Illegal) */
2908	"Ill-1 ", /* 1 0001 Available 16-bit TSS */
2909	"LDT ", /* 2 0010 LDT */
2910	"Ill-3 ", /* 3 0011 Busy 16-bit TSS */
2911	"Ill-4 ", /* 4 0100 16-bit Call Gate */
2912	"Ill-5 ", /* 5 0101 Task Gate */
2913	"Ill-6 ", /* 6 0110 16-bit Interrupt Gate */
2914	"Ill-7 ", /* 7 0111 16-bit Trap Gate */
2915	"Ill-8 ", /* 8 1000 Reserved (Illegal) */
2916	"Tss64A", /* 9 1001 Available 32-bit TSS */
2917	"Ill-A ", /* A 1010 Reserved (Illegal) */
2918	"Tss64B", /* B 1011 Busy 32-bit TSS */
2919	"Call64", /* C 1100 32-bit Call Gate */
2920	"Ill-D ", /* D 1101 Reserved (Illegal) */
2921	"Int64 ", /* E 1110 32-bit Interrupt Gate */
2922	"Trap64" /* F 1111 32-bit Trap Gate */
2923	};
2924	switch (pDesc->Gen.u4Type)
2925	{
2926	/* raw */
2927	case X86_SEL_TYPE_SYS_UNDEFINED:
2928	case X86_SEL_TYPE_SYS_UNDEFINED2:
2929	case X86_SEL_TYPE_SYS_UNDEFINED4:
2930	case X86_SEL_TYPE_SYS_UNDEFINED3:
2931	case X86_SEL_TYPE_SYS_286_TSS_AVAIL:
2932	case X86_SEL_TYPE_SYS_286_TSS_BUSY:
2933	case X86_SEL_TYPE_SYS_286_CALL_GATE:
2934	case X86_SEL_TYPE_SYS_286_INT_GATE:
2935	case X86_SEL_TYPE_SYS_286_TRAP_GATE:
2936	case X86_SEL_TYPE_SYS_TASK_GATE:
2937	rc = DBGCCmdHlpPrintf(pCmdHlp, "%04x %s %.8Rhxs DPL=%d %s%s\n",
2938	iEntry, s_apszTypes[pDesc->Gen.u4Type], pDesc,
2939	pDesc->Gen.u2Dpl, pszPresent, pszHyper);
2940	break;
2941
2942	case X86_SEL_TYPE_SYS_386_TSS_AVAIL:
2943	case X86_SEL_TYPE_SYS_386_TSS_BUSY:
2944	case X86_SEL_TYPE_SYS_LDT:
2945	{
2946	const char *pszBusy = pDesc->Gen.u4Type & RT_BIT(1) ? "B " : "NB";
2947	const char *pszBig = pDesc->Gen.u1DefBig ? "BIG" : " ";
2948	const char *pszLong = pDesc->Gen.u1Long ? "LONG" : " ";
2949
2950	uint64_t u64Base = X86DESC64_BASE(pDesc);
2951	uint32_t cbLimit = X86DESC_LIMIT_G(pDesc);
2952
2953	rc = DBGCCmdHlpPrintf(pCmdHlp, "%04x %s Bas=%016RX64 Lim=%08x DPL=%d %s %s %s %sAVL=%d R=%d%s\n",
2954	iEntry, s_apszTypes[pDesc->Gen.u4Type], u64Base, cbLimit,
2955	pDesc->Gen.u2Dpl, pszPresent, pszBusy, pszLong, pszBig,
2956	pDesc->Gen.u1Available, pDesc->Gen.u1Long \| (pDesc->Gen.u1DefBig << 1),
2957	pszHyper);
2958	if (pfDblEntry)
2959	*pfDblEntry = true;
2960	break;
2961	}
2962
2963	case X86_SEL_TYPE_SYS_386_CALL_GATE:
2964	{
2965	unsigned cParams = pDesc->au8[4] & 0x1f;
2966	const char *pszCountOf = pDesc->Gen.u4Type & RT_BIT(3) ? "DC" : "WC";
2967	RTSEL sel = pDesc->au16[1];
2968	uint64_t off = pDesc->au16[0]
2969	\| ((uint64_t)pDesc->au16[3] << 16)
2970	\| ((uint64_t)pDesc->Gen.u32BaseHigh3 << 32);
2971	char *pszSymbol = dbgcCmdHlpFarAddrToSymbol(pCmdHlp, hAs, sel, off, " (", ")");
2972	rc = DBGCCmdHlpPrintf(pCmdHlp, "%04x %s Sel:Off=%04x:%016RX64 DPL=%d %s %s=%d%s%s\n",
2973	iEntry, s_apszTypes[pDesc->Gen.u4Type], sel, off,
2974	pDesc->Gen.u2Dpl, pszPresent, pszCountOf, cParams, pszHyper, pszSymbol ? pszSymbol : "");
2975	RTStrFree(pszSymbol);
2976	if (pfDblEntry)
2977	*pfDblEntry = true;
2978	break;
2979	}
2980
2981	case X86_SEL_TYPE_SYS_386_INT_GATE:
2982	case X86_SEL_TYPE_SYS_386_TRAP_GATE:
2983	{
2984	RTSEL sel = pDesc->Gate.u16Sel;
2985	uint64_t off = pDesc->Gate.u16OffsetLow
2986	\| ((uint64_t)pDesc->Gate.u16OffsetHigh << 16)
2987	\| ((uint64_t)pDesc->Gate.u32OffsetTop << 32);
2988	char *pszSymbol = dbgcCmdHlpFarAddrToSymbol(pCmdHlp, hAs, sel, off, " (", ")");
2989	rc = DBGCCmdHlpPrintf(pCmdHlp, "%04x %s Sel:Off=%04x:%016RX64 DPL=%u %s IST=%u%s%s\n",
2990	iEntry, s_apszTypes[pDesc->Gate.u4Type], sel, off,
2991	pDesc->Gate.u2Dpl, pszPresent, pDesc->Gate.u3IST, pszHyper, pszSymbol ? pszSymbol : "");
2992	RTStrFree(pszSymbol);
2993	if (pfDblEntry)
2994	*pfDblEntry = true;
2995	break;
2996	}
2997
2998	/* impossible, just it's necessary to keep gcc happy. */
2999	default:
3000	return VINF_SUCCESS;
3001	}
3002	}
3003	return VINF_SUCCESS;
3004	}
3005
3006
3007	/**
3008	* Worker function that displays one descriptor entry (GDT, LDT, IDT).
3009	*
3010	* @returns pfnPrintf status code.
3011	* @param pCmdHlp The DBGC command helpers.
3012	* @param pDesc The descriptor to display.
3013	* @param iEntry The descriptor entry number.
3014	* @param fHyper Whether the selector belongs to the hypervisor or not.
3015	* @param hAs Address space to use when resolving symbols.
3016	*/
3017	static int dbgcCmdDumpDTWorker32(PDBGCCMDHLP pCmdHlp, PCX86DESC pDesc, unsigned iEntry, bool fHyper, RTDBGAS hAs)
3018	{
3019	int rc;
3020
3021	const char *pszHyper = fHyper ? " HYPER" : "";
3022	const char *pszPresent = pDesc->Gen.u1Present ? "P " : "NP";
3023	if (pDesc->Gen.u1DescType)
3024	{
3025	static const char * const s_apszTypes[] =
3026	{
3027	"DataRO", /* 0 Read-Only */
3028	"DataRO", /* 1 Read-Only - Accessed */
3029	"DataRW", /* 2 Read/Write */
3030	"DataRW", /* 3 Read/Write - Accessed */
3031	"DownRO", /* 4 Expand-down, Read-Only */
3032	"DownRO", /* 5 Expand-down, Read-Only - Accessed */
3033	"DownRW", /* 6 Expand-down, Read/Write */
3034	"DownRW", /* 7 Expand-down, Read/Write - Accessed */
3035	"CodeEO", /* 8 Execute-Only */
3036	"CodeEO", /* 9 Execute-Only - Accessed */
3037	"CodeER", /* A Execute/Readable */
3038	"CodeER", /* B Execute/Readable - Accessed */
3039	"ConfE0", /* C Conforming, Execute-Only */
3040	"ConfE0", /* D Conforming, Execute-Only - Accessed */
3041	"ConfER", /* E Conforming, Execute/Readable */
3042	"ConfER" /* F Conforming, Execute/Readable - Accessed */
3043	};
3044	const char *pszAccessed = pDesc->Gen.u4Type & RT_BIT(0) ? "A " : "NA";
3045	const char *pszGranularity = pDesc->Gen.u1Granularity ? "G" : " ";
3046	const char *pszBig = pDesc->Gen.u1DefBig ? "BIG" : " ";
3047	uint32_t u32Base = pDesc->Gen.u16BaseLow
3048	\| ((uint32_t)pDesc->Gen.u8BaseHigh1 << 16)
3049	\| ((uint32_t)pDesc->Gen.u8BaseHigh2 << 24);
3050	uint32_t cbLimit = pDesc->Gen.u16LimitLow \| (pDesc->Gen.u4LimitHigh << 16);
3051	if (pDesc->Gen.u1Granularity)
3052	cbLimit <<= PAGE_SHIFT;
3053
3054	rc = DBGCCmdHlpPrintf(pCmdHlp, "%04x %s Bas=%08x Lim=%08x DPL=%d %s %s %s %s AVL=%d L=%d%s\n",
3055	iEntry, s_apszTypes[pDesc->Gen.u4Type], u32Base, cbLimit,
3056	pDesc->Gen.u2Dpl, pszPresent, pszAccessed, pszGranularity, pszBig,
3057	pDesc->Gen.u1Available, pDesc->Gen.u1Long, pszHyper);
3058	}
3059	else
3060	{
3061	static const char * const s_apszTypes[] =
3062	{
3063	"Ill-0 ", /* 0 0000 Reserved (Illegal) */
3064	"Tss16A", /* 1 0001 Available 16-bit TSS */
3065	"LDT ", /* 2 0010 LDT */
3066	"Tss16B", /* 3 0011 Busy 16-bit TSS */
3067	"Call16", /* 4 0100 16-bit Call Gate */
3068	"TaskG ", /* 5 0101 Task Gate */
3069	"Int16 ", /* 6 0110 16-bit Interrupt Gate */
3070	"Trap16", /* 7 0111 16-bit Trap Gate */
3071	"Ill-8 ", /* 8 1000 Reserved (Illegal) */
3072	"Tss32A", /* 9 1001 Available 32-bit TSS */
3073	"Ill-A ", /* A 1010 Reserved (Illegal) */
3074	"Tss32B", /* B 1011 Busy 32-bit TSS */
3075	"Call32", /* C 1100 32-bit Call Gate */
3076	"Ill-D ", /* D 1101 Reserved (Illegal) */
3077	"Int32 ", /* E 1110 32-bit Interrupt Gate */
3078	"Trap32" /* F 1111 32-bit Trap Gate */
3079	};
3080	switch (pDesc->Gen.u4Type)
3081	{
3082	/* raw */
3083	case X86_SEL_TYPE_SYS_UNDEFINED:
3084	case X86_SEL_TYPE_SYS_UNDEFINED2:
3085	case X86_SEL_TYPE_SYS_UNDEFINED4:
3086	case X86_SEL_TYPE_SYS_UNDEFINED3:
3087	rc = DBGCCmdHlpPrintf(pCmdHlp, "%04x %s %.8Rhxs DPL=%d %s%s\n",
3088	iEntry, s_apszTypes[pDesc->Gen.u4Type], pDesc,
3089	pDesc->Gen.u2Dpl, pszPresent, pszHyper);
3090	break;
3091
3092	case X86_SEL_TYPE_SYS_286_TSS_AVAIL:
3093	case X86_SEL_TYPE_SYS_386_TSS_AVAIL:
3094	case X86_SEL_TYPE_SYS_286_TSS_BUSY:
3095	case X86_SEL_TYPE_SYS_386_TSS_BUSY:
3096	case X86_SEL_TYPE_SYS_LDT:
3097	{
3098	const char *pszGranularity = pDesc->Gen.u1Granularity ? "G" : " ";
3099	const char *pszBusy = pDesc->Gen.u4Type & RT_BIT(1) ? "B " : "NB";
3100	const char *pszBig = pDesc->Gen.u1DefBig ? "BIG" : " ";
3101	uint32_t u32Base = pDesc->Gen.u16BaseLow
3102	\| ((uint32_t)pDesc->Gen.u8BaseHigh1 << 16)
3103	\| ((uint32_t)pDesc->Gen.u8BaseHigh2 << 24);
3104	uint32_t cbLimit = pDesc->Gen.u16LimitLow \| (pDesc->Gen.u4LimitHigh << 16);
3105	if (pDesc->Gen.u1Granularity)
3106	cbLimit <<= PAGE_SHIFT;
3107
3108	rc = DBGCCmdHlpPrintf(pCmdHlp, "%04x %s Bas=%08x Lim=%08x DPL=%d %s %s %s %s AVL=%d R=%d%s\n",
3109	iEntry, s_apszTypes[pDesc->Gen.u4Type], u32Base, cbLimit,
3110	pDesc->Gen.u2Dpl, pszPresent, pszBusy, pszGranularity, pszBig,
3111	pDesc->Gen.u1Available, pDesc->Gen.u1Long \| (pDesc->Gen.u1DefBig << 1),
3112	pszHyper);
3113	break;
3114	}
3115
3116	case X86_SEL_TYPE_SYS_TASK_GATE:
3117	{
3118	rc = DBGCCmdHlpPrintf(pCmdHlp, "%04x %s TSS=%04x DPL=%d %s%s\n",
3119	iEntry, s_apszTypes[pDesc->Gen.u4Type], pDesc->au16[1],
3120	pDesc->Gen.u2Dpl, pszPresent, pszHyper);
3121	break;
3122	}
3123
3124	case X86_SEL_TYPE_SYS_286_CALL_GATE:
3125	case X86_SEL_TYPE_SYS_386_CALL_GATE:
3126	{
3127	unsigned cParams = pDesc->au8[4] & 0x1f;
3128	const char *pszCountOf = pDesc->Gen.u4Type & RT_BIT(3) ? "DC" : "WC";
3129	RTSEL sel = pDesc->au16[1];
3130	uint32_t off = pDesc->au16[0] \| ((uint32_t)pDesc->au16[3] << 16);
3131	char *pszSymbol = dbgcCmdHlpFarAddrToSymbol(pCmdHlp, hAs, sel, off, " (", ")");
3132	rc = DBGCCmdHlpPrintf(pCmdHlp, "%04x %s Sel:Off=%04x:%08x DPL=%d %s %s=%d%s%s\n",
3133	iEntry, s_apszTypes[pDesc->Gen.u4Type], sel, off,
3134	pDesc->Gen.u2Dpl, pszPresent, pszCountOf, cParams, pszHyper, pszSymbol ? pszSymbol : "");
3135	RTStrFree(pszSymbol);
3136	break;
3137	}
3138
3139	case X86_SEL_TYPE_SYS_286_INT_GATE:
3140	case X86_SEL_TYPE_SYS_386_INT_GATE:
3141	case X86_SEL_TYPE_SYS_286_TRAP_GATE:
3142	case X86_SEL_TYPE_SYS_386_TRAP_GATE:
3143	{
3144	RTSEL sel = pDesc->au16[1];
3145	uint32_t off = pDesc->au16[0] \| ((uint32_t)pDesc->au16[3] << 16);
3146	char *pszSymbol = dbgcCmdHlpFarAddrToSymbol(pCmdHlp, hAs, sel, off, " (", ")");
3147	rc = DBGCCmdHlpPrintf(pCmdHlp, "%04x %s Sel:Off=%04x:%08x DPL=%d %s%s%s\n",
3148	iEntry, s_apszTypes[pDesc->Gen.u4Type], sel, off,
3149	pDesc->Gen.u2Dpl, pszPresent, pszHyper, pszSymbol ? pszSymbol : "");
3150	RTStrFree(pszSymbol);
3151	break;
3152	}
3153
3154	/* impossible, just it's necessary to keep gcc happy. */
3155	default:
3156	return VINF_SUCCESS;
3157	}
3158	}
3159	return rc;
3160	}
3161
3162
3163	/**
3164	* @callback_method_impl{FNDBGCCMD, The 'dg'\, 'dga'\, 'dl' and 'dla' commands.}
3165	*/
3166	static DECLCALLBACK(int) dbgcCmdDumpDT(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
3167	{
3168	/*
3169	* Validate input.
3170	*/
3171	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
3172
3173	/*
3174	* Get the CPU mode, check which command variation this is
3175	* and fix a default parameter if needed.
3176	*/
3177	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
3178	PVMCPU pVCpu = VMMR3GetCpuByIdU(pUVM, pDbgc->idCpu);
3179	CPUMMODE enmMode = CPUMGetGuestMode(pVCpu);
3180	bool fGdt = pCmd->pszCmd[1] == 'g';
3181	bool fAll = pCmd->pszCmd[2] == 'a';
3182	RTSEL SelTable = fGdt ? 0 : X86_SEL_LDT;
3183
3184	DBGCVAR Var;
3185	if (!cArgs)
3186	{
3187	cArgs = 1;
3188	paArgs = &Var;
3189	Var.enmType = DBGCVAR_TYPE_NUMBER;
3190	Var.u.u64Number = fGdt ? 0 : 4;
3191	Var.enmRangeType = DBGCVAR_RANGE_ELEMENTS;
3192	Var.u64Range = 1024;
3193	}
3194
3195	/*
3196	* Process the arguments.
3197	*/
3198	for (unsigned i = 0; i < cArgs; i++)
3199	{
3200	/*
3201	* Retrieve the selector value from the argument.
3202	* The parser may confuse pointers and numbers if more than one
3203	* argument is given, that that into account.
3204	*/
3205	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, i, paArgs[i].enmType == DBGCVAR_TYPE_NUMBER \|\| DBGCVAR_ISPOINTER(paArgs[i].enmType));
3206	uint64_t u64;
3207	unsigned cSels = 1;
3208	switch (paArgs[i].enmType)
3209	{
3210	case DBGCVAR_TYPE_NUMBER:
3211	u64 = paArgs[i].u.u64Number;
3212	if (paArgs[i].enmRangeType != DBGCVAR_RANGE_NONE)
3213	cSels = RT_MIN(paArgs[i].u64Range, 1024);
3214	break;
3215	case DBGCVAR_TYPE_GC_FAR: u64 = paArgs[i].u.GCFar.sel; break;
3216	case DBGCVAR_TYPE_GC_FLAT: u64 = paArgs[i].u.GCFlat; break;
3217	case DBGCVAR_TYPE_GC_PHYS: u64 = paArgs[i].u.GCPhys; break;
3218	case DBGCVAR_TYPE_HC_FLAT: u64 = (uintptr_t)paArgs[i].u.pvHCFlat; break;
3219	case DBGCVAR_TYPE_HC_PHYS: u64 = paArgs[i].u.HCPhys; break;
3220	default: u64 = _64K; break;
3221	}
3222	if (u64 < _64K)
3223	{
3224	unsigned Sel = (RTSEL)u64;
3225
3226	/*
3227	* Dump the specified range.
3228	*/
3229	bool fSingle = cSels == 1;
3230	while ( cSels-- > 0
3231	&& Sel < _64K)
3232	{
3233	DBGFSELINFO SelInfo;
3234	int rc = DBGFR3SelQueryInfo(pUVM, pDbgc->idCpu, Sel \| SelTable, DBGFSELQI_FLAGS_DT_GUEST, &SelInfo);
3235	if (RT_SUCCESS(rc))
3236	{
3237	if (SelInfo.fFlags & DBGFSELINFO_FLAGS_REAL_MODE)
3238	rc = DBGCCmdHlpPrintf(pCmdHlp, "%04x RealM Bas=%04x Lim=%04x\n",
3239	Sel, (unsigned)SelInfo.GCPtrBase, (unsigned)SelInfo.cbLimit);
3240	else if ( fAll
3241	\|\| fSingle
3242	\|\| SelInfo.u.Raw.Gen.u1Present)
3243	{
3244	if (enmMode == CPUMMODE_PROTECTED)
3245	rc = dbgcCmdDumpDTWorker32(pCmdHlp, &SelInfo.u.Raw, Sel,
3246	!!(SelInfo.fFlags & DBGFSELINFO_FLAGS_HYPER), DBGF_AS_GLOBAL);
3247	else
3248	{
3249	bool fDblSkip = false;
3250	rc = dbgcCmdDumpDTWorker64(pCmdHlp, &SelInfo.u.Raw64, Sel,
3251	!!(SelInfo.fFlags & DBGFSELINFO_FLAGS_HYPER), DBGF_AS_GLOBAL, &fDblSkip);
3252	if (fDblSkip)
3253	Sel += 4;
3254	}
3255	}
3256	}
3257	else
3258	{
3259	rc = DBGCCmdHlpPrintf(pCmdHlp, "%04x %Rrc\n", Sel, rc);
3260	if (!fAll)
3261	return rc;
3262	}
3263	if (RT_FAILURE(rc))
3264	return rc;
3265
3266	/* next */
3267	Sel += 8;
3268	}
3269	}
3270	else
3271	DBGCCmdHlpPrintf(pCmdHlp, "error: %llx is out of bounds\n", u64);
3272	}
3273
3274	return VINF_SUCCESS;
3275	}
3276
3277
3278	/**
3279	* @callback_method_impl{FNDBGCCMD, The 'di' and 'dia' commands.}
3280	*/
3281	static DECLCALLBACK(int) dbgcCmdDumpIDT(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
3282	{
3283	/*
3284	* Validate input.
3285	*/
3286	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
3287
3288	/*
3289	* Establish some stuff like the current IDTR and CPU mode,
3290	* and fix a default parameter.
3291	*/
3292	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
3293	CPUMMODE enmMode = DBGCCmdHlpGetCpuMode(pCmdHlp);
3294	uint16_t cbLimit = 0;
3295	uint64_t GCFlat = 0;
3296	int rc = DBGFR3RegCpuQueryXdtr(pDbgc->pUVM, pDbgc->idCpu, DBGFREG_IDTR, &GCFlat, &cbLimit);
3297	if (RT_FAILURE(rc))
3298	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGFR3RegCpuQueryXdtr/DBGFREG_IDTR");
3299	unsigned cbEntry;
3300	switch (enmMode)
3301	{
3302	case CPUMMODE_REAL: cbEntry = sizeof(RTFAR16); break;
3303	case CPUMMODE_PROTECTED: cbEntry = sizeof(X86DESC); break;
3304	case CPUMMODE_LONG: cbEntry = sizeof(X86DESC64); break;
3305	default:
3306	return DBGCCmdHlpPrintf(pCmdHlp, "error: Invalid CPU mode %d.\n", enmMode);
3307	}
3308
3309	bool fAll = pCmd->pszCmd[2] == 'a';
3310	DBGCVAR Var;
3311	if (!cArgs)
3312	{
3313	cArgs = 1;
3314	paArgs = &Var;
3315	Var.enmType = DBGCVAR_TYPE_NUMBER;
3316	Var.u.u64Number = 0;
3317	Var.enmRangeType = DBGCVAR_RANGE_ELEMENTS;
3318	Var.u64Range = 256;
3319	}
3320
3321	/*
3322	* Process the arguments.
3323	*/
3324	for (unsigned i = 0; i < cArgs; i++)
3325	{
3326	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, i, paArgs[i].enmType == DBGCVAR_TYPE_NUMBER);
3327	if (paArgs[i].u.u64Number < 256)
3328	{
3329	RTGCUINTPTR iInt = (RTGCUINTPTR)paArgs[i].u.u64Number;
3330	unsigned cInts = paArgs[i].enmRangeType != DBGCVAR_RANGE_NONE
3331	? paArgs[i].u64Range
3332	: 1;
3333	bool fSingle = cInts == 1;
3334	while ( cInts-- > 0
3335	&& iInt < 256)
3336	{
3337	/*
3338	* Try read it.
3339	*/
3340	union
3341	{
3342	RTFAR16 Real;
3343	X86DESC Prot;
3344	X86DESC64 Long;
3345	} u;
3346	if (iInt * cbEntry + (cbEntry - 1) > cbLimit)
3347	{
3348	DBGCCmdHlpPrintf(pCmdHlp, "%04x not within the IDT\n", (unsigned)iInt);
3349	if (!fAll && !fSingle)
3350	return VINF_SUCCESS;
3351	}
3352	DBGCVAR AddrVar;
3353	AddrVar.enmType = DBGCVAR_TYPE_GC_FLAT;
3354	AddrVar.u.GCFlat = GCFlat + iInt * cbEntry;
3355	AddrVar.enmRangeType = DBGCVAR_RANGE_NONE;
3356	rc = pCmdHlp->pfnMemRead(pCmdHlp, &u, cbEntry, &AddrVar, NULL);
3357	if (RT_FAILURE(rc))
3358	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Reading IDT entry %#04x.\n", (unsigned)iInt);
3359
3360	/*
3361	* Display it.
3362	*/
3363	switch (enmMode)
3364	{
3365	case CPUMMODE_REAL:
3366	{
3367	char *pszSymbol = dbgcCmdHlpFarAddrToSymbol(pCmdHlp, DBGF_AS_GLOBAL, u.Real.sel, u.Real.off, " (", ")");
3368	rc = DBGCCmdHlpPrintf(pCmdHlp, "%04x %RTfp16%s\n", (unsigned)iInt, u.Real, pszSymbol ? pszSymbol : "");
3369	RTStrFree(pszSymbol);
3370	break;
3371	}
3372	case CPUMMODE_PROTECTED:
3373	if (fAll \|\| fSingle \|\| u.Prot.Gen.u1Present)
3374	rc = dbgcCmdDumpDTWorker32(pCmdHlp, &u.Prot, iInt, false, DBGF_AS_GLOBAL);
3375	break;
3376	case CPUMMODE_LONG:
3377	if (fAll \|\| fSingle \|\| u.Long.Gen.u1Present)
3378	rc = dbgcCmdDumpDTWorker64(pCmdHlp, &u.Long, iInt, false, DBGF_AS_GLOBAL, NULL);
3379	break;
3380	default: break; /* to shut up gcc */
3381	}
3382	if (RT_FAILURE(rc))
3383	return rc;
3384
3385	/* next */
3386	iInt++;
3387	}
3388	}
3389	else
3390	DBGCCmdHlpPrintf(pCmdHlp, "error: %llx is out of bounds (max 256)\n", paArgs[i].u.u64Number);
3391	}
3392
3393	return VINF_SUCCESS;
3394	}
3395
3396
3397	/**
3398	* @callback_method_impl{FNDBGCCMD,
3399	* The 'da'\, 'dq'\, 'dqs'\, 'dd'\, 'dds'\, 'dw'\, 'db'\, 'dp'\, 'dps'\,
3400	* and 'du' commands.}
3401	*/
3402	static DECLCALLBACK(int) dbgcCmdDumpMem(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
3403	{
3404	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
3405
3406	/*
3407	* Validate input.
3408	*/
3409	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, cArgs <= 1);
3410	if (cArgs == 1)
3411	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, DBGCVAR_ISPOINTER(paArgs[0].enmType));
3412	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
3413
3414	#define DBGC_DUMP_MEM_F_ASCII RT_BIT_32(31)
3415	#define DBGC_DUMP_MEM_F_UNICODE RT_BIT_32(30)
3416	#define DBGC_DUMP_MEM_F_FAR RT_BIT_32(29)
3417	#define DBGC_DUMP_MEM_F_SYMBOLS RT_BIT_32(28)
3418	#define DBGC_DUMP_MEM_F_SIZE UINT32_C(0x0000ffff)
3419
3420	/*
3421	* Figure out the element size.
3422	*/
3423	unsigned cbElement;
3424	bool fAscii = false;
3425	bool fUnicode = false;
3426	bool fFar = false;
3427	bool fSymbols = pCmd->pszCmd[1] && pCmd->pszCmd[2] == 's';
3428	switch (pCmd->pszCmd[1])
3429	{
3430	default:
3431	case 'b': cbElement = 1; break;
3432	case 'w': cbElement = 2; break;
3433	case 'd': cbElement = 4; break;
3434	case 'q': cbElement = 8; break;
3435	case 'a':
3436	cbElement = 1;
3437	fAscii = true;
3438	break;
3439	case 'F':
3440	cbElement = 4;
3441	fFar = true;
3442	break;
3443	case 'p':
3444	cbElement = DBGFR3CpuIsIn64BitCode(pUVM, pDbgc->idCpu) ? 8 : 4;
3445	break;
3446	case 'u':
3447	cbElement = 2;
3448	fUnicode = true;
3449	break;
3450	case '\0':
3451	fAscii = RT_BOOL(pDbgc->cbDumpElement & DBGC_DUMP_MEM_F_ASCII);
3452	fSymbols = RT_BOOL(pDbgc->cbDumpElement & DBGC_DUMP_MEM_F_SYMBOLS);
3453	fUnicode = RT_BOOL(pDbgc->cbDumpElement & DBGC_DUMP_MEM_F_UNICODE);
3454	fFar = RT_BOOL(pDbgc->cbDumpElement & DBGC_DUMP_MEM_F_FAR);
3455	cbElement = pDbgc->cbDumpElement & DBGC_DUMP_MEM_F_SIZE;
3456	if (!cbElement)
3457	cbElement = 1;
3458	break;
3459	}
3460	uint32_t const cbDumpElement = cbElement
3461	\| (fSymbols ? DBGC_DUMP_MEM_F_SYMBOLS : 0)
3462	\| (fFar ? DBGC_DUMP_MEM_F_FAR : 0)
3463	\| (fUnicode ? DBGC_DUMP_MEM_F_UNICODE : 0)
3464	\| (fAscii ? DBGC_DUMP_MEM_F_ASCII : 0);
3465	pDbgc->cbDumpElement = cbDumpElement;
3466
3467	/*
3468	* Find address.
3469	*/
3470	if (!cArgs)
3471	pDbgc->DumpPos.enmRangeType = DBGCVAR_RANGE_NONE;
3472	else
3473	pDbgc->DumpPos = paArgs[0];
3474
3475	/*
3476	* Range.
3477	*/
3478	switch (pDbgc->DumpPos.enmRangeType)
3479	{
3480	case DBGCVAR_RANGE_NONE:
3481	pDbgc->DumpPos.enmRangeType = DBGCVAR_RANGE_BYTES;
3482	pDbgc->DumpPos.u64Range = 0x60;
3483	break;
3484
3485	case DBGCVAR_RANGE_ELEMENTS:
3486	if (pDbgc->DumpPos.u64Range > 2048)
3487	return DBGCCmdHlpPrintf(pCmdHlp, "error: Too many elements requested. Max is 2048 elements.\n");
3488	pDbgc->DumpPos.enmRangeType = DBGCVAR_RANGE_BYTES;
3489	pDbgc->DumpPos.u64Range = (cbElement ? cbElement : 1) * pDbgc->DumpPos.u64Range;
3490	break;
3491
3492	case DBGCVAR_RANGE_BYTES:
3493	if (pDbgc->DumpPos.u64Range > 65536)
3494	return DBGCCmdHlpPrintf(pCmdHlp, "error: The requested range is too big. Max is 64KB.\n");
3495	break;
3496
3497	default:
3498	return DBGCCmdHlpPrintf(pCmdHlp, "internal error: Unknown range type %d.\n", pDbgc->DumpPos.enmRangeType);
3499	}
3500
3501	pDbgc->pLastPos = &pDbgc->DumpPos;
3502
3503	/*
3504	* Do the dumping.
3505	*/
3506	int cbLeft = (int)pDbgc->DumpPos.u64Range;
3507	uint8_t u16Prev = '\0';
3508	for (;;)
3509	{
3510	/*
3511	* Read memory.
3512	*/
3513	char achBuffer[16];
3514	size_t cbReq = RT_MIN((int)sizeof(achBuffer), cbLeft);
3515	size_t cb = RT_MIN((int)sizeof(achBuffer), cbLeft);
3516	int rc = pCmdHlp->pfnMemRead(pCmdHlp, &achBuffer, cbReq, &pDbgc->DumpPos, &cb);
3517	if (RT_FAILURE(rc))
3518	{
3519	if (u16Prev && u16Prev != '\n')
3520	DBGCCmdHlpPrintf(pCmdHlp, "\n");
3521	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Reading memory at %DV.\n", &pDbgc->DumpPos);
3522	}
3523
3524	/*
3525	* Display it.
3526	*/
3527	memset(&achBuffer[cb], 0, sizeof(achBuffer) - cb);
3528	if (!fAscii && !fUnicode)
3529	{
3530	DBGCCmdHlpPrintf(pCmdHlp, "%DV:", &pDbgc->DumpPos);
3531	unsigned i;
3532	for (i = 0; i < cb; i += cbElement)
3533	{
3534	const char *pszSpace = " ";
3535	if (cbElement <= 2 && i == 8)
3536	pszSpace = "-";
3537	switch (cbElement)
3538	{
3539	case 1:
3540	DBGCCmdHlpPrintf(pCmdHlp, "%s%02x", pszSpace, (uint8_t )&achBuffer[i]);
3541	break;
3542	case 2:
3543	DBGCCmdHlpPrintf(pCmdHlp, "%s%04x", pszSpace, (uint16_t )&achBuffer[i]);
3544	break;
3545	case 4:
3546	if (!fFar)
3547	DBGCCmdHlpPrintf(pCmdHlp, "%s%08x", pszSpace, (uint32_t )&achBuffer[i]);
3548	else
3549	DBGCCmdHlpPrintf(pCmdHlp, "%s%04x:%04x:",
3550	pszSpace, (uint16_t )&achBuffer[i + 2], (uint16_t )&achBuffer[i]);
3551	break;
3552	case 8:
3553	DBGCCmdHlpPrintf(pCmdHlp, "%s%016llx", pszSpace, (uint64_t )&achBuffer[i]);
3554	break;
3555	}
3556
3557	if (fSymbols)
3558	{
3559	/* Try lookup symbol for the above address. */
3560	DBGFADDRESS Addr;
3561	rc = VINF_SUCCESS;
3562	if (cbElement == 8)
3563	DBGFR3AddrFromFlat(pDbgc->pUVM, &Addr, (uint64_t )&achBuffer[i]);
3564	else if (!fFar)
3565	DBGFR3AddrFromFlat(pDbgc->pUVM, &Addr, (uint32_t )&achBuffer[i]);
3566	else
3567	rc = DBGFR3AddrFromSelOff(pDbgc->pUVM, pDbgc->idCpu, &Addr,
3568	(uint16_t )&achBuffer[i + 2], (uint16_t )&achBuffer[i]);
3569	if (RT_SUCCESS(rc))
3570	{
3571	RTINTPTR offDisp;
3572	RTDBGSYMBOL Symbol;
3573	rc = DBGFR3AsSymbolByAddr(pUVM, pDbgc->hDbgAs, &Addr,
3574	RTDBGSYMADDR_FLAGS_LESS_OR_EQUAL \| RTDBGSYMADDR_FLAGS_SKIP_ABS_IN_DEFERRED,
3575	&offDisp, &Symbol, NULL);
3576	if (RT_SUCCESS(rc))
3577	{
3578	if (!offDisp)
3579	rc = DBGCCmdHlpPrintf(pCmdHlp, " %s", Symbol.szName);
3580	else if (offDisp > 0)
3581	rc = DBGCCmdHlpPrintf(pCmdHlp, " %s + %RGv", Symbol.szName, offDisp);
3582	else
3583	rc = DBGCCmdHlpPrintf(pCmdHlp, " %s - %RGv", Symbol.szName, -offDisp);
3584	if (Symbol.cb > 0)
3585	rc = DBGCCmdHlpPrintf(pCmdHlp, " (LB %RGv)", Symbol.cb);
3586	}
3587	}
3588
3589	/* Next line prefix. */
3590	unsigned iNext = i + cbElement;
3591	if (iNext < cb)
3592	{
3593	DBGCVAR TmpPos = pDbgc->DumpPos;
3594	DBGCCmdHlpEval(pCmdHlp, &TmpPos, "(%Dv) + %x", &pDbgc->DumpPos, iNext);
3595	DBGCCmdHlpPrintf(pCmdHlp, "\n%DV:", &pDbgc->DumpPos);
3596	}
3597	}
3598	}
3599
3600	/* Chars column. */
3601	if (cbElement == 1)
3602	{
3603	while (i++ < sizeof(achBuffer))
3604	DBGCCmdHlpPrintf(pCmdHlp, " ");
3605	DBGCCmdHlpPrintf(pCmdHlp, " ");
3606	for (i = 0; i < cb; i += cbElement)
3607	{
3608	uint8_t u8 = (uint8_t )&achBuffer[i];
3609	if (RT_C_IS_PRINT(u8) && u8 < 127 && u8 >= 32)
3610	DBGCCmdHlpPrintf(pCmdHlp, "%c", u8);
3611	else
3612	DBGCCmdHlpPrintf(pCmdHlp, ".");
3613	}
3614	}
3615	rc = DBGCCmdHlpPrintf(pCmdHlp, "\n");
3616	}
3617	else
3618	{
3619	/*
3620	* We print up to the first zero and stop there.
3621	* Only printables + '\t' and '\n' are printed.
3622	*/
3623	if (!u16Prev)
3624	DBGCCmdHlpPrintf(pCmdHlp, "%DV:\n", &pDbgc->DumpPos);
3625	uint16_t u16 = '\0';
3626	unsigned i;
3627	for (i = 0; i < cb; i += cbElement)
3628	{
3629	u16Prev = u16;
3630	if (cbElement == 1)
3631	u16 = (uint8_t )&achBuffer[i];
3632	else
3633	u16 = (uint16_t )&achBuffer[i];
3634	if ( u16 < 127
3635	&& ( (RT_C_IS_PRINT(u16) && u16 >= 32)
3636	\|\| u16 == '\t'
3637	\|\| u16 == '\n'))
3638	DBGCCmdHlpPrintf(pCmdHlp, "%c", (int)u16);
3639	else if (!u16)
3640	break;
3641	else
3642	DBGCCmdHlpPrintf(pCmdHlp, "\\x%0x", cbElement 2, u16);
3643	}
3644	if (u16 == '\0')
3645	cb = cbLeft = i + 1;
3646	if (cbLeft - cb <= 0 && u16Prev != '\n')
3647	DBGCCmdHlpPrintf(pCmdHlp, "\n");
3648	}
3649
3650	/*
3651	* Advance
3652	*/
3653	cbLeft -= (int)cb;
3654	rc = DBGCCmdHlpEval(pCmdHlp, &pDbgc->DumpPos, "(%Dv) + %x", &pDbgc->DumpPos, cb);
3655	if (RT_FAILURE(rc))
3656	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Expression: (%Dv) + %x\n", &pDbgc->DumpPos, cb);
3657	if (cbLeft <= 0)
3658	break;
3659	}
3660
3661	NOREF(pCmd);
3662	return VINF_SUCCESS;
3663	}
3664
3665
3666	/**
3667	* Best guess at which paging mode currently applies to the guest
3668	* paging structures.
3669	*
3670	* This have to come up with a decent answer even when the guest
3671	* is in non-paged protected mode or real mode.
3672	*
3673	* @returns cr3.
3674	* @param pDbgc The DBGC instance.
3675	* @param pfPAE Where to store the page address extension indicator.
3676	* @param pfLME Where to store the long mode enabled indicator.
3677	* @param pfPSE Where to store the page size extension indicator.
3678	* @param pfPGE Where to store the page global enabled indicator.
3679	* @param pfNXE Where to store the no-execution enabled indicator.
3680	*/
3681	static RTGCPHYS dbgcGetGuestPageMode(PDBGC pDbgc, bool pfPAE, bool pfLME, bool pfPSE, bool pfPGE, bool *pfNXE)
3682	{
3683	PVMCPU pVCpu = VMMR3GetCpuByIdU(pDbgc->pUVM, pDbgc->idCpu);
3684	RTGCUINTREG cr4 = CPUMGetGuestCR4(pVCpu);
3685	*pfPSE = !!(cr4 & X86_CR4_PSE);
3686	*pfPGE = !!(cr4 & X86_CR4_PGE);
3687	if (cr4 & X86_CR4_PAE)
3688	{
3689	*pfPSE = true;
3690	*pfPAE = true;
3691	}
3692	else
3693	*pfPAE = false;
3694
3695	*pfLME = CPUMGetGuestMode(pVCpu) == CPUMMODE_LONG;
3696	pfNXE = false; / GUEST64 GUESTNX */
3697	return CPUMGetGuestCR3(pVCpu);
3698	}
3699
3700
3701	/**
3702	* Determine the shadow paging mode.
3703	*
3704	* @returns cr3.
3705	* @param pDbgc The DBGC instance.
3706	* @param pfPAE Where to store the page address extension indicator.
3707	* @param pfLME Where to store the long mode enabled indicator.
3708	* @param pfPSE Where to store the page size extension indicator.
3709	* @param pfPGE Where to store the page global enabled indicator.
3710	* @param pfNXE Where to store the no-execution enabled indicator.
3711	*/
3712	static RTHCPHYS dbgcGetShadowPageMode(PDBGC pDbgc, bool pfPAE, bool pfLME, bool pfPSE, bool pfPGE, bool *pfNXE)
3713	{
3714	PVMCPU pVCpu = VMMR3GetCpuByIdU(pDbgc->pUVM, pDbgc->idCpu);
3715
3716	*pfPSE = true;
3717	*pfPGE = false;
3718	switch (PGMGetShadowMode(pVCpu))
3719	{
3720	default:
3721	case PGMMODE_32_BIT:
3722	pfPAE = pfLME = *pfNXE = false;
3723	break;
3724	case PGMMODE_PAE:
3725	pfLME = pfNXE = false;
3726	*pfPAE = true;
3727	break;
3728	case PGMMODE_PAE_NX:
3729	*pfLME = false;
3730	pfPAE = pfNXE = true;
3731	break;
3732	case PGMMODE_AMD64:
3733	*pfNXE = false;
3734	pfPAE = pfLME = true;
3735	break;
3736	case PGMMODE_AMD64_NX:
3737	pfPAE = pfLME = *pfNXE = true;
3738	break;
3739	}
3740	return PGMGetHyperCR3(pVCpu);
3741	}
3742
3743
3744	/**
3745	* @callback_method_impl{FNDBGCCMD,
3746	* The 'dpd'\, 'dpda'\, 'dpdb'\, 'dpdg' and 'dpdh' commands.}
3747	*/
3748	static DECLCALLBACK(int) dbgcCmdDumpPageDir(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
3749	{
3750	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
3751
3752	/*
3753	* Validate input.
3754	*/
3755	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, cArgs <= 1);
3756	if (cArgs == 1 && pCmd->pszCmd[3] == 'a')
3757	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, DBGCVAR_ISPOINTER(paArgs[0].enmType));
3758	if (cArgs == 1 && pCmd->pszCmd[3] != 'a')
3759	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, paArgs[0].enmType == DBGCVAR_TYPE_NUMBER
3760	\|\| DBGCVAR_ISPOINTER(paArgs[0].enmType));
3761	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
3762
3763	/*
3764	* Guest or shadow page directories? Get the paging parameters.
3765	*/
3766	bool fGuest = pCmd->pszCmd[3] != 'h';
3767	if (!pCmd->pszCmd[3] \|\| pCmd->pszCmd[3] == 'a')
3768	fGuest = paArgs[0].enmType == DBGCVAR_TYPE_NUMBER ? true : DBGCVAR_ISGCPOINTER(paArgs[0].enmType);
3769
3770	bool fPAE, fLME, fPSE, fPGE, fNXE;
3771	uint64_t cr3 = fGuest
3772	? dbgcGetGuestPageMode(pDbgc, &fPAE, &fLME, &fPSE, &fPGE, &fNXE)
3773	: dbgcGetShadowPageMode(pDbgc, &fPAE, &fLME, &fPSE, &fPGE, &fNXE);
3774	const unsigned cbEntry = fPAE ? sizeof(X86PTEPAE) : sizeof(X86PTE);
3775
3776	/*
3777	* Setup default argument if none was specified.
3778	* Fix address / index confusion.
3779	*/
3780	DBGCVAR VarDefault;
3781	if (!cArgs)
3782	{
3783	if (pCmd->pszCmd[3] == 'a')
3784	{
3785	if (fLME \|\| fPAE)
3786	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");
3787	if (fGuest)
3788	DBGCVAR_INIT_GC_PHYS(&VarDefault, cr3);
3789	else
3790	DBGCVAR_INIT_HC_PHYS(&VarDefault, cr3);
3791	}
3792	else
3793	DBGCVAR_INIT_GC_FLAT(&VarDefault, 0);
3794	paArgs = &VarDefault;
3795	cArgs = 1;
3796	}
3797	else if (paArgs[0].enmType == DBGCVAR_TYPE_NUMBER)
3798	{
3799	/* If it's a number (not an address), it's an index, so convert it to an address. */
3800	Assert(pCmd->pszCmd[3] != 'a');
3801	VarDefault = paArgs[0];
3802	if (fPAE)
3803	return DBGCCmdHlpPrintf(pCmdHlp, "PDE indexing is only implemented for 32-bit paging.\n");
3804	if (VarDefault.u.u64Number >= PAGE_SIZE / cbEntry)
3805	return DBGCCmdHlpPrintf(pCmdHlp, "PDE index is out of range [0..%d].\n", PAGE_SIZE / cbEntry - 1);
3806	VarDefault.u.u64Number <<= X86_PD_SHIFT;
3807	VarDefault.enmType = DBGCVAR_TYPE_GC_FLAT;
3808	paArgs = &VarDefault;
3809	}
3810
3811	/*
3812	* Locate the PDE to start displaying at.
3813	*
3814	* The 'dpda' command takes the address of a PDE, while the others are guest
3815	* virtual address which PDEs should be displayed. So, 'dpda' is rather simple
3816	* while the others require us to do all the tedious walking thru the paging
3817	* hierarchy to find the intended PDE.
3818	*/
3819	unsigned iEntry = ~0U; /* The page directory index. ~0U for 'dpta'. */
3820	DBGCVAR VarGCPtr = { NULL, }; /* The GC address corresponding to the current PDE (iEntry != ~0U). */
3821	DBGCVAR VarPDEAddr; /* The address of the current PDE. */
3822	unsigned cEntries; /* The number of entries to display. */
3823	unsigned cEntriesMax; /* The max number of entries to display. */
3824	int rc;
3825	if (pCmd->pszCmd[3] == 'a')
3826	{
3827	VarPDEAddr = paArgs[0];
3828	switch (VarPDEAddr.enmRangeType)
3829	{
3830	case DBGCVAR_RANGE_BYTES: cEntries = VarPDEAddr.u64Range / cbEntry; break;
3831	case DBGCVAR_RANGE_ELEMENTS: cEntries = VarPDEAddr.u64Range; break;
3832	default: cEntries = 10; break;
3833	}
3834	cEntriesMax = PAGE_SIZE / cbEntry;
3835	}
3836	else
3837	{
3838	/*
3839	* Determine the range.
3840	*/
3841	switch (paArgs[0].enmRangeType)
3842	{
3843	case DBGCVAR_RANGE_BYTES: cEntries = paArgs[0].u64Range / PAGE_SIZE; break;
3844	case DBGCVAR_RANGE_ELEMENTS: cEntries = paArgs[0].u64Range; break;
3845	default: cEntries = 10; break;
3846	}
3847
3848	/*
3849	* Normalize the input address, it must be a flat GC address.
3850	*/
3851	rc = DBGCCmdHlpEval(pCmdHlp, &VarGCPtr, "%%(%Dv)", &paArgs[0]);
3852	if (RT_FAILURE(rc))
3853	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "%%(%Dv)", &paArgs[0]);
3854	if (VarGCPtr.enmType == DBGCVAR_TYPE_HC_FLAT)
3855	{
3856	VarGCPtr.u.GCFlat = (uintptr_t)VarGCPtr.u.pvHCFlat;
3857	VarGCPtr.enmType = DBGCVAR_TYPE_GC_FLAT;
3858	}
3859	if (fPAE)
3860	VarGCPtr.u.GCFlat &= ~(((RTGCPTR)1 << X86_PD_PAE_SHIFT) - 1);
3861	else
3862	VarGCPtr.u.GCFlat &= ~(((RTGCPTR)1 << X86_PD_SHIFT) - 1);
3863
3864	/*
3865	* Do the paging walk until we get to the page directory.
3866	*/
3867	DBGCVAR VarCur;
3868	if (fGuest)
3869	DBGCVAR_INIT_GC_PHYS(&VarCur, cr3);
3870	else
3871	DBGCVAR_INIT_HC_PHYS(&VarCur, cr3);
3872	if (fLME)
3873	{
3874	/* Page Map Level 4 Lookup. */
3875	/* Check if it's a valid address first? */
3876	VarCur.u.u64Number &= X86_PTE_PAE_PG_MASK;
3877	VarCur.u.u64Number += (((uint64_t)VarGCPtr.u.GCFlat >> X86_PML4_SHIFT) & X86_PML4_MASK) * sizeof(X86PML4E);
3878	X86PML4E Pml4e;
3879	rc = pCmdHlp->pfnMemRead(pCmdHlp, &Pml4e, sizeof(Pml4e), &VarCur, NULL);
3880	if (RT_FAILURE(rc))
3881	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "Reading PML4E memory at %DV.\n", &VarCur);
3882	if (!Pml4e.n.u1Present)
3883	return DBGCCmdHlpPrintf(pCmdHlp, "Page directory pointer table is not present for %Dv.\n", &VarGCPtr);
3884
3885	VarCur.u.u64Number = Pml4e.u & X86_PML4E_PG_MASK;
3886	Assert(fPAE);
3887	}
3888	if (fPAE)
3889	{
3890	/* Page directory pointer table. */
3891	X86PDPE Pdpe;
3892	VarCur.u.u64Number += ((VarGCPtr.u.GCFlat >> X86_PDPT_SHIFT) & X86_PDPT_MASK_PAE) * sizeof(Pdpe);
3893	rc = pCmdHlp->pfnMemRead(pCmdHlp, &Pdpe, sizeof(Pdpe), &VarCur, NULL);
3894	if (RT_FAILURE(rc))
3895	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "Reading PDPE memory at %DV.\n", &VarCur);
3896	if (!Pdpe.n.u1Present)
3897	return DBGCCmdHlpPrintf(pCmdHlp, "Page directory is not present for %Dv.\n", &VarGCPtr);
3898
3899	iEntry = (VarGCPtr.u.GCFlat >> X86_PD_PAE_SHIFT) & X86_PD_PAE_MASK;
3900	VarPDEAddr = VarCur;
3901	VarPDEAddr.u.u64Number = Pdpe.u & X86_PDPE_PG_MASK;
3902	VarPDEAddr.u.u64Number += iEntry * sizeof(X86PDEPAE);
3903	}
3904	else
3905	{
3906	/* 32-bit legacy - CR3 == page directory. */
3907	iEntry = (VarGCPtr.u.GCFlat >> X86_PD_SHIFT) & X86_PD_MASK;
3908	VarPDEAddr = VarCur;
3909	VarPDEAddr.u.u64Number += iEntry * sizeof(X86PDE);
3910	}
3911	cEntriesMax = (PAGE_SIZE - iEntry) / cbEntry;
3912	}
3913
3914	/* adjust cEntries */
3915	cEntries = RT_MAX(1, cEntries);
3916	cEntries = RT_MIN(cEntries, cEntriesMax);
3917
3918	/*
3919	* The display loop.
3920	*/
3921	DBGCCmdHlpPrintf(pCmdHlp, iEntry != ~0U ? "%DV (index %#x):\n" : "%DV:\n",
3922	&VarPDEAddr, iEntry);
3923	do
3924	{
3925	/*
3926	* Read.
3927	*/
3928	X86PDEPAE Pde;
3929	Pde.u = 0;
3930	rc = pCmdHlp->pfnMemRead(pCmdHlp, &Pde, cbEntry, &VarPDEAddr, NULL);
3931	if (RT_FAILURE(rc))
3932	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Reading PDE memory at %DV.\n", &VarPDEAddr);
3933
3934	/*
3935	* Display.
3936	*/
3937	if (iEntry != ~0U)
3938	{
3939	DBGCCmdHlpPrintf(pCmdHlp, "%03x %DV: ", iEntry, &VarGCPtr);
3940	iEntry++;
3941	}
3942	if (fPSE && Pde.b.u1Size)
3943	DBGCCmdHlpPrintf(pCmdHlp,
3944	fPAE
3945	? "%016llx big phys=%016llx %s %s %s %s %s avl=%02x %s %s %s %s %s"
3946	: "%08llx big phys=%08llx %s %s %s %s %s avl=%02x %s %s %s %s %s",
3947	Pde.u,
3948	Pde.u & X86_PDE_PAE_PG_MASK,
3949	Pde.b.u1Present ? "p " : "np",
3950	Pde.b.u1Write ? "w" : "r",
3951	Pde.b.u1User ? "u" : "s",
3952	Pde.b.u1Accessed ? "a " : "na",
3953	Pde.b.u1Dirty ? "d " : "nd",
3954	Pde.b.u3Available,
3955	Pde.b.u1Global ? (fPGE ? "g" : "G") : " ",
3956	Pde.b.u1WriteThru ? "pwt" : " ",
3957	Pde.b.u1CacheDisable ? "pcd" : " ",
3958	Pde.b.u1PAT ? "pat" : "",
3959	Pde.b.u1NoExecute ? (fNXE ? "nx" : "NX") : " ");
3960	else
3961	DBGCCmdHlpPrintf(pCmdHlp,
3962	fPAE
3963	? "%016llx 4kb phys=%016llx %s %s %s %s %s avl=%02x %s %s %s %s"
3964	: "%08llx 4kb phys=%08llx %s %s %s %s %s avl=%02x %s %s %s %s",
3965	Pde.u,
3966	Pde.u & X86_PDE_PAE_PG_MASK,
3967	Pde.n.u1Present ? "p " : "np",
3968	Pde.n.u1Write ? "w" : "r",
3969	Pde.n.u1User ? "u" : "s",
3970	Pde.n.u1Accessed ? "a " : "na",
3971	Pde.u & RT_BIT(6) ? "6 " : " ",
3972	Pde.n.u3Available,
3973	Pde.u & RT_BIT(8) ? "8" : " ",
3974	Pde.n.u1WriteThru ? "pwt" : " ",
3975	Pde.n.u1CacheDisable ? "pcd" : " ",
3976	Pde.u & RT_BIT(7) ? "7" : "",
3977	Pde.n.u1NoExecute ? (fNXE ? "nx" : "NX") : " ");
3978	if (Pde.u & UINT64_C(0x7fff000000000000))
3979	DBGCCmdHlpPrintf(pCmdHlp, " weird=%RX64", (Pde.u & UINT64_C(0x7fff000000000000)));
3980	rc = DBGCCmdHlpPrintf(pCmdHlp, "\n");
3981	if (RT_FAILURE(rc))
3982	return rc;
3983
3984	/*
3985	* Advance.
3986	*/
3987	VarPDEAddr.u.u64Number += cbEntry;
3988	if (iEntry != ~0U)
3989	VarGCPtr.u.GCFlat += fPAE ? RT_BIT_32(X86_PD_PAE_SHIFT) : RT_BIT_32(X86_PD_SHIFT);
3990	} while (cEntries-- > 0);
3991
3992	return VINF_SUCCESS;
3993	}
3994
3995
3996	/**
3997	* @callback_method_impl{FNDBGCCMD, The 'dpdb' command.}
3998	*/
3999	static DECLCALLBACK(int) dbgcCmdDumpPageDirBoth(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
4000	{
4001	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
4002	int rc1 = pCmdHlp->pfnExec(pCmdHlp, "dpdg %DV", &paArgs[0]);
4003	int rc2 = pCmdHlp->pfnExec(pCmdHlp, "dpdh %DV", &paArgs[0]);
4004	if (RT_FAILURE(rc1))
4005	return rc1;
4006	NOREF(pCmd); NOREF(paArgs); NOREF(cArgs);
4007	return rc2;
4008	}
4009
4010
4011	/**
4012	* @callback_method_impl{FNDBGCCMD, The 'dph*' commands and main part of 'm'.}
4013	*/
4014	static DECLCALLBACK(int) dbgcCmdDumpPageHierarchy(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
4015	{
4016	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
4017	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
4018
4019	/*
4020	* Figure the context and base flags.
4021	*/
4022	uint32_t fFlags = DBGFPGDMP_FLAGS_PAGE_INFO \| DBGFPGDMP_FLAGS_PRINT_CR3;
4023	if (pCmd->pszCmd[0] == 'm')
4024	fFlags \|= DBGFPGDMP_FLAGS_GUEST \| DBGFPGDMP_FLAGS_SHADOW;
4025	else if (pCmd->pszCmd[3] == '\0')
4026	fFlags \|= DBGFPGDMP_FLAGS_GUEST;
4027	else if (pCmd->pszCmd[3] == 'g')
4028	fFlags \|= DBGFPGDMP_FLAGS_GUEST;
4029	else if (pCmd->pszCmd[3] == 'h')
4030	fFlags \|= DBGFPGDMP_FLAGS_SHADOW;
4031	else
4032	AssertFailed();
4033
4034	if (pDbgc->cPagingHierarchyDumps == 0)
4035	fFlags \|= DBGFPGDMP_FLAGS_HEADER;
4036	pDbgc->cPagingHierarchyDumps = (pDbgc->cPagingHierarchyDumps + 1) % 42;
4037
4038	/*
4039	* Get the range.
4040	*/
4041	PCDBGCVAR pRange = cArgs > 0 ? &paArgs[0] : pDbgc->pLastPos;
4042	RTGCPTR GCPtrFirst = NIL_RTGCPTR;
4043	int rc = DBGCCmdHlpVarToFlatAddr(pCmdHlp, pRange, &GCPtrFirst);
4044	if (RT_FAILURE(rc))
4045	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Failed to convert %DV to a flat address: %Rrc", pRange, rc);
4046
4047	uint64_t cbRange;
4048	rc = DBGCCmdHlpVarGetRange(pCmdHlp, pRange, PAGE_SIZE, PAGE_SIZE * 8, &cbRange);
4049	if (RT_FAILURE(rc))
4050	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Failed to obtain the range of %DV: %Rrc", pRange, rc);
4051
4052	RTGCPTR GCPtrLast = RTGCPTR_MAX - GCPtrFirst;
4053	if (cbRange >= GCPtrLast)
4054	GCPtrLast = RTGCPTR_MAX;
4055	else if (!cbRange)
4056	GCPtrLast = GCPtrFirst;
4057	else
4058	GCPtrLast = GCPtrFirst + cbRange - 1;
4059
4060	/*
4061	* Do we have a CR3?
4062	*/
4063	uint64_t cr3 = 0;
4064	if (cArgs > 1)
4065	{
4066	if ((fFlags & (DBGFPGDMP_FLAGS_GUEST \| DBGFPGDMP_FLAGS_SHADOW)) == (DBGFPGDMP_FLAGS_GUEST \| DBGFPGDMP_FLAGS_SHADOW))
4067	return DBGCCmdHlpFail(pCmdHlp, pCmd, "No CR3 or mode arguments when dumping both context, please.");
4068	if (paArgs[1].enmType != DBGCVAR_TYPE_NUMBER)
4069	return DBGCCmdHlpFail(pCmdHlp, pCmd, "The CR3 argument is not a number: %DV", &paArgs[1]);
4070	cr3 = paArgs[1].u.u64Number;
4071	}
4072	else
4073	fFlags \|= DBGFPGDMP_FLAGS_CURRENT_CR3;
4074
4075	/*
4076	* Do we have a mode?
4077	*/
4078	if (cArgs > 2)
4079	{
4080	if (paArgs[2].enmType != DBGCVAR_TYPE_STRING)
4081	return DBGCCmdHlpFail(pCmdHlp, pCmd, "The mode argument is not a string: %DV", &paArgs[2]);
4082	static const struct MODETOFLAGS
4083	{
4084	const char *pszName;
4085	uint32_t fFlags;
4086	} s_aModeToFlags[] =
4087	{
4088	{ "ept", DBGFPGDMP_FLAGS_EPT },
4089	{ "legacy", 0 },
4090	{ "legacy-np", DBGFPGDMP_FLAGS_NP },
4091	{ "pse", DBGFPGDMP_FLAGS_PSE },
4092	{ "pse-np", DBGFPGDMP_FLAGS_PSE \| DBGFPGDMP_FLAGS_NP },
4093	{ "pae", DBGFPGDMP_FLAGS_PSE \| DBGFPGDMP_FLAGS_PAE },
4094	{ "pae-np", DBGFPGDMP_FLAGS_PSE \| DBGFPGDMP_FLAGS_PAE \| DBGFPGDMP_FLAGS_NP },
4095	{ "pae-nx", DBGFPGDMP_FLAGS_PSE \| DBGFPGDMP_FLAGS_PAE \| DBGFPGDMP_FLAGS_NXE },
4096	{ "pae-nx-np", DBGFPGDMP_FLAGS_PSE \| DBGFPGDMP_FLAGS_PAE \| DBGFPGDMP_FLAGS_NXE \| DBGFPGDMP_FLAGS_NP },
4097	{ "long", DBGFPGDMP_FLAGS_PSE \| DBGFPGDMP_FLAGS_PAE \| DBGFPGDMP_FLAGS_LME },
4098	{ "long-np", DBGFPGDMP_FLAGS_PSE \| DBGFPGDMP_FLAGS_PAE \| DBGFPGDMP_FLAGS_LME \| DBGFPGDMP_FLAGS_NP },
4099	{ "long-nx", DBGFPGDMP_FLAGS_PSE \| DBGFPGDMP_FLAGS_PAE \| DBGFPGDMP_FLAGS_LME \| DBGFPGDMP_FLAGS_NXE },
4100	{ "long-nx-np", DBGFPGDMP_FLAGS_PSE \| DBGFPGDMP_FLAGS_PAE \| DBGFPGDMP_FLAGS_LME \| DBGFPGDMP_FLAGS_NXE \| DBGFPGDMP_FLAGS_NP }
4101	};
4102	int i = RT_ELEMENTS(s_aModeToFlags);
4103	while (i-- > 0)
4104	if (!strcmp(s_aModeToFlags[i].pszName, paArgs[2].u.pszString))
4105	{
4106	fFlags \|= s_aModeToFlags[i].fFlags;
4107	break;
4108	}
4109	if (i < 0)
4110	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Unknown mode: \"%s\"", paArgs[2].u.pszString);
4111	}
4112	else
4113	fFlags \|= DBGFPGDMP_FLAGS_CURRENT_MODE;
4114
4115	/*
4116	* Call the worker.
4117	*/
4118	rc = DBGFR3PagingDumpEx(pUVM, pDbgc->idCpu, fFlags, cr3, GCPtrFirst, GCPtrLast, 99 /cMaxDepth/,
4119	DBGCCmdHlpGetDbgfOutputHlp(pCmdHlp));
4120	if (RT_FAILURE(rc))
4121	return DBGCCmdHlpFail(pCmdHlp, pCmd, "DBGFR3PagingDumpEx: %Rrc\n", rc);
4122	return VINF_SUCCESS;
4123	}
4124
4125
4126
4127	/**
4128	* @callback_method_impl{FNDBGCCMD, The 'dpg*' commands.}
4129	*/
4130	static DECLCALLBACK(int) dbgcCmdDumpPageTable(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
4131	{
4132	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
4133
4134	/*
4135	* Validate input.
4136	*/
4137	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, cArgs == 1);
4138	if (pCmd->pszCmd[3] == 'a')
4139	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, DBGCVAR_ISPOINTER(paArgs[0].enmType));
4140	else
4141	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, paArgs[0].enmType == DBGCVAR_TYPE_NUMBER
4142	\|\| DBGCVAR_ISPOINTER(paArgs[0].enmType));
4143	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
4144
4145	/*
4146	* Guest or shadow page tables? Get the paging parameters.
4147	*/
4148	bool fGuest = pCmd->pszCmd[3] != 'h';
4149	if (!pCmd->pszCmd[3] \|\| pCmd->pszCmd[3] == 'a')
4150	fGuest = paArgs[0].enmType == DBGCVAR_TYPE_NUMBER ? true : DBGCVAR_ISGCPOINTER(paArgs[0].enmType);
4151
4152	bool fPAE, fLME, fPSE, fPGE, fNXE;
4153	uint64_t cr3 = fGuest
4154	? dbgcGetGuestPageMode(pDbgc, &fPAE, &fLME, &fPSE, &fPGE, &fNXE)
4155	: dbgcGetShadowPageMode(pDbgc, &fPAE, &fLME, &fPSE, &fPGE, &fNXE);
4156	const unsigned cbEntry = fPAE ? sizeof(X86PTEPAE) : sizeof(X86PTE);
4157
4158	/*
4159	* Locate the PTE to start displaying at.
4160	*
4161	* The 'dpta' command takes the address of a PTE, while the others are guest
4162	* virtual address which PTEs should be displayed. So, 'pdta' is rather simple
4163	* while the others require us to do all the tedious walking thru the paging
4164	* hierarchy to find the intended PTE.
4165	*/
4166	unsigned iEntry = ~0U; /* The page table index. ~0U for 'dpta'. */
4167	DBGCVAR VarGCPtr; /* The GC address corresponding to the current PTE (iEntry != ~0U). */
4168	DBGCVAR VarPTEAddr; /* The address of the current PTE. */
4169	unsigned cEntries; /* The number of entries to display. */
4170	unsigned cEntriesMax; /* The max number of entries to display. */
4171	int rc;
4172	if (pCmd->pszCmd[3] == 'a')
4173	{
4174	VarPTEAddr = paArgs[0];
4175	switch (VarPTEAddr.enmRangeType)
4176	{
4177	case DBGCVAR_RANGE_BYTES: cEntries = VarPTEAddr.u64Range / cbEntry; break;
4178	case DBGCVAR_RANGE_ELEMENTS: cEntries = VarPTEAddr.u64Range; break;
4179	default: cEntries = 10; break;
4180	}
4181	cEntriesMax = PAGE_SIZE / cbEntry;
4182	}
4183	else
4184	{
4185	/*
4186	* Determine the range.
4187	*/
4188	switch (paArgs[0].enmRangeType)
4189	{
4190	case DBGCVAR_RANGE_BYTES: cEntries = paArgs[0].u64Range / PAGE_SIZE; break;
4191	case DBGCVAR_RANGE_ELEMENTS: cEntries = paArgs[0].u64Range; break;
4192	default: cEntries = 10; break;
4193	}
4194
4195	/*
4196	* Normalize the input address, it must be a flat GC address.
4197	*/
4198	rc = DBGCCmdHlpEval(pCmdHlp, &VarGCPtr, "%%(%Dv)", &paArgs[0]);
4199	if (RT_FAILURE(rc))
4200	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "%%(%Dv)", &paArgs[0]);
4201	if (VarGCPtr.enmType == DBGCVAR_TYPE_HC_FLAT)
4202	{
4203	VarGCPtr.u.GCFlat = (uintptr_t)VarGCPtr.u.pvHCFlat;
4204	VarGCPtr.enmType = DBGCVAR_TYPE_GC_FLAT;
4205	}
4206	VarGCPtr.u.GCFlat &= ~(RTGCPTR)PAGE_OFFSET_MASK;
4207
4208	/*
4209	* Do the paging walk until we get to the page table.
4210	*/
4211	DBGCVAR VarCur;
4212	if (fGuest)
4213	DBGCVAR_INIT_GC_PHYS(&VarCur, cr3);
4214	else
4215	DBGCVAR_INIT_HC_PHYS(&VarCur, cr3);
4216	if (fLME)
4217	{
4218	/* Page Map Level 4 Lookup. */
4219	/* Check if it's a valid address first? */
4220	VarCur.u.u64Number &= X86_PTE_PAE_PG_MASK;
4221	VarCur.u.u64Number += (((uint64_t)VarGCPtr.u.GCFlat >> X86_PML4_SHIFT) & X86_PML4_MASK) * sizeof(X86PML4E);
4222	X86PML4E Pml4e;
4223	rc = pCmdHlp->pfnMemRead(pCmdHlp, &Pml4e, sizeof(Pml4e), &VarCur, NULL);
4224	if (RT_FAILURE(rc))
4225	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "Reading PML4E memory at %DV.\n", &VarCur);
4226	if (!Pml4e.n.u1Present)
4227	return DBGCCmdHlpPrintf(pCmdHlp, "Page directory pointer table is not present for %Dv.\n", &VarGCPtr);
4228
4229	VarCur.u.u64Number = Pml4e.u & X86_PML4E_PG_MASK;
4230	Assert(fPAE);
4231	}
4232	if (fPAE)
4233	{
4234	/* Page directory pointer table. */
4235	X86PDPE Pdpe;
4236	VarCur.u.u64Number += ((VarGCPtr.u.GCFlat >> X86_PDPT_SHIFT) & X86_PDPT_MASK_PAE) * sizeof(Pdpe);
4237	rc = pCmdHlp->pfnMemRead(pCmdHlp, &Pdpe, sizeof(Pdpe), &VarCur, NULL);
4238	if (RT_FAILURE(rc))
4239	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "Reading PDPE memory at %DV.\n", &VarCur);
4240	if (!Pdpe.n.u1Present)
4241	return DBGCCmdHlpPrintf(pCmdHlp, "Page directory is not present for %Dv.\n", &VarGCPtr);
4242
4243	VarCur.u.u64Number = Pdpe.u & X86_PDPE_PG_MASK;
4244
4245	/* Page directory (PAE). */
4246	X86PDEPAE Pde;
4247	VarCur.u.u64Number += ((VarGCPtr.u.GCFlat >> X86_PD_PAE_SHIFT) & X86_PD_PAE_MASK) * sizeof(Pde);
4248	rc = pCmdHlp->pfnMemRead(pCmdHlp, &Pde, sizeof(Pde), &VarCur, NULL);
4249	if (RT_FAILURE(rc))
4250	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "Reading PDE memory at %DV.\n", &VarCur);
4251	if (!Pde.n.u1Present)
4252	return DBGCCmdHlpPrintf(pCmdHlp, "Page table is not present for %Dv.\n", &VarGCPtr);
4253	if (fPSE && Pde.n.u1Size)
4254	return pCmdHlp->pfnExec(pCmdHlp, "dpd%s %Dv L3", &pCmd->pszCmd[3], &VarGCPtr);
4255
4256	iEntry = (VarGCPtr.u.GCFlat >> X86_PT_PAE_SHIFT) & X86_PT_PAE_MASK;
4257	VarPTEAddr = VarCur;
4258	VarPTEAddr.u.u64Number = Pde.u & X86_PDE_PAE_PG_MASK;
4259	VarPTEAddr.u.u64Number += iEntry * sizeof(X86PTEPAE);
4260	}
4261	else
4262	{
4263	/* Page directory (legacy). */
4264	X86PDE Pde;
4265	VarCur.u.u64Number += ((VarGCPtr.u.GCFlat >> X86_PD_SHIFT) & X86_PD_MASK) * sizeof(Pde);
4266	rc = pCmdHlp->pfnMemRead(pCmdHlp, &Pde, sizeof(Pde), &VarCur, NULL);
4267	if (RT_FAILURE(rc))
4268	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "Reading PDE memory at %DV.\n", &VarCur);
4269	if (!Pde.n.u1Present)
4270	return DBGCCmdHlpPrintf(pCmdHlp, "Page table is not present for %Dv.\n", &VarGCPtr);
4271	if (fPSE && Pde.n.u1Size)
4272	return pCmdHlp->pfnExec(pCmdHlp, "dpd%s %Dv L3", &pCmd->pszCmd[3], &VarGCPtr);
4273
4274	iEntry = (VarGCPtr.u.GCFlat >> X86_PT_SHIFT) & X86_PT_MASK;
4275	VarPTEAddr = VarCur;
4276	VarPTEAddr.u.u64Number = Pde.u & X86_PDE_PG_MASK;
4277	VarPTEAddr.u.u64Number += iEntry * sizeof(X86PTE);
4278	}
4279	cEntriesMax = (PAGE_SIZE - iEntry) / cbEntry;
4280	}
4281
4282	/* adjust cEntries */
4283	cEntries = RT_MAX(1, cEntries);
4284	cEntries = RT_MIN(cEntries, cEntriesMax);
4285
4286	/*
4287	* The display loop.
4288	*/
4289	DBGCCmdHlpPrintf(pCmdHlp, iEntry != ~0U ? "%DV (base %DV / index %#x):\n" : "%DV:\n",
4290	&VarPTEAddr, &VarGCPtr, iEntry);
4291	do
4292	{
4293	/*
4294	* Read.
4295	*/
4296	X86PTEPAE Pte;
4297	Pte.u = 0;
4298	rc = pCmdHlp->pfnMemRead(pCmdHlp, &Pte, cbEntry, &VarPTEAddr, NULL);
4299	if (RT_FAILURE(rc))
4300	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "Reading PTE memory at %DV.\n", &VarPTEAddr);
4301
4302	/*
4303	* Display.
4304	*/
4305	if (iEntry != ~0U)
4306	{
4307	DBGCCmdHlpPrintf(pCmdHlp, "%03x %DV: ", iEntry, &VarGCPtr);
4308	iEntry++;
4309	}
4310	DBGCCmdHlpPrintf(pCmdHlp,
4311	fPAE
4312	? "%016llx 4kb phys=%016llx %s %s %s %s %s avl=%02x %s %s %s %s %s"
4313	: "%08llx 4kb phys=%08llx %s %s %s %s %s avl=%02x %s %s %s %s %s",
4314	Pte.u,
4315	Pte.u & X86_PTE_PAE_PG_MASK,
4316	Pte.n.u1Present ? "p " : "np",
4317	Pte.n.u1Write ? "w" : "r",
4318	Pte.n.u1User ? "u" : "s",
4319	Pte.n.u1Accessed ? "a " : "na",
4320	Pte.n.u1Dirty ? "d " : "nd",
4321	Pte.n.u3Available,
4322	Pte.n.u1Global ? (fPGE ? "g" : "G") : " ",
4323	Pte.n.u1WriteThru ? "pwt" : " ",
4324	Pte.n.u1CacheDisable ? "pcd" : " ",
4325	Pte.n.u1PAT ? "pat" : " ",
4326	Pte.n.u1NoExecute ? (fNXE ? "nx" : "NX") : " "
4327	);
4328	if (Pte.u & UINT64_C(0x7fff000000000000))
4329	DBGCCmdHlpPrintf(pCmdHlp, " weird=%RX64", (Pte.u & UINT64_C(0x7fff000000000000)));
4330	rc = DBGCCmdHlpPrintf(pCmdHlp, "\n");
4331	if (RT_FAILURE(rc))
4332	return rc;
4333
4334	/*
4335	* Advance.
4336	*/
4337	VarPTEAddr.u.u64Number += cbEntry;
4338	if (iEntry != ~0U)
4339	VarGCPtr.u.GCFlat += PAGE_SIZE;
4340	} while (cEntries-- > 0);
4341
4342	return VINF_SUCCESS;
4343	}
4344
4345
4346	/**
4347	* @callback_method_impl{FNDBGCCMD, The 'dptb' command.}
4348	*/
4349	static DECLCALLBACK(int) dbgcCmdDumpPageTableBoth(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
4350	{
4351	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
4352	int rc1 = pCmdHlp->pfnExec(pCmdHlp, "dptg %DV", &paArgs[0]);
4353	int rc2 = pCmdHlp->pfnExec(pCmdHlp, "dpth %DV", &paArgs[0]);
4354	if (RT_FAILURE(rc1))
4355	return rc1;
4356	NOREF(pCmd); NOREF(cArgs);
4357	return rc2;
4358	}
4359
4360
4361	/**
4362	* @callback_method_impl{FNDBGCCMD, The 'dt' command.}
4363	*/
4364	static DECLCALLBACK(int) dbgcCmdDumpTSS(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
4365	{
4366	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
4367	int rc;
4368
4369	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
4370	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, cArgs <= 1);
4371	if (cArgs == 1)
4372	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, paArgs[0].enmType != DBGCVAR_TYPE_STRING
4373	&& paArgs[0].enmType != DBGCVAR_TYPE_SYMBOL);
4374
4375	/*
4376	* Check if the command indicates the type.
4377	*/
4378	enum { kTss16, kTss32, kTss64, kTssToBeDetermined } enmTssType = kTssToBeDetermined;
4379	if (!strcmp(pCmd->pszCmd, "dt16"))
4380	enmTssType = kTss16;
4381	else if (!strcmp(pCmd->pszCmd, "dt32"))
4382	enmTssType = kTss32;
4383	else if (!strcmp(pCmd->pszCmd, "dt64"))
4384	enmTssType = kTss64;
4385
4386	/*
4387	* We can get a TSS selector (number), a far pointer using a TSS selector, or some kind of TSS pointer.
4388	*/
4389	uint32_t SelTss = UINT32_MAX;
4390	DBGCVAR VarTssAddr;
4391	if (cArgs == 0)
4392	{
4393	/** @todo consider querying the hidden bits instead (missing API). */
4394	uint16_t SelTR;
4395	rc = DBGFR3RegCpuQueryU16(pUVM, pDbgc->idCpu, DBGFREG_TR, &SelTR);
4396	if (RT_FAILURE(rc))
4397	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Failed to query TR, rc=%Rrc\n", rc);
4398	DBGCVAR_INIT_GC_FAR(&VarTssAddr, SelTR, 0);
4399	SelTss = SelTR;
4400	}
4401	else if (paArgs[0].enmType == DBGCVAR_TYPE_NUMBER)
4402	{
4403	if (paArgs[0].u.u64Number < 0xffff)
4404	DBGCVAR_INIT_GC_FAR(&VarTssAddr, (RTSEL)paArgs[0].u.u64Number, 0);
4405	else
4406	{
4407	if (paArgs[0].enmRangeType == DBGCVAR_RANGE_ELEMENTS)
4408	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Element count doesn't combine with a TSS address.\n");
4409	DBGCVAR_INIT_GC_FLAT(&VarTssAddr, paArgs[0].u.u64Number);
4410	if (paArgs[0].enmRangeType == DBGCVAR_RANGE_BYTES)
4411	{
4412	VarTssAddr.enmRangeType = paArgs[0].enmRangeType;
4413	VarTssAddr.u64Range = paArgs[0].u64Range;
4414	}
4415	}
4416	}
4417	else
4418	VarTssAddr = paArgs[0];
4419
4420	/*
4421	* Deal with TSS:ign by means of the GDT.
4422	*/
4423	if (VarTssAddr.enmType == DBGCVAR_TYPE_GC_FAR)
4424	{
4425	SelTss = VarTssAddr.u.GCFar.sel;
4426	DBGFSELINFO SelInfo;
4427	rc = DBGFR3SelQueryInfo(pUVM, pDbgc->idCpu, VarTssAddr.u.GCFar.sel, DBGFSELQI_FLAGS_DT_GUEST, &SelInfo);
4428	if (RT_FAILURE(rc))
4429	return DBGCCmdHlpFail(pCmdHlp, pCmd, "DBGFR3SelQueryInfo(,%u,%d,,) -> %Rrc.\n",
4430	pDbgc->idCpu, VarTssAddr.u.GCFar.sel, rc);
4431
4432	if (SelInfo.u.Raw.Gen.u1DescType)
4433	return DBGCCmdHlpFail(pCmdHlp, pCmd, "%04x is not a TSS selector. (!sys)\n", VarTssAddr.u.GCFar.sel);
4434
4435	switch (SelInfo.u.Raw.Gen.u4Type)
4436	{
4437	case X86_SEL_TYPE_SYS_286_TSS_BUSY:
4438	case X86_SEL_TYPE_SYS_286_TSS_AVAIL:
4439	if (enmTssType == kTssToBeDetermined)
4440	enmTssType = kTss16;
4441	break;
4442
4443	case X86_SEL_TYPE_SYS_386_TSS_BUSY: /* AMD64 too */
4444	case X86_SEL_TYPE_SYS_386_TSS_AVAIL:
4445	if (enmTssType == kTssToBeDetermined)
4446	enmTssType = SelInfo.fFlags & DBGFSELINFO_FLAGS_LONG_MODE ? kTss64 : kTss32;
4447	break;
4448
4449	default:
4450	return DBGCCmdHlpFail(pCmdHlp, pCmd, "%04x is not a TSS selector. (type=%x)\n",
4451	VarTssAddr.u.GCFar.sel, SelInfo.u.Raw.Gen.u4Type);
4452	}
4453
4454	DBGCVAR_INIT_GC_FLAT(&VarTssAddr, SelInfo.GCPtrBase);
4455	DBGCVAR_SET_RANGE(&VarTssAddr, DBGCVAR_RANGE_BYTES, RT_MAX(SelInfo.cbLimit + 1, SelInfo.cbLimit));
4456	}
4457
4458	/*
4459	* Determine the TSS type if none is currently given.
4460	*/
4461	if (enmTssType == kTssToBeDetermined)
4462	{
4463	if ( VarTssAddr.u64Range > 0
4464	&& VarTssAddr.u64Range < sizeof(X86TSS32) - 4)
4465	enmTssType = kTss16;
4466	else
4467	{
4468	uint64_t uEfer;
4469	rc = DBGFR3RegCpuQueryU64(pUVM, pDbgc->idCpu, DBGFREG_MSR_K6_EFER, &uEfer);
4470	if ( RT_FAILURE(rc)
4471	\|\| !(uEfer & MSR_K6_EFER_LMA) )
4472	enmTssType = kTss32;
4473	else
4474	enmTssType = kTss64;
4475	}
4476	}
4477
4478	/*
4479	* Figure the min/max sizes.
4480	* ASSUMES max TSS size is 64 KB.
4481	*/
4482	uint32_t cbTssMin;
4483	uint32_t cbTssMax;
4484	switch (enmTssType)
4485	{
4486	case kTss16:
4487	cbTssMin = cbTssMax = X86_SEL_TYPE_SYS_286_TSS_LIMIT_MIN + 1;
4488	break;
4489	case kTss32:
4490	cbTssMin = X86_SEL_TYPE_SYS_386_TSS_LIMIT_MIN + 1;
4491	cbTssMax = _64K;
4492	break;
4493	case kTss64:
4494	cbTssMin = X86_SEL_TYPE_SYS_386_TSS_LIMIT_MIN + 1;
4495	cbTssMax = _64K;
4496	break;
4497	default:
4498	AssertFailedReturn(VERR_INTERNAL_ERROR);
4499	}
4500	uint32_t cbTss = VarTssAddr.enmRangeType == DBGCVAR_RANGE_BYTES ? (uint32_t)VarTssAddr.u64Range : 0;
4501	if (cbTss == 0)
4502	cbTss = cbTssMin;
4503	else if (cbTss < cbTssMin)
4504	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Minimum TSS size is %u bytes, you specified %llu (%llx) bytes.\n",
4505	cbTssMin, VarTssAddr.u64Range, VarTssAddr.u64Range);
4506	else if (cbTss > cbTssMax)
4507	cbTss = cbTssMax;
4508	DBGCVAR_SET_RANGE(&VarTssAddr, DBGCVAR_RANGE_BYTES, cbTss);
4509
4510	/*
4511	* Read the TSS into a temporary buffer.
4512	*/
4513	uint8_t abBuf[_64K];
4514	size_t cbTssRead;
4515	rc = DBGCCmdHlpMemRead(pCmdHlp, abBuf, cbTss, &VarTssAddr, &cbTssRead);
4516	if (RT_FAILURE(rc))
4517	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Failed to read TSS at %Dv: %Rrc\n", &VarTssAddr, rc);
4518	if (cbTssRead < cbTssMin)
4519	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Failed to read essential parts of the TSS (read %zu, min %zu).\n",
4520	cbTssRead, cbTssMin);
4521	if (cbTssRead < cbTss)
4522	memset(&abBuf[cbTssRead], 0xff, cbTss - cbTssRead);
4523
4524
4525	/*
4526	* Format the TSS.
4527	*/
4528	uint16_t offIoBitmap;
4529	switch (enmTssType)
4530	{
4531	case kTss16:
4532	{
4533	PCX86TSS16 pTss = (PCX86TSS16)&abBuf[0];
4534	if (SelTss != UINT32_MAX)
4535	DBGCCmdHlpPrintf(pCmdHlp, "%04x TSS16 at %Dv\n", SelTss, &VarTssAddr);
4536	else
4537	DBGCCmdHlpPrintf(pCmdHlp, "TSS16 at %Dv\n", &VarTssAddr);
4538	DBGCCmdHlpPrintf(pCmdHlp,
4539	"ax=%04x bx=%04x cx=%04x dx=%04x si=%04x di=%04x\n"
4540	"ip=%04x sp=%04x bp=%04x\n"
4541	"cs=%04x ss=%04x ds=%04x es=%04x flags=%04x\n"
4542	"ss:sp0=%04x:%04x ss:sp1=%04x:%04x ss:sp2=%04x:%04x\n"
4543	"prev=%04x ldtr=%04x\n"
4544	,
4545	pTss->ax, pTss->bx, pTss->cx, pTss->dx, pTss->si, pTss->di,
4546	pTss->ip, pTss->sp, pTss->bp,
4547	pTss->cs, pTss->ss, pTss->ds, pTss->es, pTss->flags,
4548	pTss->ss0, pTss->sp0, pTss->ss1, pTss->sp1, pTss->ss2, pTss->sp2,
4549	pTss->selPrev, pTss->selLdt);
4550	if (pTss->cs != 0)
4551	pCmdHlp->pfnExec(pCmdHlp, "u %04x:%04x L 0", pTss->cs, pTss->ip);
4552	offIoBitmap = 0;
4553	break;
4554	}
4555
4556	case kTss32:
4557	{
4558	PCX86TSS32 pTss = (PCX86TSS32)&abBuf[0];
4559	if (SelTss != UINT32_MAX)
4560	DBGCCmdHlpPrintf(pCmdHlp, "%04x TSS32 at %Dv (min=%04x)\n", SelTss, &VarTssAddr, cbTssMin);
4561	else
4562	DBGCCmdHlpPrintf(pCmdHlp, "TSS32 at %Dv (min=%04x)\n", &VarTssAddr, cbTssMin);
4563	DBGCCmdHlpPrintf(pCmdHlp,
4564	"eax=%08x ebx=%08x ecx=%08x edx=%08x esi=%08x edi=%08x\n"
4565	"eip=%08x esp=%08x ebp=%08x\n"
4566	"cs=%04x ss=%04x ds=%04x es=%04x fs=%04x gs=%04x eflags=%08x\n"
4567	"ss:esp0=%04x:%08x ss:esp1=%04x:%08x ss:esp2=%04x:%08x\n"
4568	"prev=%04x ldtr=%04x cr3=%08x debug=%u iomap=%04x\n"
4569	,
4570	pTss->eax, pTss->ebx, pTss->ecx, pTss->edx, pTss->esi, pTss->edi,
4571	pTss->eip, pTss->esp, pTss->ebp,
4572	pTss->cs, pTss->ss, pTss->ds, pTss->es, pTss->fs, pTss->gs, pTss->eflags,
4573	pTss->ss0, pTss->esp0, pTss->ss1, pTss->esp1, pTss->ss2, pTss->esp2,
4574	pTss->selPrev, pTss->selLdt, pTss->cr3, pTss->fDebugTrap, pTss->offIoBitmap);
4575	if (pTss->cs != 0)
4576	pCmdHlp->pfnExec(pCmdHlp, "u %04x:%08x L 0", pTss->cs, pTss->eip);
4577	offIoBitmap = pTss->offIoBitmap;
4578	break;
4579	}
4580
4581	case kTss64:
4582	{
4583	PCX86TSS64 pTss = (PCX86TSS64)&abBuf[0];
4584	if (SelTss != UINT32_MAX)
4585	DBGCCmdHlpPrintf(pCmdHlp, "%04x TSS64 at %Dv (min=%04x)\n", SelTss, &VarTssAddr, cbTssMin);
4586	else
4587	DBGCCmdHlpPrintf(pCmdHlp, "TSS64 at %Dv (min=%04x)\n", &VarTssAddr, cbTssMin);
4588	DBGCCmdHlpPrintf(pCmdHlp,
4589	"rsp0=%016RX64 rsp1=%016RX64 rsp2=%016RX64\n"
4590	"ist1=%016RX64 ist2=%016RX64\n"
4591	"ist3=%016RX64 ist4=%016RX64\n"
4592	"ist5=%016RX64 ist6=%016RX64\n"
4593	"ist7=%016RX64 iomap=%04x\n"
4594	,
4595	pTss->rsp0, pTss->rsp1, pTss->rsp2,
4596	pTss->ist1, pTss->ist2,
4597	pTss->ist3, pTss->ist4,
4598	pTss->ist5, pTss->ist6,
4599	pTss->ist7, pTss->offIoBitmap);
4600	offIoBitmap = pTss->offIoBitmap;
4601	break;
4602	}
4603
4604	default:
4605	AssertFailedReturn(VERR_INTERNAL_ERROR);
4606	}
4607
4608	/*
4609	* Dump the interrupt redirection bitmap.
4610	*/
4611	if (enmTssType != kTss16)
4612	{
4613	if ( offIoBitmap > cbTssMin
4614	&& offIoBitmap < cbTss) /** @todo check exactly what the edge cases are here. */
4615	{
4616	if (offIoBitmap - cbTssMin >= 32)
4617	{
4618	DBGCCmdHlpPrintf(pCmdHlp, "Interrupt redirection:\n");
4619	uint8_t const *pbIntRedirBitmap = &abBuf[offIoBitmap - 32];
4620	uint32_t iStart = 0;
4621	bool fPrev = ASMBitTest(pbIntRedirBitmap, 0); /* LE/BE issue */
4622	for (uint32_t i = 0; i < 256; i++)
4623	{
4624	bool fThis = ASMBitTest(pbIntRedirBitmap, i);
4625	if (fThis != fPrev)
4626	{
4627	DBGCCmdHlpPrintf(pCmdHlp, "%02x-%02x %s\n", iStart, i - 1, fPrev ? "Protected mode" : "Redirected");
4628	fPrev = fThis;
4629	iStart = i;
4630	}
4631	}
4632	DBGCCmdHlpPrintf(pCmdHlp, "%02x-%02x %s\n", iStart, 255, fPrev ? "Protected mode" : "Redirected");
4633	}
4634	else
4635	DBGCCmdHlpPrintf(pCmdHlp, "Invalid interrupt redirection bitmap size: %u (%#x), expected 32 bytes.\n",
4636	offIoBitmap - cbTssMin, offIoBitmap - cbTssMin);
4637	}
4638	else if (offIoBitmap > 0)
4639	DBGCCmdHlpPrintf(pCmdHlp, "No interrupt redirection bitmap (-%#x)\n", cbTssMin - offIoBitmap);
4640	else
4641	DBGCCmdHlpPrintf(pCmdHlp, "No interrupt redirection bitmap\n");
4642	}
4643
4644	/*
4645	* Dump the I/O permission bitmap if present. The IOPM cannot start below offset 0x68
4646	* (that applies to both 32-bit and 64-bit TSSs since their size is the same).
4647	* Note that there is always one padding byte that is not technically part of the bitmap
4648	* and "must have all bits set". It's not clear what happens when it doesn't. All ports
4649	* not covered by the bitmap are considered to be not accessible.
4650	*/
4651	if (enmTssType != kTss16)
4652	{
4653	if (offIoBitmap < cbTss && offIoBitmap >= 0x68)
4654	{
4655	uint32_t cPorts = RT_MIN((cbTss - offIoBitmap) * 8, _64K);
4656	DBGCVAR VarAddr;
4657	DBGCCmdHlpEval(pCmdHlp, &VarAddr, "%DV + %#x", &VarTssAddr, offIoBitmap);
4658	DBGCCmdHlpPrintf(pCmdHlp, "I/O bitmap at %DV - %#x ports:\n", &VarAddr, cPorts);
4659
4660	uint8_t const *pbIoBitmap = &abBuf[offIoBitmap];
4661	uint32_t iStart = 0;
4662	bool fPrev = ASMBitTest(pbIoBitmap, 0);
4663	uint32_t cLine = 0;
4664	for (uint32_t i = 1; i < _64K; i++)
4665	{
4666	bool fThis = i < cPorts ? ASMBitTest(pbIoBitmap, i) : true;
4667	if (fThis != fPrev)
4668	{
4669	cLine++;
4670	DBGCCmdHlpPrintf(pCmdHlp, "%04x-%04x %s%s", iStart, i-1,
4671	fPrev ? "GP" : "OK", (cLine % 6) == 0 ? "\n" : " ");
4672	fPrev = fThis;
4673	iStart = i;
4674	}
4675	}
4676	DBGCCmdHlpPrintf(pCmdHlp, "%04x-%04x %s\n", iStart, _64K-1, fPrev ? "GP" : "OK");
4677	}
4678	else if (offIoBitmap > 0)
4679	DBGCCmdHlpPrintf(pCmdHlp, "No I/O bitmap (-%#x)\n", cbTssMin - offIoBitmap);
4680	else
4681	DBGCCmdHlpPrintf(pCmdHlp, "No I/O bitmap\n");
4682	}
4683
4684	return VINF_SUCCESS;
4685	}
4686
4687
4688	/**
4689	* @callback_method_impl{FNDBGFR3TYPEDUMP, The 'dti' command dumper callback.}
4690	*/
4691	static DECLCALLBACK(int) dbgcCmdDumpTypeInfoCallback(uint32_t off, const char *pszField, uint32_t iLvl,
4692	const char *pszType, uint32_t fTypeFlags,
4693	uint32_t cElements, void *pvUser)
4694	{
4695	PDBGCCMDHLP pCmdHlp = (PDBGCCMDHLP)pvUser;
4696
4697	/* Pad with spaces to match the level. */
4698	for (uint32_t i = 0; i < iLvl; i++)
4699	DBGCCmdHlpPrintf(pCmdHlp, " ");
4700
4701	size_t cbWritten = 0;
4702	DBGCCmdHlpPrintfEx(pCmdHlp, &cbWritten, "+0x%04x %s", off, pszField);
4703	while (cbWritten < 32)
4704	{
4705	/* Fill with spaces to get proper aligning. */
4706	DBGCCmdHlpPrintf(pCmdHlp, " ");
4707	cbWritten++;
4708	}
4709
4710	DBGCCmdHlpPrintf(pCmdHlp, ": ");
4711	if (fTypeFlags & DBGFTYPEREGMEMBER_F_ARRAY)
4712	DBGCCmdHlpPrintf(pCmdHlp, "[%u] ", cElements);
4713	if (fTypeFlags & DBGFTYPEREGMEMBER_F_POINTER)
4714	DBGCCmdHlpPrintf(pCmdHlp, "Ptr ");
4715	DBGCCmdHlpPrintf(pCmdHlp, "%s\n", pszType);
4716
4717	return VINF_SUCCESS;
4718	}
4719
4720
4721	/**
4722	* @callback_method_impl{FNDBGCCMD, The 'dti' command.}
4723	*/
4724	static DECLCALLBACK(int) dbgcCmdDumpTypeInfo(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
4725	{
4726	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
4727	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, cArgs == 1 \|\| cArgs == 2);
4728	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, paArgs[0].enmType == DBGCVAR_TYPE_STRING);
4729	if (cArgs == 2)
4730	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, paArgs[1].enmType == DBGCVAR_TYPE_NUMBER);
4731
4732	uint32_t cLvlMax = cArgs == 2 ? (uint32_t)paArgs[1].u.u64Number : UINT32_MAX;
4733	return DBGFR3TypeDumpEx(pUVM, paArgs[0].u.pszString, 0 /* fFlags */, cLvlMax,
4734	dbgcCmdDumpTypeInfoCallback, pCmdHlp);
4735	}
4736
4737
4738	static void dbgcCmdDumpTypedValCallbackBuiltin(PDBGCCMDHLP pCmdHlp, DBGFTYPEBUILTIN enmType, size_t cbType,
4739	PDBGFTYPEVALBUF pValBuf)
4740	{
4741	switch (enmType)
4742	{
4743	case DBGFTYPEBUILTIN_UINT8:
4744	DBGCCmdHlpPrintf(pCmdHlp, "%RU8", pValBuf->u8);
4745	break;
4746	case DBGFTYPEBUILTIN_INT8:
4747	DBGCCmdHlpPrintf(pCmdHlp, "%RI8", pValBuf->i8);
4748	break;
4749	case DBGFTYPEBUILTIN_UINT16:
4750	DBGCCmdHlpPrintf(pCmdHlp, "%RU16", pValBuf->u16);
4751	break;
4752	case DBGFTYPEBUILTIN_INT16:
4753	DBGCCmdHlpPrintf(pCmdHlp, "%RI16", pValBuf->i16);
4754	break;
4755	case DBGFTYPEBUILTIN_UINT32:
4756	DBGCCmdHlpPrintf(pCmdHlp, "%RU32", pValBuf->u32);
4757	break;
4758	case DBGFTYPEBUILTIN_INT32:
4759	DBGCCmdHlpPrintf(pCmdHlp, "%RI32", pValBuf->i32);
4760	break;
4761	case DBGFTYPEBUILTIN_UINT64:
4762	DBGCCmdHlpPrintf(pCmdHlp, "%RU64", pValBuf->u64);
4763	break;
4764	case DBGFTYPEBUILTIN_INT64:
4765	DBGCCmdHlpPrintf(pCmdHlp, "%RI64", pValBuf->i64);
4766	break;
4767	case DBGFTYPEBUILTIN_PTR32:
4768	DBGCCmdHlpPrintf(pCmdHlp, "%RX32", pValBuf->GCPtr);
4769	break;
4770	case DBGFTYPEBUILTIN_PTR64:
4771	DBGCCmdHlpPrintf(pCmdHlp, "%RX64", pValBuf->GCPtr);
4772	break;
4773	case DBGFTYPEBUILTIN_PTR:
4774	if (cbType == sizeof(uint32_t))
4775	DBGCCmdHlpPrintf(pCmdHlp, "%RX32", pValBuf->GCPtr);
4776	else if (cbType == sizeof(uint64_t))
4777	DBGCCmdHlpPrintf(pCmdHlp, "%RX64", pValBuf->GCPtr);
4778	else
4779	DBGCCmdHlpPrintf(pCmdHlp, "<Unsupported pointer width %u>", cbType);
4780	break;
4781	case DBGFTYPEBUILTIN_SIZE:
4782	if (cbType == sizeof(uint32_t))
4783	DBGCCmdHlpPrintf(pCmdHlp, "%RU32", pValBuf->size);
4784	else if (cbType == sizeof(uint64_t))
4785	DBGCCmdHlpPrintf(pCmdHlp, "%RU64", pValBuf->size);
4786	else
4787	DBGCCmdHlpPrintf(pCmdHlp, "<Unsupported size width %u>", cbType);
4788	break;
4789	case DBGFTYPEBUILTIN_FLOAT32:
4790	case DBGFTYPEBUILTIN_FLOAT64:
4791	case DBGFTYPEBUILTIN_COMPOUND:
4792	default:
4793	AssertMsgFailed(("Invalid built-in type: %d\n", enmType));
4794	}
4795	}
4796
4797	/**
4798	* @callback_method_impl{FNDBGFR3TYPEDUMP, The 'dtv' command dumper callback.}
4799	*/
4800	static DECLCALLBACK(int) dbgcCmdDumpTypedValCallback(uint32_t off, const char *pszField, uint32_t iLvl,
4801	DBGFTYPEBUILTIN enmType, size_t cbType,
4802	PDBGFTYPEVALBUF pValBuf, uint32_t cValBufs,
4803	void *pvUser)
4804	{
4805	PDBGCCMDHLP pCmdHlp = (PDBGCCMDHLP)pvUser;
4806
4807	/* Pad with spaces to match the level. */
4808	for (uint32_t i = 0; i < iLvl; i++)
4809	DBGCCmdHlpPrintf(pCmdHlp, " ");
4810
4811	size_t cbWritten = 0;
4812	DBGCCmdHlpPrintfEx(pCmdHlp, &cbWritten, "+0x%04x %s", off, pszField);
4813	while (cbWritten < 32)
4814	{
4815	/* Fill with spaces to get proper aligning. */
4816	DBGCCmdHlpPrintf(pCmdHlp, " ");
4817	cbWritten++;
4818	}
4819
4820	DBGCCmdHlpPrintf(pCmdHlp, ": ");
4821	if (cValBufs > 1)
4822	DBGCCmdHlpPrintf(pCmdHlp, "[%u] [ ", cValBufs);
4823
4824	for (uint32_t i = 0; i < cValBufs; i++)
4825	{
4826	dbgcCmdDumpTypedValCallbackBuiltin(pCmdHlp, enmType, cbType, pValBuf);
4827	if (i < cValBufs - 1)
4828	DBGCCmdHlpPrintf(pCmdHlp, " , ");
4829	pValBuf++;
4830	}
4831
4832	if (cValBufs > 1)
4833	DBGCCmdHlpPrintf(pCmdHlp, " ]");
4834	DBGCCmdHlpPrintf(pCmdHlp, "\n");
4835
4836	return VINF_SUCCESS;
4837	}
4838
4839
4840	/**
4841	* @callback_method_impl{FNDBGCCMD, The 'dtv' command.}
4842	*/
4843	static DECLCALLBACK(int) dbgcCmdDumpTypedVal(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
4844	{
4845	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
4846	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, cArgs == 2 \|\| cArgs == 3);
4847	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, paArgs[0].enmType == DBGCVAR_TYPE_STRING);
4848	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, DBGCVAR_ISGCPOINTER(paArgs[1].enmType));
4849	if (cArgs == 3)
4850	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, paArgs[2].enmType == DBGCVAR_TYPE_NUMBER);
4851
4852	/*
4853	* Make DBGF address and fix the range.
4854	*/
4855	DBGFADDRESS Address;
4856	int rc = pCmdHlp->pfnVarToDbgfAddr(pCmdHlp, &paArgs[1], &Address);
4857	if (RT_FAILURE(rc))
4858	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "VarToDbgfAddr(,%Dv,)\n", &paArgs[1]);
4859
4860	uint32_t cLvlMax = cArgs == 3 ? (uint32_t)paArgs[2].u.u64Number : UINT32_MAX;
4861	return DBGFR3TypeValDumpEx(pUVM, &Address, paArgs[0].u.pszString, 0 /* fFlags */, cLvlMax,
4862	dbgcCmdDumpTypedValCallback, pCmdHlp);
4863	}
4864
4865	/**
4866	* @callback_method_impl{FNDBGCCMD, The 'm' command.}
4867	*/
4868	static DECLCALLBACK(int) dbgcCmdMemoryInfo(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
4869	{
4870	DBGCCmdHlpPrintf(pCmdHlp, "Address: %DV\n", &paArgs[0]);
4871	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
4872	return dbgcCmdDumpPageHierarchy(pCmd, pCmdHlp, pUVM, paArgs, cArgs);
4873	}
4874
4875
4876	/**
4877	* Converts one or more variables into a byte buffer for a
4878	* given unit size.
4879	*
4880	* @returns VBox status codes:
4881	* @retval VERR_TOO_MUCH_DATA if the buffer is too small, bitched.
4882	* @retval VERR_INTERNAL_ERROR on bad variable type, bitched.
4883	* @retval VINF_SUCCESS on success.
4884	*
4885	* @param pCmdHlp The command helper callback table.
4886	* @param pvBuf The buffer to convert into.
4887	* @param pcbBuf The buffer size on input. The size of the result on output.
4888	* @param cbUnit The unit size to apply when converting.
4889	* The high bit is used to indicate unicode string.
4890	* @param paVars The array of variables to convert.
4891	* @param cVars The number of variables.
4892	*/
4893	int dbgcVarsToBytes(PDBGCCMDHLP pCmdHlp, void pvBuf, uint32_t pcbBuf, size_t cbUnit, PCDBGCVAR paVars, unsigned cVars)
4894	{
4895	union
4896	{
4897	uint8_t *pu8;
4898	uint16_t *pu16;
4899	uint32_t *pu32;
4900	uint64_t *pu64;
4901	} u, uEnd;
4902	u.pu8 = (uint8_t *)pvBuf;
4903	uEnd.pu8 = u.pu8 + *pcbBuf;
4904
4905	unsigned i;
4906	for (i = 0; i < cVars && u.pu8 < uEnd.pu8; i++)
4907	{
4908	switch (paVars[i].enmType)
4909	{
4910	case DBGCVAR_TYPE_GC_FAR:
4911	case DBGCVAR_TYPE_GC_FLAT:
4912	case DBGCVAR_TYPE_GC_PHYS:
4913	case DBGCVAR_TYPE_HC_FLAT:
4914	case DBGCVAR_TYPE_HC_PHYS:
4915	case DBGCVAR_TYPE_NUMBER:
4916	{
4917	uint64_t u64 = paVars[i].u.u64Number;
4918	switch (cbUnit & 0x1f)
4919	{
4920	case 1:
4921	do
4922	{
4923	*u.pu8++ = u64;
4924	u64 >>= 8;
4925	} while (u64);
4926	break;
4927	case 2:
4928	do
4929	{
4930	*u.pu16++ = u64;
4931	u64 >>= 16;
4932	} while (u64);
4933	break;
4934	case 4:
4935	*u.pu32++ = u64;
4936	u64 >>= 32;
4937	if (u64)
4938	*u.pu32++ = u64;
4939	break;
4940	case 8:
4941	*u.pu64++ = u64;
4942	break;
4943	}
4944	break;
4945	}
4946
4947	case DBGCVAR_TYPE_STRING:
4948	case DBGCVAR_TYPE_SYMBOL:
4949	{
4950	const char *psz = paVars[i].u.pszString;
4951	size_t cbString = strlen(psz);
4952	if (cbUnit & RT_BIT_32(31))
4953	{
4954	/* Explode char to unit. */
4955	if (cbString > (uintptr_t)(uEnd.pu8 - u.pu8) * (cbUnit & 0x1f))
4956	{
4957	pCmdHlp->pfnVBoxError(pCmdHlp, VERR_TOO_MUCH_DATA, "Max %d bytes.\n", uEnd.pu8 - (uint8_t *)pvBuf);
4958	return VERR_TOO_MUCH_DATA;
4959	}
4960	while (*psz)
4961	{
4962	switch (cbUnit & 0x1f)
4963	{
4964	case 1: u.pu8++ = psz; break;
4965	case 2: u.pu16++ = psz; break;
4966	case 4: u.pu32++ = psz; break;
4967	case 8: u.pu64++ = psz; break;
4968	}
4969	psz++;
4970	}
4971	}
4972	else
4973	{
4974	/* Raw copy with zero padding if the size isn't aligned. */
4975	if (cbString > (uintptr_t)(uEnd.pu8 - u.pu8))
4976	{
4977	pCmdHlp->pfnVBoxError(pCmdHlp, VERR_TOO_MUCH_DATA, "Max %d bytes.\n", uEnd.pu8 - (uint8_t *)pvBuf);
4978	return VERR_TOO_MUCH_DATA;
4979	}
4980
4981	size_t cbCopy = cbString & ~(cbUnit - 1);
4982	memcpy(u.pu8, psz, cbCopy);
4983	u.pu8 += cbCopy;
4984	psz += cbCopy;
4985
4986	size_t cbReminder = cbString & (cbUnit - 1);
4987	if (cbReminder)
4988	{
4989	memcpy(u.pu8, psz, cbString & (cbUnit - 1));
4990	memset(u.pu8 + cbReminder, 0, cbUnit - cbReminder);
4991	u.pu8 += cbUnit;
4992	}
4993	}
4994	break;
4995	}
4996
4997	default:
4998	pcbBuf = u.pu8 - (uint8_t )pvBuf;
4999	pCmdHlp->pfnVBoxError(pCmdHlp, VERR_INTERNAL_ERROR,
5000	"i=%d enmType=%d\n", i, paVars[i].enmType);
5001	return VERR_INTERNAL_ERROR;
5002	}
5003	}
5004	pcbBuf = u.pu8 - (uint8_t )pvBuf;
5005	if (i != cVars)
5006	{
5007	pCmdHlp->pfnVBoxError(pCmdHlp, VERR_TOO_MUCH_DATA, "Max %d bytes.\n", uEnd.pu8 - (uint8_t *)pvBuf);
5008	return VERR_TOO_MUCH_DATA;
5009	}
5010	return VINF_SUCCESS;
5011	}
5012
5013
5014	/**
5015	* @callback_method_impl{FNDBGCCMD, The 'eb'\, 'ew'\, 'ed' and 'eq' commands.}
5016	*/
5017	static DECLCALLBACK(int) dbgcCmdEditMem(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
5018	{
5019	/*
5020	* Validate input.
5021	*/
5022	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, cArgs >= 2);
5023	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, DBGCVAR_ISPOINTER(paArgs[0].enmType));
5024	for (unsigned iArg = 1; iArg < cArgs; iArg++)
5025	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, paArgs[iArg].enmType == DBGCVAR_TYPE_NUMBER);
5026	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
5027
5028	/*
5029	* Figure out the element size.
5030	*/
5031	unsigned cbElement;
5032	switch (pCmd->pszCmd[1])
5033	{
5034	default:
5035	case 'b': cbElement = 1; break;
5036	case 'w': cbElement = 2; break;
5037	case 'd': cbElement = 4; break;
5038	case 'q': cbElement = 8; break;
5039	}
5040
5041	/*
5042	* Do setting.
5043	*/
5044	DBGCVAR Addr = paArgs[0];
5045	for (unsigned iArg = 1;;)
5046	{
5047	size_t cbWritten;
5048	int rc = pCmdHlp->pfnMemWrite(pCmdHlp, &paArgs[iArg].u, cbElement, &Addr, &cbWritten);
5049	if (RT_FAILURE(rc))
5050	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Writing memory at %DV.\n", &Addr);
5051	if (cbWritten != cbElement)
5052	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Only wrote %u out of %u bytes!\n", cbWritten, cbElement);
5053
5054	/* advance. */
5055	iArg++;
5056	if (iArg >= cArgs)
5057	break;
5058	rc = DBGCCmdHlpEval(pCmdHlp, &Addr, "%Dv + %#x", &Addr, cbElement);
5059	if (RT_FAILURE(rc))
5060	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "%%(%Dv)", &paArgs[0]);
5061	}
5062
5063	return VINF_SUCCESS;
5064	}
5065
5066
5067	/**
5068	* Executes the search.
5069	*
5070	* @returns VBox status code.
5071	* @param pCmdHlp The command helpers.
5072	* @param pUVM The user mode VM handle.
5073	* @param pAddress The address to start searching from. (undefined on output)
5074	* @param cbRange The address range to search. Must not wrap.
5075	* @param pabBytes The byte pattern to search for.
5076	* @param cbBytes The size of the pattern.
5077	* @param cbUnit The search unit.
5078	* @param cMaxHits The max number of hits.
5079	* @param pResult Where to store the result if it's a function invocation.
5080	*/
5081	static int dbgcCmdWorkerSearchMemDoIt(PDBGCCMDHLP pCmdHlp, PUVM pUVM, PDBGFADDRESS pAddress, RTGCUINTPTR cbRange,
5082	const uint8_t *pabBytes, uint32_t cbBytes,
5083	uint32_t cbUnit, uint64_t cMaxHits, PDBGCVAR pResult)
5084	{
5085	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
5086
5087	/*
5088	* Do the search.
5089	*/
5090	uint64_t cHits = 0;
5091	for (;;)
5092	{
5093	/* search */
5094	DBGFADDRESS HitAddress;
5095	int rc = DBGFR3MemScan(pUVM, pDbgc->idCpu, pAddress, cbRange, 1, pabBytes, cbBytes, &HitAddress);
5096	if (RT_FAILURE(rc))
5097	{
5098	if (rc != VERR_DBGF_MEM_NOT_FOUND)
5099	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "DBGFR3MemScan\n");
5100
5101	/* update the current address so we can save it (later). */
5102	pAddress->off += cbRange;
5103	pAddress->FlatPtr += cbRange;
5104	cbRange = 0;
5105	break;
5106	}
5107
5108	/* report result */
5109	DBGCVAR VarCur;
5110	rc = DBGCCmdHlpVarFromDbgfAddr(pCmdHlp, &HitAddress, &VarCur);
5111	if (RT_FAILURE(rc))
5112	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "DBGCCmdHlpVarFromDbgfAddr\n");
5113	if (!pResult)
5114	pCmdHlp->pfnExec(pCmdHlp, "db %DV LB 10", &VarCur);
5115	else
5116	DBGCVAR_ASSIGN(pResult, &VarCur);
5117
5118	/* advance */
5119	cbRange -= HitAddress.FlatPtr - pAddress->FlatPtr;
5120	*pAddress = HitAddress;
5121	pAddress->FlatPtr += cbBytes;
5122	pAddress->off += cbBytes;
5123	if (cbRange <= cbBytes)
5124	{
5125	cbRange = 0;
5126	break;
5127	}
5128	cbRange -= cbBytes;
5129
5130	if (++cHits >= cMaxHits)
5131	{
5132	/// @todo save the search.
5133	break;
5134	}
5135	}
5136
5137	/*
5138	* Save the search so we can resume it...
5139	*/
5140	if (pDbgc->abSearch != pabBytes)
5141	{
5142	memcpy(pDbgc->abSearch, pabBytes, cbBytes);
5143	pDbgc->cbSearch = cbBytes;
5144	pDbgc->cbSearchUnit = cbUnit;
5145	}
5146	pDbgc->cMaxSearchHits = cMaxHits;
5147	pDbgc->SearchAddr = *pAddress;
5148	pDbgc->cbSearchRange = cbRange;
5149
5150	return cHits ? VINF_SUCCESS : VERR_DBGC_COMMAND_FAILED;
5151	}
5152
5153
5154	/**
5155	* Resumes the previous search.
5156	*
5157	* @returns VBox status code.
5158	* @param pCmdHlp Pointer to the command helper functions.
5159	* @param pUVM The user mode VM handle.
5160	* @param pResult Where to store the result of a function invocation.
5161	*/
5162	static int dbgcCmdWorkerSearchMemResume(PDBGCCMDHLP pCmdHlp, PUVM pUVM, PDBGCVAR pResult)
5163	{
5164	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
5165
5166	/*
5167	* Make sure there is a previous command.
5168	*/
5169	if (!pDbgc->cbSearch)
5170	{
5171	DBGCCmdHlpPrintf(pCmdHlp, "Error: No previous search\n");
5172	return VERR_DBGC_COMMAND_FAILED;
5173	}
5174
5175	/*
5176	* Make range and address adjustments.
5177	*/
5178	DBGFADDRESS Address = pDbgc->SearchAddr;
5179	if (Address.FlatPtr == ~(RTGCUINTPTR)0)
5180	{
5181	Address.FlatPtr -= Address.off;
5182	Address.off = 0;
5183	}
5184
5185	RTGCUINTPTR cbRange = pDbgc->cbSearchRange;
5186	if (!cbRange)
5187	cbRange = ~(RTGCUINTPTR)0;
5188	if (Address.FlatPtr + cbRange < pDbgc->SearchAddr.FlatPtr)
5189	cbRange = ~(RTGCUINTPTR)0 - pDbgc->SearchAddr.FlatPtr + !!pDbgc->SearchAddr.FlatPtr;
5190
5191	return dbgcCmdWorkerSearchMemDoIt(pCmdHlp, pUVM, &Address, cbRange, pDbgc->abSearch, pDbgc->cbSearch,
5192	pDbgc->cbSearchUnit, pDbgc->cMaxSearchHits, pResult);
5193	}
5194
5195
5196	/**
5197	* Search memory, worker for the 's' and 's?' functions.
5198	*
5199	* @returns VBox status code.
5200	* @param pCmdHlp Pointer to the command helper functions.
5201	* @param pUVM The user mode VM handle.
5202	* @param pAddress Where to start searching. If no range, search till end of address space.
5203	* @param cMaxHits The maximum number of hits.
5204	* @param chType The search type.
5205	* @param paPatArgs The pattern variable array.
5206	* @param cPatArgs Number of pattern variables.
5207	* @param pResult Where to store the result of a function invocation.
5208	*/
5209	static int dbgcCmdWorkerSearchMem(PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR pAddress, uint64_t cMaxHits, char chType,
5210	PCDBGCVAR paPatArgs, unsigned cPatArgs, PDBGCVAR pResult)
5211	{
5212	if (pResult)
5213	DBGCVAR_INIT_GC_FLAT(pResult, 0);
5214
5215	/*
5216	* Convert the search pattern into bytes and DBGFR3MemScan can deal with.
5217	*/
5218	uint32_t cbUnit;
5219	switch (chType)
5220	{
5221	case 'a':
5222	case 'b': cbUnit = 1; break;
5223	case 'u': cbUnit = 2 \| RT_BIT_32(31); break;
5224	case 'w': cbUnit = 2; break;
5225	case 'd': cbUnit = 4; break;
5226	case 'q': cbUnit = 8; break;
5227	default:
5228	return pCmdHlp->pfnVBoxError(pCmdHlp, VERR_INVALID_PARAMETER, "chType=%c\n", chType);
5229	}
5230	uint8_t abBytes[RT_SIZEOFMEMB(DBGC, abSearch)];
5231	uint32_t cbBytes = sizeof(abBytes);
5232	int rc = dbgcVarsToBytes(pCmdHlp, abBytes, &cbBytes, cbUnit, paPatArgs, cPatArgs);
5233	if (RT_FAILURE(rc))
5234	return VERR_DBGC_COMMAND_FAILED;
5235
5236	/*
5237	* Make DBGF address and fix the range.
5238	*/
5239	DBGFADDRESS Address;
5240	rc = pCmdHlp->pfnVarToDbgfAddr(pCmdHlp, pAddress, &Address);
5241	if (RT_FAILURE(rc))
5242	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "VarToDbgfAddr(,%Dv,)\n", pAddress);
5243
5244	RTGCUINTPTR cbRange;
5245	switch (pAddress->enmRangeType)
5246	{
5247	case DBGCVAR_RANGE_BYTES:
5248	cbRange = pAddress->u64Range;
5249	if (cbRange != pAddress->u64Range)
5250	cbRange = ~(RTGCUINTPTR)0;
5251	break;
5252
5253	case DBGCVAR_RANGE_ELEMENTS:
5254	cbRange = (RTGCUINTPTR)(pAddress->u64Range * cbUnit);
5255	if ( cbRange != pAddress->u64Range * cbUnit
5256	\|\| cbRange < pAddress->u64Range)
5257	cbRange = ~(RTGCUINTPTR)0;
5258	break;
5259
5260	default:
5261	cbRange = ~(RTGCUINTPTR)0;
5262	break;
5263	}
5264	if (Address.FlatPtr + cbRange < Address.FlatPtr)
5265	cbRange = ~(RTGCUINTPTR)0 - Address.FlatPtr + !!Address.FlatPtr;
5266
5267	/*
5268	* Ok, do it.
5269	*/
5270	return dbgcCmdWorkerSearchMemDoIt(pCmdHlp, pUVM, &Address, cbRange, abBytes, cbBytes, cbUnit, cMaxHits, pResult);
5271	}
5272
5273
5274	/**
5275	* @callback_method_impl{FNDBGCCMD, The 's' command.}
5276	*/
5277	static DECLCALLBACK(int) dbgcCmdSearchMem(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
5278	{
5279	RT_NOREF2(pCmd, paArgs);
5280
5281	/* check that the parser did what it's supposed to do. */
5282	//if ( cArgs <= 2
5283	// && paArgs[0].enmType != DBGCVAR_TYPE_STRING)
5284	// return DBGCCmdHlpPrintf(pCmdHlp, "parser error\n");
5285
5286	/*
5287	* Repeat previous search?
5288	*/
5289	if (cArgs == 0)
5290	return dbgcCmdWorkerSearchMemResume(pCmdHlp, pUVM, NULL);
5291
5292	/*
5293	* Parse arguments.
5294	*/
5295
5296	return -1;
5297	}
5298
5299
5300	/**
5301	* @callback_method_impl{FNDBGCCMD, The 's?' command.}
5302	*/
5303	static DECLCALLBACK(int) dbgcCmdSearchMemType(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
5304	{
5305	/* check that the parser did what it's supposed to do. */
5306	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, cArgs >= 2 && DBGCVAR_ISGCPOINTER(paArgs[0].enmType));
5307	return dbgcCmdWorkerSearchMem(pCmdHlp, pUVM, &paArgs[0], 25, pCmd->pszCmd[1], paArgs + 1, cArgs - 1, NULL);
5308	}
5309
5310
5311	/**
5312	* Matching function for interrupts event names.
5313	*
5314	* This parses the interrupt number and length.
5315	*
5316	* @returns True if match, false if not.
5317	* @param pPattern The user specified pattern to match.
5318	* @param pszEvtName The event name.
5319	* @param pCmdHlp Command helpers for warning about malformed stuff.
5320	* @param piFirst Where to return start interrupt number on success.
5321	* @param pcInts Where to return the number of interrupts on success.
5322	*/
5323	static bool dbgcEventIsMatchingInt(PCDBGCVAR pPattern, const char *pszEvtName, PDBGCCMDHLP pCmdHlp,
5324	uint8_t piFirst, uint16_t pcInts)
5325	{
5326	/*
5327	* Ignore trailing hex digits when comparing with the event base name.
5328	*/
5329	const char *pszPattern = pPattern->u.pszString;
5330	const char *pszEnd = RTStrEnd(pszPattern, RTSTR_MAX);
5331	while ( (uintptr_t)pszEnd > (uintptr_t)pszPattern
5332	&& RT_C_IS_XDIGIT(pszEnd[-1]))
5333	pszEnd -= 1;
5334	if (RTStrSimplePatternNMatch(pszPattern, pszEnd - pszPattern, pszEvtName, RTSTR_MAX))
5335	{
5336	/*
5337	* Parse the index and length.
5338	*/
5339	if (!*pszEnd)
5340	*piFirst = 0;
5341	else
5342	{
5343	int rc = RTStrToUInt8Full(pszEnd, 16, piFirst);
5344	if (rc != VINF_SUCCESS)
5345	{
5346	if (RT_FAILURE(rc))
5347	*piFirst = 0;
5348	DBGCCmdHlpPrintf(pCmdHlp, "Warning: %Rrc parsing '%s' - interpreting it as %#x\n", rc, pszEnd, *piFirst);
5349	}
5350	}
5351
5352	if (pPattern->enmRangeType == DBGCVAR_RANGE_NONE)
5353	*pcInts = 1;
5354	else
5355	pcInts = RT_MAX(RT_MIN((uint16_t)pPattern->u64Range, 256 - piFirst), 1);
5356	return true;
5357	}
5358	return false;
5359	}
5360
5361
5362	/**
5363	* Updates a DBGC event config.
5364	*
5365	* @returns VINF_SUCCESS or VERR_NO_MEMORY.
5366	* @param ppEvtCfg The event configuration entry to update.
5367	* @param pszCmd The new command. Leave command alone if NULL.
5368	* @param enmEvtState The new event state.
5369	* @param fChangeCmdOnly Whether to only update the command.
5370	*/
5371	static int dbgcEventUpdate(PDBGCEVTCFG ppEvtCfg, const char pszCmd, DBGCEVTSTATE enmEvtState, bool fChangeCmdOnly)
5372	{
5373	PDBGCEVTCFG pEvtCfg = *ppEvtCfg;
5374
5375	/*
5376	* If we've got a command string, update the command too.
5377	*/
5378	if (pszCmd)
5379	{
5380	size_t cchCmd = strlen(pszCmd);
5381	if ( !cchCmd
5382	&& ( !fChangeCmdOnly
5383	? enmEvtState == kDbgcEvtState_Disabled
5384	: !pEvtCfg \|\| pEvtCfg->enmState == kDbgcEvtState_Disabled))
5385	{
5386	/* NULL entry is fine if no command and disabled. */
5387	RTMemFree(pEvtCfg);
5388	*ppEvtCfg = NULL;
5389	}
5390	else
5391	{
5392	if (!pEvtCfg \|\| pEvtCfg->cchCmd < cchCmd)
5393	{
5394	RTMemFree(pEvtCfg);
5395	*ppEvtCfg = pEvtCfg = (PDBGCEVTCFG)RTMemAlloc(RT_UOFFSETOF_DYN(DBGCEVTCFG, szCmd[cchCmd + 1]));
5396	if (!pEvtCfg)
5397	return VERR_NO_MEMORY;
5398	}
5399	pEvtCfg->enmState = enmEvtState;
5400	pEvtCfg->cchCmd = cchCmd;
5401	memcpy(pEvtCfg->szCmd, pszCmd, cchCmd + 1);
5402	}
5403	}
5404	/*
5405	* Update existing or enable new. If NULL and not enabled, we can keep it that way.
5406	*/
5407	else if (pEvtCfg \|\| enmEvtState != kDbgcEvtState_Disabled)
5408	{
5409	if (!pEvtCfg)
5410	{
5411	*ppEvtCfg = pEvtCfg = (PDBGCEVTCFG)RTMemAlloc(sizeof(DBGCEVTCFG));
5412	if (!pEvtCfg)
5413	return VERR_NO_MEMORY;
5414	pEvtCfg->cchCmd = 0;
5415	pEvtCfg->szCmd[0] = '\0';
5416	}
5417	pEvtCfg->enmState = enmEvtState;
5418	}
5419
5420	return VINF_SUCCESS;
5421	}
5422
5423
5424	/**
5425	* Record one settings change for a plain event.
5426	*
5427	* @returns The new @a cIntCfgs value.
5428	* @param paEventCfgs The event setttings array. Must have DBGFEVENT_END
5429	* entries.
5430	* @param cEventCfgs The current number of entries in @a paEventCfgs.
5431	* @param enmType The event to change the settings for.
5432	* @param enmEvtState The new event state.
5433	* @param iSxEvt Index into the g_aDbgcSxEvents array.
5434	*
5435	* @remarks We use abUnused[0] for the enmEvtState, while abUnused[1] and
5436	* abUnused[2] are used for iSxEvt.
5437	*/
5438	static uint32_t dbgcEventAddPlainConfig(PDBGFEVENTCONFIG paEventCfgs, uint32_t cEventCfgs, DBGFEVENTTYPE enmType,
5439	DBGCEVTSTATE enmEvtState, uint16_t iSxEvt)
5440	{
5441	uint32_t iCfg;
5442	for (iCfg = 0; iCfg < cEventCfgs; iCfg++)
5443	if (paEventCfgs[iCfg].enmType == enmType)
5444	break;
5445	if (iCfg == cEventCfgs)
5446	{
5447	Assert(cEventCfgs < DBGFEVENT_END);
5448	paEventCfgs[iCfg].enmType = enmType;
5449	cEventCfgs++;
5450	}
5451	paEventCfgs[iCfg].fEnabled = enmEvtState > kDbgcEvtState_Disabled;
5452	paEventCfgs[iCfg].abUnused[0] = enmEvtState;
5453	paEventCfgs[iCfg].abUnused[1] = (uint8_t)iSxEvt;
5454	paEventCfgs[iCfg].abUnused[2] = (uint8_t)(iSxEvt >> 8);
5455	return cEventCfgs;
5456	}
5457
5458
5459	/**
5460	* Record one or more interrupt event config changes.
5461	*
5462	* @returns The new @a cIntCfgs value.
5463	* @param paIntCfgs Interrupt confiruation array. Must have 256 entries.
5464	* @param cIntCfgs The current number of entries in @a paIntCfgs.
5465	* @param iInt The interrupt number to start with.
5466	* @param cInts The number of interrupts to change.
5467	* @param pszName The settings name (hwint/swint).
5468	* @param enmEvtState The new event state.
5469	* @param bIntOp The new DBGF interrupt state.
5470	*/
5471	static uint32_t dbgcEventAddIntConfig(PDBGFINTERRUPTCONFIG paIntCfgs, uint32_t cIntCfgs, uint8_t iInt, uint16_t cInts,
5472	const char *pszName, DBGCEVTSTATE enmEvtState, uint8_t bIntOp)
5473	{
5474	bool const fHwInt = *pszName == 'h';
5475
5476	bIntOp \|= (uint8_t)enmEvtState << 4;
5477	uint8_t const bSoftState = !fHwInt ? bIntOp : DBGFINTERRUPTSTATE_DONT_TOUCH;
5478	uint8_t const bHardState = fHwInt ? bIntOp : DBGFINTERRUPTSTATE_DONT_TOUCH;
5479
5480	while (cInts > 0)
5481	{
5482	uint32_t iCfg;
5483	for (iCfg = 0; iCfg < cIntCfgs; iCfg++)
5484	if (paIntCfgs[iCfg].iInterrupt == iInt)
5485	break;
5486	if (iCfg == cIntCfgs)
5487	break;
5488	if (fHwInt)
5489	paIntCfgs[iCfg].enmHardState = bHardState;
5490	else
5491	paIntCfgs[iCfg].enmSoftState = bSoftState;
5492	iInt++;
5493	cInts--;
5494	}
5495
5496	while (cInts > 0)
5497	{
5498	Assert(cIntCfgs < 256);
5499	paIntCfgs[cIntCfgs].iInterrupt = iInt;
5500	paIntCfgs[cIntCfgs].enmHardState = bHardState;
5501	paIntCfgs[cIntCfgs].enmSoftState = bSoftState;
5502	cIntCfgs++;
5503	iInt++;
5504	cInts--;
5505	}
5506
5507	return cIntCfgs;
5508	}
5509
5510
5511	/**
5512	* Applies event settings changes to DBGC and DBGF.
5513	*
5514	* @returns VBox status code (fully bitched)
5515	* @param pCmdHlp The command helpers.
5516	* @param pUVM The user mode VM handle.
5517	* @param paIntCfgs Interrupt configuration array. We use the upper 4
5518	* bits of the settings for the DBGCEVTSTATE. This
5519	* will be cleared.
5520	* @param cIntCfgs Number of interrupt configuration changes.
5521	* @param paEventCfgs The generic event configuration array. We use the
5522	* abUnused[0] member for the DBGCEVTSTATE, and
5523	* abUnused[2:1] for the g_aDbgcSxEvents index.
5524	* @param cEventCfgs The number of generic event settings changes.
5525	* @param pszCmd The commands to associate with the changed events.
5526	* If this is NULL, don't touch the command.
5527	* @param fChangeCmdOnly Whether to only change the commands (sx-).
5528	*/
5529	static int dbgcEventApplyChanges(PDBGCCMDHLP pCmdHlp, PUVM pUVM, PDBGFINTERRUPTCONFIG paIntCfgs, uint32_t cIntCfgs,
5530	PCDBGFEVENTCONFIG paEventCfgs, uint32_t cEventCfgs, const char *pszCmd, bool fChangeCmdOnly)
5531	{
5532	int rc;
5533
5534	/*
5535	* Apply changes to DBGC. This can only fail with out of memory error.
5536	*/
5537	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
5538	if (cIntCfgs)
5539	for (uint32_t iCfg = 0; iCfg < cIntCfgs; iCfg++)
5540	{
5541	DBGCEVTSTATE enmEvtState = (DBGCEVTSTATE)(paIntCfgs[iCfg].enmHardState >> 4);
5542	paIntCfgs[iCfg].enmHardState &= 0xf;
5543	if (paIntCfgs[iCfg].enmHardState != DBGFINTERRUPTSTATE_DONT_TOUCH)
5544	{
5545	rc = dbgcEventUpdate(&pDbgc->apHardInts[paIntCfgs[iCfg].iInterrupt], pszCmd, enmEvtState, fChangeCmdOnly);
5546	if (RT_FAILURE(rc))
5547	return rc;
5548	}
5549
5550	enmEvtState = (DBGCEVTSTATE)(paIntCfgs[iCfg].enmSoftState >> 4);
5551	paIntCfgs[iCfg].enmSoftState &= 0xf;
5552	if (paIntCfgs[iCfg].enmSoftState != DBGFINTERRUPTSTATE_DONT_TOUCH)
5553	{
5554	rc = dbgcEventUpdate(&pDbgc->apSoftInts[paIntCfgs[iCfg].iInterrupt], pszCmd, enmEvtState, fChangeCmdOnly);
5555	if (RT_FAILURE(rc))
5556	return rc;
5557	}
5558	}
5559
5560	if (cEventCfgs)
5561	{
5562	for (uint32_t iCfg = 0; iCfg < cEventCfgs; iCfg++)
5563	{
5564	Assert((unsigned)paEventCfgs[iCfg].enmType < RT_ELEMENTS(pDbgc->apEventCfgs));
5565	uint16_t iSxEvt = RT_MAKE_U16(paEventCfgs[iCfg].abUnused[1], paEventCfgs[iCfg].abUnused[2]);
5566	Assert(iSxEvt < RT_ELEMENTS(g_aDbgcSxEvents));
5567	rc = dbgcEventUpdate(&pDbgc->apEventCfgs[iSxEvt], pszCmd, (DBGCEVTSTATE)paEventCfgs[iCfg].abUnused[0], fChangeCmdOnly);
5568	if (RT_FAILURE(rc))
5569	return rc;
5570	}
5571	}
5572
5573	/*
5574	* Apply changes to DBGF.
5575	*/
5576	if (!fChangeCmdOnly)
5577	{
5578	if (cIntCfgs)
5579	{
5580	rc = DBGFR3InterruptConfigEx(pUVM, paIntCfgs, cIntCfgs);
5581	if (RT_FAILURE(rc))
5582	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "DBGFR3InterruptConfigEx: %Rrc\n", rc);
5583	}
5584	if (cEventCfgs)
5585	{
5586	rc = DBGFR3EventConfigEx(pUVM, paEventCfgs, cEventCfgs);
5587	if (RT_FAILURE(rc))
5588	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "DBGFR3EventConfigEx: %Rrc\n", rc);
5589	}
5590	}
5591
5592	return VINF_SUCCESS;
5593	}
5594
5595
5596	/**
5597	* @callback_method_impl{FNDBGCCMD, The 'sx[eni-]' commands.}
5598	*/
5599	static DECLCALLBACK(int) dbgcCmdEventCtrl(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
5600	{
5601	/*
5602	* Figure out which command this is.
5603	*/
5604	uint8_t bIntOp;
5605	DBGCEVTSTATE enmEvtState;
5606	bool fChangeCmdOnly;
5607	switch (pCmd->pszCmd[2])
5608	{
5609	case 'e': bIntOp = DBGFINTERRUPTSTATE_ENABLED; enmEvtState = kDbgcEvtState_Enabled; fChangeCmdOnly = false; break;
5610	case 'n': bIntOp = DBGFINTERRUPTSTATE_ENABLED; enmEvtState = kDbgcEvtState_Notify; fChangeCmdOnly = false; break;
5611	case '-': bIntOp = DBGFINTERRUPTSTATE_ENABLED; enmEvtState = kDbgcEvtState_Invalid; fChangeCmdOnly = true; break;
5612	case 'i': bIntOp = DBGFINTERRUPTSTATE_DISABLED; enmEvtState = kDbgcEvtState_Disabled; fChangeCmdOnly = false; break;
5613	default:
5614	return DBGCCmdHlpVBoxError(pCmdHlp, VERR_INVALID_PARAMETER, "pszCmd=%s\n", pCmd->pszCmd);
5615	}
5616
5617	/*
5618	* Command option.
5619	*/
5620	unsigned iArg = 0;
5621	const char *pszCmd = NULL;
5622	if ( cArgs >= iArg + 2
5623	&& paArgs[iArg].enmType == DBGCVAR_TYPE_STRING
5624	&& paArgs[iArg + 1].enmType == DBGCVAR_TYPE_STRING
5625	&& strcmp(paArgs[iArg].u.pszString, "-c") == 0)
5626	{
5627	pszCmd = paArgs[iArg + 1].u.pszString;
5628	iArg += 2;
5629	}
5630	if (fChangeCmdOnly && !pszCmd)
5631	return DBGCCmdHlpVBoxError(pCmdHlp, VERR_INVALID_PARAMETER, "The 'sx-' requires the '-c cmd' arguments.\n");
5632
5633	/*
5634	* The remaining arguments are event specifiers to which the operation should be applied.
5635	*/
5636	uint32_t cIntCfgs = 0;
5637	DBGFINTERRUPTCONFIG aIntCfgs[256];
5638	uint32_t cEventCfgs = 0;
5639	DBGFEVENTCONFIG aEventCfgs[DBGFEVENT_END];
5640
5641	for (; iArg < cArgs; iArg++)
5642	{
5643	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, iArg, paArgs[iArg].enmType == DBGCVAR_TYPE_STRING
5644	\|\| paArgs[iArg].enmType == DBGCVAR_TYPE_SYMBOL);
5645	uint32_t cHits = 0;
5646	for (uint32_t iEvt = 0; iEvt < RT_ELEMENTS(g_aDbgcSxEvents); iEvt++)
5647	if (g_aDbgcSxEvents[iEvt].enmKind == kDbgcSxEventKind_Plain)
5648	{
5649	if ( RTStrSimplePatternMatch(paArgs[iArg].u.pszString, g_aDbgcSxEvents[iEvt].pszName)
5650	\|\| ( g_aDbgcSxEvents[iEvt].pszAltNm
5651	&& RTStrSimplePatternMatch(paArgs[iArg].u.pszString, g_aDbgcSxEvents[iEvt].pszAltNm)) )
5652	{
5653	cEventCfgs = dbgcEventAddPlainConfig(aEventCfgs, cEventCfgs, g_aDbgcSxEvents[iEvt].enmType,
5654	enmEvtState, iEvt);
5655	cHits++;
5656	}
5657	}
5658	else
5659	{
5660	Assert(g_aDbgcSxEvents[iEvt].enmKind == kDbgcSxEventKind_Interrupt);
5661	uint8_t iInt;
5662	uint16_t cInts;
5663	if (dbgcEventIsMatchingInt(&paArgs[iArg], g_aDbgcSxEvents[iEvt].pszName, pCmdHlp, &iInt, &cInts))
5664	{
5665	cIntCfgs = dbgcEventAddIntConfig(aIntCfgs, cIntCfgs, iInt, cInts, g_aDbgcSxEvents[iEvt].pszName,
5666	enmEvtState, bIntOp);
5667	cHits++;
5668	}
5669	}
5670	if (!cHits)
5671	return DBGCCmdHlpVBoxError(pCmdHlp, VERR_INVALID_PARAMETER, "Unknown event: '%s'\n", paArgs[iArg].u.pszString);
5672	}
5673
5674	/*
5675	* Apply the changes.
5676	*/
5677	return dbgcEventApplyChanges(pCmdHlp, pUVM, aIntCfgs, cIntCfgs, aEventCfgs, cEventCfgs, pszCmd, fChangeCmdOnly);
5678	}
5679
5680
5681	/**
5682	* @callback_method_impl{FNDBGCCMD, The 'sxr' commands.}
5683	*/
5684	static DECLCALLBACK(int) dbgcCmdEventCtrlReset(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
5685	{
5686	RT_NOREF1(pCmd);
5687	uint32_t cEventCfgs = 0;
5688	DBGFEVENTCONFIG aEventCfgs[DBGFEVENT_END];
5689	uint32_t cIntCfgs = 0;
5690	DBGFINTERRUPTCONFIG aIntCfgs[256];
5691
5692	if (cArgs == 0)
5693	{
5694	/*
5695	* All events.
5696	*/
5697	for (uint32_t iInt = 0; iInt < 256; iInt++)
5698	{
5699	aIntCfgs[iInt].iInterrupt = iInt;
5700	aIntCfgs[iInt].enmHardState = DBGFINTERRUPTSTATE_DONT_TOUCH;
5701	aIntCfgs[iInt].enmSoftState = DBGFINTERRUPTSTATE_DONT_TOUCH;
5702	}
5703	cIntCfgs = 256;
5704
5705	for (uint32_t iEvt = 0; iEvt < RT_ELEMENTS(g_aDbgcSxEvents); iEvt++)
5706	if (g_aDbgcSxEvents[iEvt].enmKind == kDbgcSxEventKind_Plain)
5707	{
5708	aEventCfgs[cEventCfgs].enmType = g_aDbgcSxEvents[iEvt].enmType;
5709	aEventCfgs[cEventCfgs].fEnabled = g_aDbgcSxEvents[iEvt].enmDefault > kDbgcEvtState_Disabled;
5710	aEventCfgs[cEventCfgs].abUnused[0] = g_aDbgcSxEvents[iEvt].enmDefault;
5711	aEventCfgs[cEventCfgs].abUnused[1] = (uint8_t)iEvt;
5712	aEventCfgs[cEventCfgs].abUnused[2] = (uint8_t)(iEvt >> 8);
5713	cEventCfgs++;
5714	}
5715	else
5716	{
5717	uint8_t const bState = ( g_aDbgcSxEvents[iEvt].enmDefault > kDbgcEvtState_Disabled
5718	? DBGFINTERRUPTSTATE_ENABLED : DBGFINTERRUPTSTATE_DISABLED)
5719	\| ((uint8_t)g_aDbgcSxEvents[iEvt].enmDefault << 4);
5720	if (strcmp(g_aDbgcSxEvents[iEvt].pszName, "hwint") == 0)
5721	for (uint32_t iInt = 0; iInt < 256; iInt++)
5722	aIntCfgs[iInt].enmHardState = bState;
5723	else
5724	for (uint32_t iInt = 0; iInt < 256; iInt++)
5725	aIntCfgs[iInt].enmSoftState = bState;
5726	}
5727	}
5728	else
5729	{
5730	/*
5731	* Selected events.
5732	*/
5733	for (uint32_t iArg = 0; iArg < cArgs; iArg++)
5734	{
5735	unsigned cHits = 0;
5736	for (uint32_t iEvt = 0; iEvt < RT_ELEMENTS(g_aDbgcSxEvents); iEvt++)
5737	if (g_aDbgcSxEvents[iEvt].enmKind == kDbgcSxEventKind_Plain)
5738	{
5739	if ( RTStrSimplePatternMatch(paArgs[iArg].u.pszString, g_aDbgcSxEvents[iEvt].pszName)
5740	\|\| ( g_aDbgcSxEvents[iEvt].pszAltNm
5741	&& RTStrSimplePatternMatch(paArgs[iArg].u.pszString, g_aDbgcSxEvents[iEvt].pszAltNm)) )
5742	{
5743	cEventCfgs = dbgcEventAddPlainConfig(aEventCfgs, cEventCfgs, g_aDbgcSxEvents[iEvt].enmType,
5744	g_aDbgcSxEvents[iEvt].enmDefault, iEvt);
5745	cHits++;
5746	}
5747	}
5748	else
5749	{
5750	Assert(g_aDbgcSxEvents[iEvt].enmKind == kDbgcSxEventKind_Interrupt);
5751	uint8_t iInt;
5752	uint16_t cInts;
5753	if (dbgcEventIsMatchingInt(&paArgs[iArg], g_aDbgcSxEvents[iEvt].pszName, pCmdHlp, &iInt, &cInts))
5754	{
5755	cIntCfgs = dbgcEventAddIntConfig(aIntCfgs, cIntCfgs, iInt, cInts, g_aDbgcSxEvents[iEvt].pszName,
5756	g_aDbgcSxEvents[iEvt].enmDefault,
5757	g_aDbgcSxEvents[iEvt].enmDefault > kDbgcEvtState_Disabled
5758	? DBGFINTERRUPTSTATE_ENABLED : DBGFINTERRUPTSTATE_DISABLED);
5759	cHits++;
5760	}
5761	}
5762	if (!cHits)
5763	return DBGCCmdHlpVBoxError(pCmdHlp, VERR_INVALID_PARAMETER, "Unknown event: '%s'\n", paArgs[iArg].u.pszString);
5764	}
5765	}
5766
5767	/*
5768	* Apply the reset changes.
5769	*/
5770	return dbgcEventApplyChanges(pCmdHlp, pUVM, aIntCfgs, cIntCfgs, aEventCfgs, cEventCfgs, "", false);
5771	}
5772
5773
5774	/**
5775	* Used during DBGC initialization to configure events with defaults.
5776	*
5777	* @returns VBox status code.
5778	* @param pDbgc The DBGC instance.
5779	*/
5780	void dbgcEventInit(PDBGC pDbgc)
5781	{
5782	if (pDbgc->pUVM)
5783	dbgcCmdEventCtrlReset(NULL, &pDbgc->CmdHlp, pDbgc->pUVM, NULL, 0);
5784	}
5785
5786
5787	/**
5788	* Used during DBGC termination to disable all events.
5789	*
5790	* @param pDbgc The DBGC instance.
5791	*/
5792	void dbgcEventTerm(PDBGC pDbgc)
5793	{
5794	/** @todo need to do more than just reset later. */
5795	if (pDbgc->pUVM && VMR3GetStateU(pDbgc->pUVM) < VMSTATE_DESTROYING)
5796	dbgcCmdEventCtrlReset(NULL, &pDbgc->CmdHlp, pDbgc->pUVM, NULL, 0);
5797	}
5798
5799
5800	static void dbgcEventDisplay(PDBGCCMDHLP pCmdHlp, const char pszName, DBGCEVTSTATE enmDefault, PDBGCEVTCFG const ppEvtCfg)
5801	{
5802	RT_NOREF1(enmDefault);
5803	PDBGCEVTCFG pEvtCfg = *ppEvtCfg;
5804
5805	const char *pszState;
5806	switch (pEvtCfg ? pEvtCfg->enmState : kDbgcEvtState_Disabled)
5807	{
5808	case kDbgcEvtState_Disabled: pszState = "ignore"; break;
5809	case kDbgcEvtState_Enabled: pszState = "enabled"; break;
5810	case kDbgcEvtState_Notify: pszState = "notify"; break;
5811	default:
5812	AssertFailed();
5813	pszState = "invalid";
5814	break;
5815	}
5816
5817	if (pEvtCfg && pEvtCfg->cchCmd > 0)
5818	DBGCCmdHlpPrintf(pCmdHlp, "%-22s %-7s \"%s\"\n", pszName, pszState, pEvtCfg->szCmd);
5819	else
5820	DBGCCmdHlpPrintf(pCmdHlp, "%-22s %s\n", pszName, pszState);
5821	}
5822
5823
5824	static void dbgcEventDisplayRange(PDBGCCMDHLP pCmdHlp, const char *pszBaseNm, DBGCEVTSTATE enmDefault,
5825	PDBGCEVTCFG const *papEvtCfgs, unsigned iCfg, unsigned cCfgs)
5826	{
5827	do
5828	{
5829	PCDBGCEVTCFG pFirstCfg = papEvtCfgs[iCfg];
5830	if (pFirstCfg && pFirstCfg->enmState == kDbgcEvtState_Disabled && pFirstCfg->cchCmd == 0)
5831	pFirstCfg = NULL;
5832
5833	unsigned const iFirstCfg = iCfg;
5834	iCfg++;
5835	while (iCfg < cCfgs)
5836	{
5837	PCDBGCEVTCFG pCurCfg = papEvtCfgs[iCfg];
5838	if (pCurCfg && pCurCfg->enmState == kDbgcEvtState_Disabled && pCurCfg->cchCmd == 0)
5839	pCurCfg = NULL;
5840	if (pCurCfg != pFirstCfg)
5841	{
5842	if (!pCurCfg \|\| !pFirstCfg)
5843	break;
5844	if (pCurCfg->enmState != pFirstCfg->enmState)
5845	break;
5846	if (pCurCfg->cchCmd != pFirstCfg->cchCmd)
5847	break;
5848	if (memcmp(pCurCfg->szCmd, pFirstCfg->szCmd, pFirstCfg->cchCmd) != 0)
5849	break;
5850	}
5851	iCfg++;
5852	}
5853
5854	char szName[16];
5855	unsigned cEntries = iCfg - iFirstCfg;
5856	if (cEntries == 1)
5857	RTStrPrintf(szName, sizeof(szName), "%s%02x", pszBaseNm, iFirstCfg);
5858	else
5859	RTStrPrintf(szName, sizeof(szName), "%s%02x L %#x", pszBaseNm, iFirstCfg, cEntries);
5860	dbgcEventDisplay(pCmdHlp, szName, enmDefault, &papEvtCfgs[iFirstCfg]);
5861
5862	cCfgs -= cEntries;
5863	} while (cCfgs > 0);
5864	}
5865
5866
5867	/**
5868	* @callback_method_impl{FNDBGCCMD, The 'sx' commands.}
5869	*/
5870	static DECLCALLBACK(int) dbgcCmdEventCtrlList(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
5871	{
5872	RT_NOREF2(pCmd, pUVM);
5873	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
5874
5875	if (cArgs == 0)
5876	{
5877	/*
5878	* All events.
5879	*/
5880	for (uint32_t iEvt = 0; iEvt < RT_ELEMENTS(g_aDbgcSxEvents); iEvt++)
5881	if (g_aDbgcSxEvents[iEvt].enmKind == kDbgcSxEventKind_Plain)
5882	dbgcEventDisplay(pCmdHlp, g_aDbgcSxEvents[iEvt].pszName, g_aDbgcSxEvents[iEvt].enmDefault,
5883	&pDbgc->apEventCfgs[iEvt]);
5884	else if (strcmp(g_aDbgcSxEvents[iEvt].pszName, "hwint") == 0)
5885	dbgcEventDisplayRange(pCmdHlp, g_aDbgcSxEvents[iEvt].pszName, g_aDbgcSxEvents[iEvt].enmDefault,
5886	pDbgc->apHardInts, 0, 256);
5887	else
5888	dbgcEventDisplayRange(pCmdHlp, g_aDbgcSxEvents[iEvt].pszName, g_aDbgcSxEvents[iEvt].enmDefault,
5889	pDbgc->apSoftInts, 0, 256);
5890	}
5891	else
5892	{
5893	/*
5894	* Selected events.
5895	*/
5896	for (uint32_t iArg = 0; iArg < cArgs; iArg++)
5897	{
5898	unsigned cHits = 0;
5899	for (uint32_t iEvt = 0; iEvt < RT_ELEMENTS(g_aDbgcSxEvents); iEvt++)
5900	if (g_aDbgcSxEvents[iEvt].enmKind == kDbgcSxEventKind_Plain)
5901	{
5902	if ( RTStrSimplePatternMatch(paArgs[iArg].u.pszString, g_aDbgcSxEvents[iEvt].pszName)
5903	\|\| ( g_aDbgcSxEvents[iEvt].pszAltNm
5904	&& RTStrSimplePatternMatch(paArgs[iArg].u.pszString, g_aDbgcSxEvents[iEvt].pszAltNm)) )
5905	{
5906	dbgcEventDisplay(pCmdHlp, g_aDbgcSxEvents[iEvt].pszName, g_aDbgcSxEvents[iEvt].enmDefault,
5907	&pDbgc->apEventCfgs[iEvt]);
5908	cHits++;
5909	}
5910	}
5911	else
5912	{
5913	Assert(g_aDbgcSxEvents[iEvt].enmKind == kDbgcSxEventKind_Interrupt);
5914	uint8_t iInt;
5915	uint16_t cInts;
5916	if (dbgcEventIsMatchingInt(&paArgs[iArg], g_aDbgcSxEvents[iEvt].pszName, pCmdHlp, &iInt, &cInts))
5917	{
5918	if (strcmp(g_aDbgcSxEvents[iEvt].pszName, "hwint") == 0)
5919	dbgcEventDisplayRange(pCmdHlp, g_aDbgcSxEvents[iEvt].pszName, g_aDbgcSxEvents[iEvt].enmDefault,
5920	pDbgc->apHardInts, iInt, cInts);
5921	else
5922	dbgcEventDisplayRange(pCmdHlp, g_aDbgcSxEvents[iEvt].pszName, g_aDbgcSxEvents[iEvt].enmDefault,
5923	pDbgc->apSoftInts, iInt, cInts);
5924	cHits++;
5925	}
5926	}
5927	if (cHits == 0)
5928	return DBGCCmdHlpVBoxError(pCmdHlp, VERR_INVALID_PARAMETER, "Unknown event: '%s'\n", paArgs[iArg].u.pszString);
5929	}
5930	}
5931
5932	return VINF_SUCCESS;
5933	}
5934
5935
5936
5937	/**
5938	* List near symbol.
5939	*
5940	* @returns VBox status code.
5941	* @param pCmdHlp Pointer to command helper functions.
5942	* @param pUVM The user mode VM handle.
5943	* @param pArg Pointer to the address or symbol to lookup.
5944	*/
5945	static int dbgcDoListNear(PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR pArg)
5946	{
5947	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
5948
5949	RTDBGSYMBOL Symbol;
5950	int rc;
5951	if (pArg->enmType == DBGCVAR_TYPE_SYMBOL)
5952	{
5953	/*
5954	* Lookup the symbol address.
5955	*/
5956	rc = DBGFR3AsSymbolByName(pUVM, pDbgc->hDbgAs, pArg->u.pszString, &Symbol, NULL);
5957	if (RT_FAILURE(rc))
5958	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "DBGFR3AsSymbolByName(,,%s,)\n", pArg->u.pszString);
5959
5960	rc = DBGCCmdHlpPrintf(pCmdHlp, "%RTptr %s\n", Symbol.Value, Symbol.szName);
5961	}
5962	else
5963	{
5964	/*
5965	* Convert it to a flat GC address and lookup that address.
5966	*/
5967	DBGCVAR AddrVar;
5968	rc = DBGCCmdHlpEval(pCmdHlp, &AddrVar, "%%(%DV)", pArg);
5969	if (RT_FAILURE(rc))
5970	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "%%(%DV)\n", pArg);
5971
5972	RTINTPTR offDisp;
5973	DBGFADDRESS Addr;
5974	rc = DBGFR3AsSymbolByAddr(pUVM, pDbgc->hDbgAs, DBGFR3AddrFromFlat(pDbgc->pUVM, &Addr, AddrVar.u.GCFlat),
5975	RTDBGSYMADDR_FLAGS_LESS_OR_EQUAL \| RTDBGSYMADDR_FLAGS_SKIP_ABS_IN_DEFERRED,
5976	&offDisp, &Symbol, NULL);
5977	if (RT_FAILURE(rc))
5978	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "DBGFR3AsSymbolByAddr(,,%RGv,,)\n", AddrVar.u.GCFlat);
5979
5980	if (!offDisp)
5981	rc = DBGCCmdHlpPrintf(pCmdHlp, "%DV %s", &AddrVar, Symbol.szName);
5982	else if (offDisp > 0)
5983	rc = DBGCCmdHlpPrintf(pCmdHlp, "%DV %s + %RGv", &AddrVar, Symbol.szName, offDisp);
5984	else
5985	rc = DBGCCmdHlpPrintf(pCmdHlp, "%DV %s - %RGv", &AddrVar, Symbol.szName, -offDisp);
5986	if (Symbol.cb > 0)
5987	rc = DBGCCmdHlpPrintf(pCmdHlp, " (LB %RGv)\n", Symbol.cb);
5988	else
5989	rc = DBGCCmdHlpPrintf(pCmdHlp, "\n");
5990	}
5991
5992	return rc;
5993	}
5994
5995
5996	/**
5997	* @callback_method_impl{FNDBGCCMD, The 'ln' (listnear) command.}
5998	*/
5999	static DECLCALLBACK(int) dbgcCmdListNear(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
6000	{
6001	if (!cArgs)
6002	{
6003	/*
6004	* Current cs:eip symbol.
6005	*/
6006	DBGCVAR AddrVar;
6007	const char *pszFmtExpr = "%%(cs:eip)";
6008	int rc = DBGCCmdHlpEval(pCmdHlp, &AddrVar, pszFmtExpr);
6009	if (RT_FAILURE(rc))
6010	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "%s\n", pszFmtExpr + 1);
6011	return dbgcDoListNear(pCmdHlp, pUVM, &AddrVar);
6012	}
6013
6014	/** @todo Fix the darn parser, it's resolving symbols specified as arguments before we get in here. */
6015	/*
6016	* Iterate arguments.
6017	*/
6018	for (unsigned iArg = 0; iArg < cArgs; iArg++)
6019	{
6020	int rc = dbgcDoListNear(pCmdHlp, pUVM, &paArgs[iArg]);
6021	if (RT_FAILURE(rc))
6022	return rc;
6023	}
6024
6025	NOREF(pCmd);
6026	return VINF_SUCCESS;
6027	}
6028
6029
6030	/**
6031	* Matches the module patters against a module name.
6032	*
6033	* @returns true if matching, otherwise false.
6034	* @param pszName The module name.
6035	* @param paArgs The module pattern argument list.
6036	* @param cArgs Number of arguments.
6037	*/
6038	static bool dbgcCmdListModuleMatch(const char *pszName, PCDBGCVAR paArgs, unsigned cArgs)
6039	{
6040	for (uint32_t i = 0; i < cArgs; i++)
6041	if (RTStrSimplePatternMatch(paArgs[i].u.pszString, pszName))
6042	return true;
6043	return false;
6044	}
6045
6046
6047	/**
6048	* @callback_method_impl{FNDBGCCMD, The 'ln' (list near) command.}
6049	*/
6050	static DECLCALLBACK(int) dbgcCmdListModules(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
6051	{
6052	bool const fMappings = pCmd->pszCmd[2] == 'o';
6053	bool const fVerbose = pCmd->pszCmd[strlen(pCmd->pszCmd) - 1] == 'v';
6054	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
6055
6056	/*
6057	* Iterate the modules in the current address space and print info about
6058	* those matching the input.
6059	*/
6060	RTDBGAS hAsCurAlias = pDbgc->hDbgAs;
6061	for (uint32_t iAs = 0;; iAs++)
6062	{
6063	RTDBGAS hAs = DBGFR3AsResolveAndRetain(pUVM, hAsCurAlias);
6064	uint32_t cMods = RTDbgAsModuleCount(hAs);
6065	for (uint32_t iMod = 0; iMod < cMods; iMod++)
6066	{
6067	RTDBGMOD hMod = RTDbgAsModuleByIndex(hAs, iMod);
6068	if (hMod != NIL_RTDBGMOD)
6069	{
6070	bool const fDeferred = RTDbgModIsDeferred(hMod);
6071	bool const fExports = RTDbgModIsExports(hMod);
6072	uint32_t const cSegs = fDeferred ? 1 : RTDbgModSegmentCount(hMod);
6073	const char * const pszName = RTDbgModName(hMod);
6074	const char * const pszImgFile = RTDbgModImageFile(hMod);
6075	const char * const pszImgFileUsed = RTDbgModImageFileUsed(hMod);
6076	const char * const pszDbgFile = RTDbgModDebugFile(hMod);
6077	if ( cArgs == 0
6078	\|\| dbgcCmdListModuleMatch(pszName, paArgs, cArgs))
6079	{
6080	/*
6081	* Find the mapping with the lower address, preferring a full
6082	* image mapping, for the main line.
6083	*/
6084	RTDBGASMAPINFO aMappings[128];
6085	uint32_t cMappings = RT_ELEMENTS(aMappings);
6086	int rc = RTDbgAsModuleQueryMapByIndex(hAs, iMod, &aMappings[0], &cMappings, 0 /fFlags/);
6087	if (RT_SUCCESS(rc))
6088	{
6089	bool fFull = false;
6090	RTUINTPTR uMin = RTUINTPTR_MAX;
6091	for (uint32_t iMap = 0; iMap < cMappings; iMap++)
6092	if ( aMappings[iMap].Address < uMin
6093	&& ( !fFull
6094	\|\| aMappings[iMap].iSeg == NIL_RTDBGSEGIDX))
6095	uMin = aMappings[iMap].Address;
6096	if (!fVerbose \|\| !pszImgFile)
6097	DBGCCmdHlpPrintf(pCmdHlp, "%RGv %04x %s%s\n", (RTGCUINTPTR)uMin, cSegs, pszName,
6098	fExports ? " (exports)" : fDeferred ? " (deferred)" : "");
6099	else
6100	DBGCCmdHlpPrintf(pCmdHlp, "%RGv %04x %-12s %s%s\n", (RTGCUINTPTR)uMin, cSegs, pszName, pszImgFile,
6101	fExports ? " (exports)" : fDeferred ? " (deferred)" : "");
6102	if (fVerbose && pszImgFileUsed)
6103	DBGCCmdHlpPrintf(pCmdHlp, " Local image: %s\n", pszImgFileUsed);
6104	if (fVerbose && pszDbgFile)
6105	DBGCCmdHlpPrintf(pCmdHlp, " Debug file: %s\n", pszDbgFile);
6106	if (fVerbose)
6107	{
6108	char szTmp[64];
6109	RTTIMESPEC TimeSpec;
6110	int64_t secTs = 0;
6111	if (RT_SUCCESS(RTDbgModImageQueryProp(hMod, RTLDRPROP_TIMESTAMP_SECONDS, &secTs, sizeof(secTs), NULL)))
6112	DBGCCmdHlpPrintf(pCmdHlp, " Timestamp: %08RX64 %s\n", secTs,
6113	RTTimeSpecToString(RTTimeSpecSetSeconds(&TimeSpec, secTs), szTmp, sizeof(szTmp)));
6114	RTUUID Uuid;
6115	if (RT_SUCCESS(RTDbgModImageQueryProp(hMod, RTLDRPROP_UUID, &Uuid, sizeof(Uuid), NULL)))
6116	DBGCCmdHlpPrintf(pCmdHlp, " UUID: %RTuuid\n", &Uuid);
6117	}
6118
6119	if (fMappings)
6120	{
6121	/* sort by address first - not very efficient. */
6122	for (uint32_t i = 0; i + 1 < cMappings; i++)
6123	for (uint32_t j = i + 1; j < cMappings; j++)
6124	if (aMappings[j].Address < aMappings[i].Address)
6125	{
6126	RTDBGASMAPINFO Tmp = aMappings[j];
6127	aMappings[j] = aMappings[i];
6128	aMappings[i] = Tmp;
6129	}
6130
6131	/* print */
6132	if ( cMappings == 1
6133	&& aMappings[0].iSeg == NIL_RTDBGSEGIDX
6134	&& !fDeferred)
6135	{
6136	for (uint32_t iSeg = 0; iSeg < cSegs; iSeg++)
6137	{
6138	RTDBGSEGMENT SegInfo;
6139	rc = RTDbgModSegmentByIndex(hMod, iSeg, &SegInfo);
6140	if (RT_SUCCESS(rc))
6141	{
6142	if (SegInfo.uRva != RTUINTPTR_MAX)
6143	DBGCCmdHlpPrintf(pCmdHlp, " %RGv %RGv #%02x %s\n",
6144	(RTGCUINTPTR)(aMappings[0].Address + SegInfo.uRva),
6145	(RTGCUINTPTR)SegInfo.cb, iSeg, SegInfo.szName);
6146	else
6147	DBGCCmdHlpPrintf(pCmdHlp, " %*s %RGv #%02x %s\n",
6148	sizeof(RTGCUINTPTR)*2, "noload",
6149	(RTGCUINTPTR)SegInfo.cb, iSeg, SegInfo.szName);
6150	}
6151	else
6152	DBGCCmdHlpPrintf(pCmdHlp, " Error query segment #%u: %Rrc\n", iSeg, rc);
6153	}
6154	}
6155	else
6156	{
6157	for (uint32_t iMap = 0; iMap < cMappings; iMap++)
6158	if (aMappings[iMap].iSeg == NIL_RTDBGSEGIDX)
6159	DBGCCmdHlpPrintf(pCmdHlp, " %RGv %RGv <everything>\n",
6160	(RTGCUINTPTR)aMappings[iMap].Address,
6161	(RTGCUINTPTR)RTDbgModImageSize(hMod));
6162	else if (!fDeferred)
6163	{
6164	RTDBGSEGMENT SegInfo;
6165	rc = RTDbgModSegmentByIndex(hMod, aMappings[iMap].iSeg, &SegInfo);
6166	if (RT_FAILURE(rc))
6167	{
6168	RT_ZERO(SegInfo);
6169	strcpy(SegInfo.szName, "error");
6170	}
6171	DBGCCmdHlpPrintf(pCmdHlp, " %RGv %RGv #%02x %s\n",
6172	(RTGCUINTPTR)aMappings[iMap].Address,
6173	(RTGCUINTPTR)SegInfo.cb,
6174	aMappings[iMap].iSeg, SegInfo.szName);
6175	}
6176	else
6177	DBGCCmdHlpPrintf(pCmdHlp, " %RGv #%02x\n",
6178	(RTGCUINTPTR)aMappings[iMap].Address, aMappings[iMap].iSeg);
6179	}
6180	}
6181	}
6182	else
6183	DBGCCmdHlpPrintf(pCmdHlp, "%.*s %04x %s (rc=%Rrc)\n",
6184	sizeof(RTGCPTR) * 2, "???????????", cSegs, pszName, rc);
6185	/** @todo missing address space API for enumerating the mappings. */
6186	}
6187	RTDbgModRelease(hMod);
6188	}
6189	}
6190	RTDbgAsRelease(hAs);
6191
6192	/* For DBGF_AS_RC_AND_GC_GLOBAL we're required to do more work. */
6193	if (hAsCurAlias != DBGF_AS_RC_AND_GC_GLOBAL)
6194	break;
6195	AssertBreak(iAs == 0);
6196	hAsCurAlias = DBGF_AS_GLOBAL;
6197	}
6198
6199	NOREF(pCmd);
6200	return VINF_SUCCESS;
6201	}
6202
6203
6204
6205	/**
6206	* @callback_method_impl{FNDBGCCMD, The 'x' (examine symbols) command.}
6207	*/
6208	static DECLCALLBACK(int) dbgcCmdListSymbols(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
6209	{
6210	AssertReturn(cArgs == 1, VERR_DBGC_PARSE_BUG);
6211	AssertReturn(paArgs[0].enmType == DBGCVAR_TYPE_STRING, VERR_DBGC_PARSE_BUG);
6212
6213	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
6214
6215	/*
6216	* Allowed is either a single * to match everything or the Module!Symbol style
6217	* which requiresa ! to separate module and symbol.
6218	*/
6219	bool fDumpAll = strcmp(paArgs[0].u.pszString, "*") == 0;
6220	const char *pszModule = NULL;
6221	size_t cchModule = 0;
6222	const char *pszSymbol = NULL;
6223	if (!fDumpAll)
6224	{
6225	const char *pszDelimiter = strchr(paArgs[0].u.pszString, '!');
6226	if (!pszDelimiter)
6227	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Invalid search string '%s' for '%s'. Valid are either '*' or the form <Module>!<Symbol> where the <Module> and <Symbol> can contain wildcards",
6228	paArgs[0].u.pszString, pCmd->pszCmd);
6229
6230	pszModule = paArgs[0].u.pszString;
6231	cchModule = pszDelimiter - pszModule;
6232	pszSymbol = pszDelimiter + 1;
6233	}
6234
6235	/*
6236	* Iterate the modules in the current address space and print info about
6237	* those matching the input.
6238	*/
6239	RTDBGAS hAsCurAlias = pDbgc->hDbgAs;
6240	for (uint32_t iAs = 0;; iAs++)
6241	{
6242	RTDBGAS hAs = DBGFR3AsResolveAndRetain(pUVM, hAsCurAlias);
6243	uint32_t cMods = RTDbgAsModuleCount(hAs);
6244	for (uint32_t iMod = 0; iMod < cMods; iMod++)
6245	{
6246	RTDBGMOD hMod = RTDbgAsModuleByIndex(hAs, iMod);
6247	if (hMod != NIL_RTDBGMOD)
6248	{
6249	const char *pszModName = RTDbgModName(hMod);
6250	if ( fDumpAll
6251	\|\| RTStrSimplePatternNMatch(pszModule, cchModule, pszModName, strlen(pszModName)))
6252	{
6253	RTDBGASMAPINFO aMappings[128];
6254	uint32_t cMappings = RT_ELEMENTS(aMappings);
6255	RTUINTPTR uMapping = 0;
6256
6257	/* Get the minimum mapping address of the module so we can print absolute values for the symbol later on. */
6258	int rc = RTDbgAsModuleQueryMapByIndex(hAs, iMod, &aMappings[0], &cMappings, 0 /fFlags/);
6259	if (RT_SUCCESS(rc))
6260	{
6261	uMapping = RTUINTPTR_MAX;
6262	for (uint32_t iMap = 0; iMap < cMappings; iMap++)
6263	if (aMappings[iMap].Address < uMapping)
6264	uMapping = aMappings[iMap].Address;
6265	}
6266
6267	/* Go through the symbols and print any matches. */
6268	uint32_t cSyms = RTDbgModSymbolCount(hMod);
6269	for (uint32_t iSym = 0; iSym < cSyms; iSym++)
6270	{
6271	RTDBGSYMBOL SymInfo;
6272	rc = RTDbgModSymbolByOrdinal(hMod, iSym, &SymInfo);
6273	if ( RT_SUCCESS(rc)
6274	&& ( fDumpAll
6275	\|\| RTStrSimplePatternMatch(pszSymbol, &SymInfo.szName[0])))
6276	DBGCCmdHlpPrintf(pCmdHlp, "%RGv %s!%s\n", uMapping + RTDbgModSegmentRva(hMod, SymInfo.iSeg) + (RTGCUINTPTR)SymInfo.Value, pszModName, &SymInfo.szName[0]);
6277	}
6278	}
6279	RTDbgModRelease(hMod);
6280	}
6281	}
6282	RTDbgAsRelease(hAs);
6283
6284	/* For DBGF_AS_RC_AND_GC_GLOBAL we're required to do more work. */
6285	if (hAsCurAlias != DBGF_AS_RC_AND_GC_GLOBAL)
6286	break;
6287	AssertBreak(iAs == 0);
6288	hAsCurAlias = DBGF_AS_GLOBAL;
6289	}
6290
6291	RT_NOREF(pCmd);
6292	return VINF_SUCCESS;
6293	}
6294
6295
6296	/**
6297	* @callback_method_impl{FNDBGCCMD, The 'tflowc' (clear trace flow) command.}
6298	*/
6299	static DECLCALLBACK(int) dbgcCmdTraceFlowClear(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
6300	{
6301	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
6302
6303	/*
6304	* Enumerate the arguments.
6305	*/
6306	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
6307	int rc = VINF_SUCCESS;
6308	for (unsigned iArg = 0; iArg < cArgs && RT_SUCCESS(rc); iArg++)
6309	{
6310	if (paArgs[iArg].enmType != DBGCVAR_TYPE_STRING)
6311	{
6312	/* one */
6313	uint32_t iFlowTraceMod = (uint32_t)paArgs[iArg].u.u64Number;
6314	if (iFlowTraceMod == paArgs[iArg].u.u64Number)
6315	{
6316	PDBGCTFLOW pFlowTrace = dbgcFlowTraceModGet(pDbgc, iFlowTraceMod);
6317	if (pFlowTrace)
6318	{
6319	rc = DBGFR3FlowTraceModRelease(pFlowTrace->hTraceFlowMod);
6320	if (RT_FAILURE(rc))
6321	rc = DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGFR3FlowTraceModRelease failed for flow trace module %#x", iFlowTraceMod);
6322	rc = DBGFR3FlowRelease(pFlowTrace->hFlow);
6323	if (RT_FAILURE(rc))
6324	rc = DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGFR3FlowRelease failed for flow trace module %#x", iFlowTraceMod);
6325	dbgcFlowTraceModDelete(pDbgc, iFlowTraceMod);
6326	}
6327	else
6328	rc = DBGCCmdHlpFailRc(pCmdHlp, pCmd, VERR_NOT_FOUND, "Flow trace module %#x doesn't exist", iFlowTraceMod);
6329	}
6330	else
6331	rc = DBGCCmdHlpFail(pCmdHlp, pCmd, "Flow trace mod id %RX64 is too large", paArgs[iArg].u.u64Number);
6332	}
6333	else if (!strcmp(paArgs[iArg].u.pszString, "all"))
6334	{
6335	/* all */
6336	PDBGCTFLOW pIt, pItNext;
6337	RTListForEachSafe(&pDbgc->LstTraceFlowMods, pIt, pItNext, DBGCTFLOW, NdTraceFlow)
6338	{
6339	int rc2 = DBGFR3FlowTraceModRelease(pIt->hTraceFlowMod);
6340	if (RT_FAILURE(rc2))
6341	rc = DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc2, "DBGFR3FlowTraceModDisable failed for flow trace module %#x", pIt->iTraceFlowMod);
6342	dbgcFlowTraceModDelete(pDbgc, pIt->iTraceFlowMod);
6343	}
6344	}
6345	else
6346	rc = DBGCCmdHlpFail(pCmdHlp, pCmd, "Invalid argument '%s'", paArgs[iArg].u.pszString);
6347	}
6348	return rc;
6349	}
6350
6351
6352	/**
6353	* @callback_method_impl{FNDBGCCMD, The 'tflowd' (disable trace flow) command.}
6354	*/
6355	static DECLCALLBACK(int) dbgcCmdTraceFlowDisable(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
6356	{
6357	/*
6358	* Enumerate the arguments.
6359	*/
6360	RT_NOREF1(pUVM);
6361	int rc = VINF_SUCCESS;
6362	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
6363	for (unsigned iArg = 0; iArg < cArgs && RT_SUCCESS(rc); iArg++)
6364	{
6365	if (paArgs[iArg].enmType != DBGCVAR_TYPE_STRING)
6366	{
6367	/* one */
6368	uint32_t iFlowTraceMod = (uint32_t)paArgs[iArg].u.u64Number;
6369	if (iFlowTraceMod == paArgs[iArg].u.u64Number)
6370	{
6371	PDBGCTFLOW pFlowTrace = dbgcFlowTraceModGet(pDbgc, iFlowTraceMod);
6372	if (pFlowTrace)
6373	{
6374	rc = DBGFR3FlowTraceModDisable(pFlowTrace->hTraceFlowMod);
6375	if (RT_FAILURE(rc))
6376	rc = DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGFR3FlowTraceModDisable failed for flow trace module %#x", iFlowTraceMod);
6377	}
6378	else
6379	rc = DBGCCmdHlpFailRc(pCmdHlp, pCmd, VERR_NOT_FOUND, "Flow trace module %#x doesn't exist", iFlowTraceMod);
6380	}
6381	else
6382	rc = DBGCCmdHlpFail(pCmdHlp, pCmd, "Breakpoint id %RX64 is too large", paArgs[iArg].u.u64Number);
6383	}
6384	else if (!strcmp(paArgs[iArg].u.pszString, "all"))
6385	{
6386	/* all */
6387	PDBGCTFLOW pIt;
6388	RTListForEach(&pDbgc->LstTraceFlowMods, pIt, DBGCTFLOW, NdTraceFlow)
6389	{
6390	int rc2 = DBGFR3FlowTraceModDisable(pIt->hTraceFlowMod);
6391	if (RT_FAILURE(rc2))
6392	rc = DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc2, "DBGFR3FlowTraceModDisable failed for flow trace module %#x",
6393	pIt->iTraceFlowMod);
6394	}
6395	}
6396	else
6397	rc = DBGCCmdHlpFail(pCmdHlp, pCmd, "Invalid argument '%s'", paArgs[iArg].u.pszString);
6398	}
6399	return rc;
6400	}
6401
6402
6403	/**
6404	* @callback_method_impl{FNDBGCCMD, The 'tflowe' (enable trace flow) command.}
6405	*/
6406	static DECLCALLBACK(int) dbgcCmdTraceFlowEnable(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
6407	{
6408	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
6409
6410	/*
6411	* Validate input.
6412	*/
6413	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
6414	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, -1, cArgs <= 2);
6415	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, cArgs == 0 \|\| DBGCVAR_ISPOINTER(paArgs[0].enmType));
6416
6417	if (!cArgs && !DBGCVAR_ISPOINTER(pDbgc->DisasmPos.enmType))
6418	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Don't know where to start disassembling");
6419
6420	/*
6421	* Check the desired mode.
6422	*/
6423	unsigned fFlags = DBGF_DISAS_FLAGS_UNPATCHED_BYTES \| DBGF_DISAS_FLAGS_ANNOTATE_PATCHED \| DBGF_DISAS_FLAGS_DEFAULT_MODE;
6424
6425	/** @todo should use DBGFADDRESS for everything */
6426
6427	/*
6428	* Find address.
6429	*/
6430	if (!cArgs)
6431	{
6432	if (!DBGCVAR_ISPOINTER(pDbgc->DisasmPos.enmType))
6433	{
6434	/** @todo Batch query CS, RIP, CPU mode and flags. */
6435	PVMCPU pVCpu = VMMR3GetCpuByIdU(pUVM, pDbgc->idCpu);
6436	if (CPUMIsGuestIn64BitCode(pVCpu))
6437	{
6438	pDbgc->DisasmPos.enmType = DBGCVAR_TYPE_GC_FLAT;
6439	pDbgc->SourcePos.u.GCFlat = CPUMGetGuestRIP(pVCpu);
6440	}
6441	else
6442	{
6443	pDbgc->DisasmPos.enmType = DBGCVAR_TYPE_GC_FAR;
6444	pDbgc->SourcePos.u.GCFar.off = CPUMGetGuestEIP(pVCpu);
6445	pDbgc->SourcePos.u.GCFar.sel = CPUMGetGuestCS(pVCpu);
6446	if ( (fFlags & DBGF_DISAS_FLAGS_MODE_MASK) == DBGF_DISAS_FLAGS_DEFAULT_MODE
6447	&& (CPUMGetGuestEFlags(pVCpu) & X86_EFL_VM))
6448	{
6449	fFlags &= ~DBGF_DISAS_FLAGS_MODE_MASK;
6450	fFlags \|= DBGF_DISAS_FLAGS_16BIT_REAL_MODE;
6451	}
6452	}
6453
6454	fFlags \|= DBGF_DISAS_FLAGS_CURRENT_GUEST;
6455	}
6456	else if ((fFlags & DBGF_DISAS_FLAGS_MODE_MASK) == DBGF_DISAS_FLAGS_DEFAULT_MODE && pDbgc->fDisasm)
6457	{
6458	fFlags &= ~DBGF_DISAS_FLAGS_MODE_MASK;
6459	fFlags \|= pDbgc->fDisasm & DBGF_DISAS_FLAGS_MODE_MASK;
6460	}
6461	pDbgc->DisasmPos.enmRangeType = DBGCVAR_RANGE_NONE;
6462	}
6463	else
6464	pDbgc->DisasmPos = paArgs[0];
6465	pDbgc->pLastPos = &pDbgc->DisasmPos;
6466
6467	/*
6468	* Convert physical and host addresses to guest addresses.
6469	*/
6470	RTDBGAS hDbgAs = pDbgc->hDbgAs;
6471	int rc;
6472	switch (pDbgc->DisasmPos.enmType)
6473	{
6474	case DBGCVAR_TYPE_GC_FLAT:
6475	case DBGCVAR_TYPE_GC_FAR:
6476	break;
6477	case DBGCVAR_TYPE_GC_PHYS:
6478	hDbgAs = DBGF_AS_PHYS;
6479	/* fall thru */
6480	case DBGCVAR_TYPE_HC_FLAT:
6481	case DBGCVAR_TYPE_HC_PHYS:
6482	{
6483	DBGCVAR VarTmp;
6484	rc = DBGCCmdHlpEval(pCmdHlp, &VarTmp, "%%(%Dv)", &pDbgc->DisasmPos);
6485	if (RT_FAILURE(rc))
6486	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "failed to evaluate '%%(%Dv)'", &pDbgc->DisasmPos);
6487	pDbgc->DisasmPos = VarTmp;
6488	break;
6489	}
6490	default: AssertFailed(); break;
6491	}
6492
6493	DBGFADDRESS CurAddr;
6494	if ( (fFlags & DBGF_DISAS_FLAGS_MODE_MASK) == DBGF_DISAS_FLAGS_16BIT_REAL_MODE
6495	&& pDbgc->DisasmPos.enmType == DBGCVAR_TYPE_GC_FAR)
6496	DBGFR3AddrFromFlat(pUVM, &CurAddr, ((uint32_t)pDbgc->DisasmPos.u.GCFar.sel << 4) + pDbgc->DisasmPos.u.GCFar.off);
6497	else
6498	{
6499	rc = DBGCCmdHlpVarToDbgfAddr(pCmdHlp, &pDbgc->DisasmPos, &CurAddr);
6500	if (RT_FAILURE(rc))
6501	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGCCmdHlpVarToDbgfAddr failed on '%Dv'", &pDbgc->DisasmPos);
6502	}
6503
6504	DBGFFLOW hCfg;
6505	rc = DBGFR3FlowCreate(pUVM, pDbgc->idCpu, &CurAddr, 0 /cbDisasmMax/,
6506	DBGF_FLOW_CREATE_F_TRY_RESOLVE_INDIRECT_BRANCHES, fFlags, &hCfg);
6507	if (RT_SUCCESS(rc))
6508	{
6509	/* Create a probe. */
6510	DBGFFLOWTRACEPROBE hFlowTraceProbe = NULL;
6511	DBGFFLOWTRACEPROBE hFlowTraceProbeExit = NULL;
6512	DBGFFLOWTRACEPROBEENTRY Entry;
6513	DBGFFLOWTRACEMOD hFlowTraceMod = NULL;
6514	uint32_t iTraceModId = 0;
6515
6516	RT_ZERO(Entry);
6517	Entry.enmType = DBGFFLOWTRACEPROBEENTRYTYPE_DEBUGGER;
6518
6519	rc = DBGFR3FlowTraceProbeCreate(pUVM, NULL, &hFlowTraceProbe);
6520	if (RT_SUCCESS(rc))
6521	rc = DBGFR3FlowTraceProbeCreate(pUVM, NULL, &hFlowTraceProbeExit);
6522	if (RT_SUCCESS(rc))
6523	rc = DBGFR3FlowTraceProbeEntriesAdd(hFlowTraceProbeExit, &Entry, 1 /cEntries/);
6524	if (RT_SUCCESS(rc))
6525	rc = DBGFR3FlowTraceModCreateFromFlowGraph(pUVM, VMCPUID_ANY, hCfg, NULL,
6526	hFlowTraceProbe, hFlowTraceProbe,
6527	hFlowTraceProbeExit, &hFlowTraceMod);
6528	if (RT_SUCCESS(rc))
6529	rc = dbgcFlowTraceModAdd(pDbgc, hFlowTraceMod, hCfg, &iTraceModId);
6530	if (RT_SUCCESS(rc))
6531	rc = DBGFR3FlowTraceModEnable(hFlowTraceMod, 0, 0);
6532	if (RT_SUCCESS(rc))
6533	DBGCCmdHlpPrintf(pCmdHlp, "Enabled execution flow tracing %u at %RGv\n",
6534	iTraceModId, CurAddr.FlatPtr);
6535
6536	if (hFlowTraceProbe)
6537	DBGFR3FlowTraceProbeRelease(hFlowTraceProbe);
6538	if (hFlowTraceProbeExit)
6539	DBGFR3FlowTraceProbeRelease(hFlowTraceProbeExit);
6540	}
6541	else
6542	rc = DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGFR3FlowCreate failed on '%Dv'", &pDbgc->DisasmPos);
6543
6544	NOREF(pCmd);
6545	return rc;
6546	}
6547
6548
6549	/**
6550	* Enumerates and prints all records contained in the given flow tarce module.
6551	*
6552	* @returns VBox status code.
6553	* @param pCmd The command.
6554	* @param pCmdHlp The command helpers.
6555	* @param hFlowTraceMod The flow trace module to print.
6556	* @param hFlow The control flow graph assoicated with the given module.
6557	* @param iFlowTraceMod The flow trace module identifier.
6558	*/
6559	static int dbgcCmdTraceFlowPrintOne(PDBGCCMDHLP pCmdHlp, PCDBGCCMD pCmd, DBGFFLOWTRACEMOD hFlowTraceMod,
6560	DBGFFLOW hFlow, uint32_t iFlowTraceMod)
6561	{
6562	RT_NOREF(hFlow);
6563
6564	DBGFFLOWTRACEREPORT hFlowTraceReport;
6565	int rc = DBGFR3FlowTraceModQueryReport(hFlowTraceMod, &hFlowTraceReport);
6566	if (RT_SUCCESS(rc))
6567	{
6568	uint32_t cRecords = DBGFR3FlowTraceReportGetRecordCount(hFlowTraceReport);
6569	DBGCCmdHlpPrintf(pCmdHlp, "Report for flow trace module %#x (%u records):\n",
6570	iFlowTraceMod, cRecords);
6571
6572	PDBGCFLOWBBDUMP paDumpBb = (PDBGCFLOWBBDUMP)RTMemTmpAllocZ(cRecords * sizeof(DBGCFLOWBBDUMP));
6573	if (RT_LIKELY(paDumpBb))
6574	{
6575	/* Query the basic block referenced for each record and calculate the size. */
6576	for (uint32_t i = 0; i < cRecords && RT_SUCCESS(rc); i++)
6577	{
6578	DBGFFLOWTRACERECORD hRec = NULL;
6579	rc = DBGFR3FlowTraceReportQueryRecord(hFlowTraceReport, i, &hRec);
6580	if (RT_SUCCESS(rc))
6581	{
6582	DBGFADDRESS Addr;
6583	DBGFR3FlowTraceRecordGetAddr(hRec, &Addr);
6584
6585	DBGFFLOWBB hFlowBb = NULL;
6586	rc = DBGFR3FlowQueryBbByAddress(hFlow, &Addr, &hFlowBb);
6587	if (RT_SUCCESS(rc))
6588	dbgcCmdUnassembleCfgDumpCalcBbSize(hFlowBb, &paDumpBb[i]);
6589
6590	DBGFR3FlowTraceRecordRelease(hRec);
6591	}
6592	}
6593
6594	if (RT_SUCCESS(rc))
6595	{
6596	/* Calculate the ASCII screen dimensions and create one. */
6597	uint32_t cchWidth = 0;
6598	uint32_t cchHeight = 0;
6599	for (unsigned i = 0; i < cRecords; i++)
6600	{
6601	PDBGCFLOWBBDUMP pDumpBb = &paDumpBb[i];
6602	cchWidth = RT_MAX(cchWidth, pDumpBb->cchWidth);
6603	cchHeight += pDumpBb->cchHeight;
6604
6605	/* Incomplete blocks don't have a successor. */
6606	if (DBGFR3FlowBbGetFlags(pDumpBb->hFlowBb) & DBGF_FLOW_BB_F_INCOMPLETE_ERR)
6607	continue;
6608
6609	cchHeight += 2; /* For the arrow down to the next basic block. */
6610	}
6611
6612
6613	DBGCSCREEN hScreen = NULL;
6614	rc = dbgcScreenAsciiCreate(&hScreen, cchWidth, cchHeight);
6615	if (RT_SUCCESS(rc))
6616	{
6617	uint32_t uY = 0;
6618
6619	/* Dump the basic blocks and connections to the immediate successor. */
6620	for (unsigned i = 0; i < cRecords; i++)
6621	{
6622	paDumpBb[i].uStartX = (cchWidth - paDumpBb[i].cchWidth) / 2;
6623	paDumpBb[i].uStartY = uY;
6624	dbgcCmdUnassembleCfgDumpBb(&paDumpBb[i], hScreen);
6625	uY += paDumpBb[i].cchHeight;
6626
6627	/* Incomplete blocks don't have a successor. */
6628	if (DBGFR3FlowBbGetFlags(paDumpBb[i].hFlowBb) & DBGF_FLOW_BB_F_INCOMPLETE_ERR)
6629	continue;
6630
6631	if (DBGFR3FlowBbGetType(paDumpBb[i].hFlowBb) != DBGFFLOWBBENDTYPE_EXIT)
6632	{
6633	/* Draw the arrow down to the next block. */
6634	dbgcScreenAsciiDrawCharacter(hScreen, cchWidth / 2, uY,
6635	'\|', DBGCSCREENCOLOR_BLUE_BRIGHT);
6636	uY++;
6637	dbgcScreenAsciiDrawCharacter(hScreen, cchWidth / 2, uY,
6638	'V', DBGCSCREENCOLOR_BLUE_BRIGHT);
6639	uY++;
6640	}
6641	}
6642
6643	rc = dbgcScreenAsciiBlit(hScreen, dbgcCmdUnassembleCfgBlit, pCmdHlp, false /fUseColor/);
6644	dbgcScreenAsciiDestroy(hScreen);
6645	}
6646	else
6647	rc = DBGCCmdHlpFail(pCmdHlp, pCmd, "Failed to create virtual screen for flow trace module %#x", iFlowTraceMod);
6648	}
6649	else
6650	rc = DBGCCmdHlpFail(pCmdHlp, pCmd, "Failed to query all records of flow trace module %#x", iFlowTraceMod);
6651
6652	for (unsigned i = 0; i < cRecords; i++)
6653	{
6654	if (paDumpBb[i].hFlowBb)
6655	DBGFR3FlowBbRelease(paDumpBb[i].hFlowBb);
6656	}
6657
6658	RTMemTmpFree(paDumpBb);
6659	}
6660	else
6661	rc = DBGCCmdHlpFail(pCmdHlp, pCmd, "Failed to allocate memory for %u records", cRecords);
6662
6663	DBGFR3FlowTraceReportRelease(hFlowTraceReport);
6664	}
6665	else
6666	rc = DBGCCmdHlpFail(pCmdHlp, pCmd, "Failed to query report for flow trace module %#x", iFlowTraceMod);
6667
6668	return rc;
6669	}
6670
6671
6672	/**
6673	* @callback_method_impl{FNDBGCCMD, The 'tflowp' (print trace flow) command.}
6674	*/
6675	static DECLCALLBACK(int) dbgcCmdTraceFlowPrint(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
6676	{
6677	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
6678
6679	/*
6680	* Enumerate the arguments.
6681	*/
6682	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
6683	int rc = VINF_SUCCESS;
6684	for (unsigned iArg = 0; iArg < cArgs && RT_SUCCESS(rc); iArg++)
6685	{
6686	if (paArgs[iArg].enmType != DBGCVAR_TYPE_STRING)
6687	{
6688	/* one */
6689	uint32_t iFlowTraceMod = (uint32_t)paArgs[iArg].u.u64Number;
6690	if (iFlowTraceMod == paArgs[iArg].u.u64Number)
6691	{
6692	PDBGCTFLOW pFlowTrace = dbgcFlowTraceModGet(pDbgc, iFlowTraceMod);
6693	if (pFlowTrace)
6694	rc = dbgcCmdTraceFlowPrintOne(pCmdHlp, pCmd, pFlowTrace->hTraceFlowMod,
6695	pFlowTrace->hFlow, pFlowTrace->iTraceFlowMod);
6696	else
6697	rc = DBGCCmdHlpFailRc(pCmdHlp, pCmd, VERR_NOT_FOUND, "Flow trace module %#x doesn't exist", iFlowTraceMod);
6698	}
6699	else
6700	rc = DBGCCmdHlpFail(pCmdHlp, pCmd, "Flow trace mod id %RX64 is too large", paArgs[iArg].u.u64Number);
6701	}
6702	else if (!strcmp(paArgs[iArg].u.pszString, "all"))
6703	{
6704	/* all */
6705	PDBGCTFLOW pIt;
6706	RTListForEach(&pDbgc->LstTraceFlowMods, pIt, DBGCTFLOW, NdTraceFlow)
6707	{
6708	rc = dbgcCmdTraceFlowPrintOne(pCmdHlp, pCmd, pIt->hTraceFlowMod,
6709	pIt->hFlow, pIt->iTraceFlowMod);
6710	if (RT_FAILURE(rc))
6711	break;
6712	}
6713	}
6714	else
6715	rc = DBGCCmdHlpFail(pCmdHlp, pCmd, "Invalid argument '%s'", paArgs[iArg].u.pszString);
6716	}
6717	return rc;
6718	}
6719
6720
6721	/**
6722	* @callback_method_impl{FNDBGCCMD, The 'tflowr' (reset trace flow) command.}
6723	*/
6724	static DECLCALLBACK(int) dbgcCmdTraceFlowReset(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
6725	{
6726	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
6727
6728	/*
6729	* Enumerate the arguments.
6730	*/
6731	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
6732	int rc = VINF_SUCCESS;
6733	for (unsigned iArg = 0; iArg < cArgs && RT_SUCCESS(rc); iArg++)
6734	{
6735	if (paArgs[iArg].enmType != DBGCVAR_TYPE_STRING)
6736	{
6737	/* one */
6738	uint32_t iFlowTraceMod = (uint32_t)paArgs[iArg].u.u64Number;
6739	if (iFlowTraceMod == paArgs[iArg].u.u64Number)
6740	{
6741	PDBGCTFLOW pFlowTrace = dbgcFlowTraceModGet(pDbgc, iFlowTraceMod);
6742	if (pFlowTrace)
6743	{
6744	rc = DBGFR3FlowTraceModClear(pFlowTrace->hTraceFlowMod);
6745	if (RT_FAILURE(rc))
6746	rc = DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGFR3FlowTraceModClear failed for flow trace module %#x", iFlowTraceMod);
6747	}
6748	else
6749	rc = DBGCCmdHlpFailRc(pCmdHlp, pCmd, VERR_NOT_FOUND, "Flow trace module %#x doesn't exist", iFlowTraceMod);
6750	}
6751	else
6752	rc = DBGCCmdHlpFail(pCmdHlp, pCmd, "Flow trace mod id %RX64 is too large", paArgs[iArg].u.u64Number);
6753	}
6754	else if (!strcmp(paArgs[iArg].u.pszString, "all"))
6755	{
6756	/* all */
6757	PDBGCTFLOW pIt;
6758	RTListForEach(&pDbgc->LstTraceFlowMods, pIt, DBGCTFLOW, NdTraceFlow)
6759	{
6760	rc = DBGFR3FlowTraceModClear(pIt->hTraceFlowMod);
6761	if (RT_FAILURE(rc))
6762	rc = DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGFR3FlowTraceModClear failed for flow trace module %#x", pIt->iTraceFlowMod);
6763	}
6764	}
6765	else
6766	rc = DBGCCmdHlpFail(pCmdHlp, pCmd, "Invalid argument '%s'", paArgs[iArg].u.pszString);
6767	}
6768	return rc;
6769	}
6770
6771
6772
6773	/**
6774	* @callback_method_impl{FNDBGCFUNC, Reads a unsigned 8-bit value.}
6775	*/
6776	static DECLCALLBACK(int) dbgcFuncReadU8(PCDBGCFUNC pFunc, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, uint32_t cArgs,
6777	PDBGCVAR pResult)
6778	{
6779	RT_NOREF1(pUVM);
6780	AssertReturn(cArgs == 1, VERR_DBGC_PARSE_BUG);
6781	AssertReturn(DBGCVAR_ISPOINTER(paArgs[0].enmType), VERR_DBGC_PARSE_BUG);
6782	AssertReturn(paArgs[0].enmRangeType == DBGCVAR_RANGE_NONE, VERR_DBGC_PARSE_BUG);
6783
6784	uint8_t b;
6785	int rc = DBGCCmdHlpMemRead(pCmdHlp, &b, sizeof(b), &paArgs[0], NULL);
6786	if (RT_FAILURE(rc))
6787	return rc;
6788	DBGCVAR_INIT_NUMBER(pResult, b);
6789
6790	NOREF(pFunc);
6791	return VINF_SUCCESS;
6792	}
6793
6794
6795	/**
6796	* @callback_method_impl{FNDBGCFUNC, Reads a unsigned 16-bit value.}
6797	*/
6798	static DECLCALLBACK(int) dbgcFuncReadU16(PCDBGCFUNC pFunc, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, uint32_t cArgs,
6799	PDBGCVAR pResult)
6800	{
6801	RT_NOREF1(pUVM);
6802	AssertReturn(cArgs == 1, VERR_DBGC_PARSE_BUG);
6803	AssertReturn(DBGCVAR_ISPOINTER(paArgs[0].enmType), VERR_DBGC_PARSE_BUG);
6804	AssertReturn(paArgs[0].enmRangeType == DBGCVAR_RANGE_NONE, VERR_DBGC_PARSE_BUG);
6805
6806	uint16_t u16;
6807	int rc = DBGCCmdHlpMemRead(pCmdHlp, &u16, sizeof(u16), &paArgs[0], NULL);
6808	if (RT_FAILURE(rc))
6809	return rc;
6810	DBGCVAR_INIT_NUMBER(pResult, u16);
6811
6812	NOREF(pFunc);
6813	return VINF_SUCCESS;
6814	}
6815
6816
6817	/**
6818	* @callback_method_impl{FNDBGCFUNC, Reads a unsigned 32-bit value.}
6819	*/
6820	static DECLCALLBACK(int) dbgcFuncReadU32(PCDBGCFUNC pFunc, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, uint32_t cArgs,
6821	PDBGCVAR pResult)
6822	{
6823	RT_NOREF1(pUVM);
6824	AssertReturn(cArgs == 1, VERR_DBGC_PARSE_BUG);
6825	AssertReturn(DBGCVAR_ISPOINTER(paArgs[0].enmType), VERR_DBGC_PARSE_BUG);
6826	AssertReturn(paArgs[0].enmRangeType == DBGCVAR_RANGE_NONE, VERR_DBGC_PARSE_BUG);
6827
6828	uint32_t u32;
6829	int rc = DBGCCmdHlpMemRead(pCmdHlp, &u32, sizeof(u32), &paArgs[0], NULL);
6830	if (RT_FAILURE(rc))
6831	return rc;
6832	DBGCVAR_INIT_NUMBER(pResult, u32);
6833
6834	NOREF(pFunc);
6835	return VINF_SUCCESS;
6836	}
6837
6838
6839	/**
6840	* @callback_method_impl{FNDBGCFUNC, Reads a unsigned 64-bit value.}
6841	*/
6842	static DECLCALLBACK(int) dbgcFuncReadU64(PCDBGCFUNC pFunc, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, uint32_t cArgs,
6843	PDBGCVAR pResult)
6844	{
6845	RT_NOREF1(pUVM);
6846	AssertReturn(cArgs == 1, VERR_DBGC_PARSE_BUG);
6847	AssertReturn(DBGCVAR_ISPOINTER(paArgs[0].enmType), VERR_DBGC_PARSE_BUG);
6848	AssertReturn(paArgs[0].enmRangeType == DBGCVAR_RANGE_NONE, VERR_DBGC_PARSE_BUG);
6849
6850	uint64_t u64;
6851	int rc = DBGCCmdHlpMemRead(pCmdHlp, &u64, sizeof(u64), &paArgs[0], NULL);
6852	if (RT_FAILURE(rc))
6853	return rc;
6854	DBGCVAR_INIT_NUMBER(pResult, u64);
6855
6856	NOREF(pFunc);
6857	return VINF_SUCCESS;
6858	}
6859
6860
6861	/**
6862	* @callback_method_impl{FNDBGCFUNC, Reads a unsigned pointer-sized value.}
6863	*/
6864	static DECLCALLBACK(int) dbgcFuncReadPtr(PCDBGCFUNC pFunc, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, uint32_t cArgs,
6865	PDBGCVAR pResult)
6866	{
6867	AssertReturn(cArgs == 1, VERR_DBGC_PARSE_BUG);
6868	AssertReturn(DBGCVAR_ISPOINTER(paArgs[0].enmType), VERR_DBGC_PARSE_BUG);
6869	AssertReturn(paArgs[0].enmRangeType == DBGCVAR_RANGE_NONE, VERR_DBGC_PARSE_BUG);
6870
6871	CPUMMODE enmMode = DBGCCmdHlpGetCpuMode(pCmdHlp);
6872	if (enmMode == CPUMMODE_LONG)
6873	return dbgcFuncReadU64(pFunc, pCmdHlp, pUVM, paArgs, cArgs, pResult);
6874	return dbgcFuncReadU32(pFunc, pCmdHlp, pUVM, paArgs, cArgs, pResult);
6875	}
6876
6877
6878	/**
6879	* @callback_method_impl{FNDBGCFUNC, The hi(value) function implementation.}
6880	*/
6881	static DECLCALLBACK(int) dbgcFuncHi(PCDBGCFUNC pFunc, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, uint32_t cArgs,
6882	PDBGCVAR pResult)
6883	{
6884	AssertReturn(cArgs == 1, VERR_DBGC_PARSE_BUG);
6885
6886	uint16_t uHi;
6887	switch (paArgs[0].enmType)
6888	{
6889	case DBGCVAR_TYPE_GC_FLAT: uHi = (uint16_t)(paArgs[0].u.GCFlat >> 16); break;
6890	case DBGCVAR_TYPE_GC_FAR: uHi = (uint16_t)paArgs[0].u.GCFar.sel; break;
6891	case DBGCVAR_TYPE_GC_PHYS: uHi = (uint16_t)(paArgs[0].u.GCPhys >> 16); break;
6892	case DBGCVAR_TYPE_HC_FLAT: uHi = (uint16_t)((uintptr_t)paArgs[0].u.pvHCFlat >> 16); break;
6893	case DBGCVAR_TYPE_HC_PHYS: uHi = (uint16_t)(paArgs[0].u.HCPhys >> 16); break;
6894	case DBGCVAR_TYPE_NUMBER: uHi = (uint16_t)(paArgs[0].u.u64Number >> 16); break;
6895	default:
6896	AssertFailedReturn(VERR_DBGC_PARSE_BUG);
6897	}
6898	DBGCVAR_INIT_NUMBER(pResult, uHi);
6899	DBGCVAR_SET_RANGE(pResult, paArgs[0].enmRangeType, paArgs[0].u64Range);
6900
6901	NOREF(pFunc); NOREF(pCmdHlp); NOREF(pUVM);
6902	return VINF_SUCCESS;
6903	}
6904
6905
6906	/**
6907	* @callback_method_impl{FNDBGCFUNC, The low(value) function implementation.}
6908	*/
6909	static DECLCALLBACK(int) dbgcFuncLow(PCDBGCFUNC pFunc, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, uint32_t cArgs,
6910	PDBGCVAR pResult)
6911	{
6912	AssertReturn(cArgs == 1, VERR_DBGC_PARSE_BUG);
6913
6914	uint16_t uLow;
6915	switch (paArgs[0].enmType)
6916	{
6917	case DBGCVAR_TYPE_GC_FLAT: uLow = (uint16_t)paArgs[0].u.GCFlat; break;
6918	case DBGCVAR_TYPE_GC_FAR: uLow = (uint16_t)paArgs[0].u.GCFar.off; break;
6919	case DBGCVAR_TYPE_GC_PHYS: uLow = (uint16_t)paArgs[0].u.GCPhys; break;
6920	case DBGCVAR_TYPE_HC_FLAT: uLow = (uint16_t)(uintptr_t)paArgs[0].u.pvHCFlat; break;
6921	case DBGCVAR_TYPE_HC_PHYS: uLow = (uint16_t)paArgs[0].u.HCPhys; break;
6922	case DBGCVAR_TYPE_NUMBER: uLow = (uint16_t)paArgs[0].u.u64Number; break;
6923	default:
6924	AssertFailedReturn(VERR_DBGC_PARSE_BUG);
6925	}
6926	DBGCVAR_INIT_NUMBER(pResult, uLow);
6927	DBGCVAR_SET_RANGE(pResult, paArgs[0].enmRangeType, paArgs[0].u64Range);
6928
6929	NOREF(pFunc); NOREF(pCmdHlp); NOREF(pUVM);
6930	return VINF_SUCCESS;
6931	}
6932
6933
6934	/**
6935	* @callback_method_impl{FNDBGCFUNC,The low(value) function implementation.}
6936	*/
6937	static DECLCALLBACK(int) dbgcFuncNot(PCDBGCFUNC pFunc, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, uint32_t cArgs,
6938	PDBGCVAR pResult)
6939	{
6940	AssertReturn(cArgs == 1, VERR_DBGC_PARSE_BUG);
6941	NOREF(pFunc); NOREF(pCmdHlp); NOREF(pUVM);
6942	return DBGCCmdHlpEval(pCmdHlp, pResult, "!(%Dv)", &paArgs[0]);
6943	}
6944
6945
6946	/** Generic pointer argument wo/ range. */
6947	static const DBGCVARDESC g_aArgPointerWoRange[] =
6948	{
6949	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
6950	{ 1, 1, DBGCVAR_CAT_POINTER_NO_RANGE, 0, "value", "Address or number." },
6951	};
6952
6953	/** Generic pointer or number argument. */
6954	static const DBGCVARDESC g_aArgPointerNumber[] =
6955	{
6956	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
6957	{ 1, 1, DBGCVAR_CAT_POINTER_NUMBER, 0, "value", "Address or number." },
6958	};
6959
6960
6961
6962	/** Function descriptors for the CodeView / WinDbg emulation.
6963	* The emulation isn't attempting to be identical, only somewhat similar.
6964	*/
6965	const DBGCFUNC g_aFuncsCodeView[] =
6966	{
6967	{ "by", 1, 1, &g_aArgPointerWoRange[0], RT_ELEMENTS(g_aArgPointerWoRange), 0, dbgcFuncReadU8, "address", "Reads a byte at the given address." },
6968	{ "dwo", 1, 1, &g_aArgPointerWoRange[0], RT_ELEMENTS(g_aArgPointerWoRange), 0, dbgcFuncReadU32, "address", "Reads a 32-bit value at the given address." },
6969	{ "hi", 1, 1, &g_aArgPointerNumber[0], RT_ELEMENTS(g_aArgPointerNumber), 0, dbgcFuncHi, "value", "Returns the high 16-bit bits of a value." },
6970	{ "low", 1, 1, &g_aArgPointerNumber[0], RT_ELEMENTS(g_aArgPointerNumber), 0, dbgcFuncLow, "value", "Returns the low 16-bit bits of a value." },
6971	{ "not", 1, 1, &g_aArgPointerNumber[0], RT_ELEMENTS(g_aArgPointerNumber), 0, dbgcFuncNot, "address", "Boolean NOT." },
6972	{ "poi", 1, 1, &g_aArgPointerWoRange[0], RT_ELEMENTS(g_aArgPointerWoRange), 0, dbgcFuncReadPtr, "address", "Reads a pointer sized (CS) value at the given address." },
6973	{ "qwo", 1, 1, &g_aArgPointerWoRange[0], RT_ELEMENTS(g_aArgPointerWoRange), 0, dbgcFuncReadU64, "address", "Reads a 32-bit value at the given address." },
6974	{ "wo", 1, 1, &g_aArgPointerWoRange[0], RT_ELEMENTS(g_aArgPointerWoRange), 0, dbgcFuncReadU16, "address", "Reads a 16-bit value at the given address." },
6975	};
6976
6977	/** The number of functions in the CodeView/WinDbg emulation. */
6978	const uint32_t g_cFuncsCodeView = RT_ELEMENTS(g_aFuncsCodeView);
6979

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

source: vbox/trunk/src/VBox/Debugger/DBGCEmulateCodeView.cpp@ 91514

Download in other formats: