DBGCEmulateCodeView.cpp@ 87594

Last change on this file since 87594 was 87594, checked in by vboxsync, 4 years ago
VMM/DBGF,Debugger: Removed the !defined(VBOX_WITH_LOTS_OF_DBGF_BPS) code. bugref:9837
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 290.0 KB

Line
1	/* $Id: DBGCEmulateCodeView.cpp 87594 2021-02-03 20:23:46Z 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/pgm.h>
26	#include <VBox/vmm/cpum.h>
27	#include <VBox/dis.h>
28	#include <VBox/param.h>
29	#include <VBox/err.h>
30	#include <VBox/log.h>
31
32	#include <iprt/asm.h>
33	#include <iprt/mem.h>
34	#include <iprt/string.h>
35	#include <iprt/assert.h>
36	#include <iprt/ctype.h>
37	#include <iprt/time.h>
38
39	#include <stdlib.h>
40	#include <stdio.h>
41
42	#include "DBGCInternal.h"
43
44
45	/*********************************************************************************************************************************
46	* Internal Functions *
47	*********************************************************************************************************************************/
48	static FNDBGCCMD dbgcCmdBrkAccess;
49	static FNDBGCCMD dbgcCmdBrkClear;
50	static FNDBGCCMD dbgcCmdBrkDisable;
51	static FNDBGCCMD dbgcCmdBrkEnable;
52	static FNDBGCCMD dbgcCmdBrkList;
53	static FNDBGCCMD dbgcCmdBrkSet;
54	static FNDBGCCMD dbgcCmdBrkREM;
55	static FNDBGCCMD dbgcCmdDumpMem;
56	static FNDBGCCMD dbgcCmdDumpDT;
57	static FNDBGCCMD dbgcCmdDumpIDT;
58	static FNDBGCCMD dbgcCmdDumpPageDir;
59	static FNDBGCCMD dbgcCmdDumpPageDirBoth;
60	static FNDBGCCMD dbgcCmdDumpPageHierarchy;
61	static FNDBGCCMD dbgcCmdDumpPageTable;
62	static FNDBGCCMD dbgcCmdDumpPageTableBoth;
63	static FNDBGCCMD dbgcCmdDumpTSS;
64	static FNDBGCCMD dbgcCmdDumpTypeInfo;
65	static FNDBGCCMD dbgcCmdDumpTypedVal;
66	static FNDBGCCMD dbgcCmdEditMem;
67	static FNDBGCCMD dbgcCmdGo;
68	static FNDBGCCMD dbgcCmdGoUp;
69	static FNDBGCCMD dbgcCmdListModules;
70	static FNDBGCCMD dbgcCmdListNear;
71	static FNDBGCCMD dbgcCmdListSource;
72	static FNDBGCCMD dbgcCmdListSymbols;
73	static FNDBGCCMD dbgcCmdMemoryInfo;
74	static FNDBGCCMD dbgcCmdReg;
75	static FNDBGCCMD dbgcCmdRegGuest;
76	static FNDBGCCMD dbgcCmdRegTerse;
77	static FNDBGCCMD dbgcCmdSearchMem;
78	static FNDBGCCMD dbgcCmdSearchMemType;
79	static FNDBGCCMD dbgcCmdStepTrace;
80	static FNDBGCCMD dbgcCmdStepTraceTo;
81	static FNDBGCCMD dbgcCmdStepTraceToggle;
82	static FNDBGCCMD dbgcCmdEventCtrl;
83	static FNDBGCCMD dbgcCmdEventCtrlList;
84	static FNDBGCCMD dbgcCmdEventCtrlReset;
85	static FNDBGCCMD dbgcCmdStack;
86	static FNDBGCCMD dbgcCmdUnassemble;
87	static FNDBGCCMD dbgcCmdUnassembleCfg;
88
89
90	/*********************************************************************************************************************************
91	* Global Variables *
92	*********************************************************************************************************************************/
93	/** 'ba' arguments. */
94	static const DBGCVARDESC g_aArgBrkAcc[] =
95	{
96	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
97	{ 1, 1, DBGCVAR_CAT_STRING, 0, "access", "The access type: x=execute, rw=read/write (alias r), w=write, i=not implemented." },
98	{ 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." },
99	{ 1, 1, DBGCVAR_CAT_GC_POINTER, 0, "address", "The address." },
100	{ 0, 1, DBGCVAR_CAT_NUMBER, 0, "passes", "The number of passes before we trigger the breakpoint. (0 is default)" },
101	{ 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)" },
102	{ 0, 1, DBGCVAR_CAT_STRING, 0, "cmds", "String of commands to be executed when the breakpoint is hit. Quote it!" },
103	};
104
105
106	/** 'bc', 'bd', 'be' arguments. */
107	static const DBGCVARDESC g_aArgBrks[] =
108	{
109	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
110	{ 0, ~0U, DBGCVAR_CAT_NUMBER, 0, "#bp", "Breakpoint number." },
111	{ 0, 1, DBGCVAR_CAT_STRING, 0, "all", "All breakpoints." },
112	};
113
114
115	/** 'bp' arguments. */
116	static const DBGCVARDESC g_aArgBrkSet[] =
117	{
118	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
119	{ 1, 1, DBGCVAR_CAT_GC_POINTER, 0, "address", "The address." },
120	{ 0, 1, DBGCVAR_CAT_NUMBER, 0, "passes", "The number of passes before we trigger the breakpoint. (0 is default)" },
121	{ 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)" },
122	{ 0, 1, DBGCVAR_CAT_STRING, 0, "cmds", "String of commands to be executed when the breakpoint is hit. Quote it!" },
123	};
124
125
126	/** 'br' arguments. */
127	static const DBGCVARDESC g_aArgBrkREM[] =
128	{
129	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
130	{ 1, 1, DBGCVAR_CAT_GC_POINTER, 0, "address", "The address." },
131	{ 0, 1, DBGCVAR_CAT_NUMBER, 0, "passes", "The number of passes before we trigger the breakpoint. (0 is default)" },
132	{ 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)" },
133	{ 0, 1, DBGCVAR_CAT_STRING, 0, "cmds", "String of commands to be executed when the breakpoint is hit. Quote it!" },
134	};
135
136
137	/** 'd?' arguments. */
138	static const DBGCVARDESC g_aArgDumpMem[] =
139	{
140	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
141	{ 0, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address where to start dumping memory." },
142	};
143
144
145	/** 'dg', 'dga', 'dl', 'dla' arguments. */
146	static const DBGCVARDESC g_aArgDumpDT[] =
147	{
148	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
149	{ 0, ~0U, DBGCVAR_CAT_NUMBER, 0, "sel", "Selector or selector range." },
150	{ 0, ~0U, DBGCVAR_CAT_POINTER, 0, "address", "Far address which selector should be dumped." },
151	};
152
153
154	/** 'di', 'dia' arguments. */
155	static const DBGCVARDESC g_aArgDumpIDT[] =
156	{
157	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
158	{ 0, ~0U, DBGCVAR_CAT_NUMBER, 0, "int", "The interrupt vector or interrupt vector range." },
159	};
160
161
162	/** 'dpd' arguments. /
163	static const DBGCVARDESC g_aArgDumpPD[] =
164	{
165	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
166	{ 0, 1, DBGCVAR_CAT_NUMBER, 0, "index", "Index into the page directory." },
167	{ 0, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address which page directory entry to start dumping from. Range is applied to the page directory." },
168	};
169
170
171	/** 'dpda' arguments. */
172	static const DBGCVARDESC g_aArgDumpPDAddr[] =
173	{
174	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
175	{ 0, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address of the page directory entry to start dumping from." },
176	};
177
178
179	/** 'dph' arguments. /
180	static const DBGCVARDESC g_aArgDumpPH[] =
181	{
182	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
183	{ 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." },
184	{ 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." },
185	{ 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." },
186	};
187
188
189	/** 'dpt?' arguments. */
190	static const DBGCVARDESC g_aArgDumpPT[] =
191	{
192	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
193	{ 1, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address which page directory entry to start dumping from." },
194	};
195
196
197	/** 'dpta' arguments. */
198	static const DBGCVARDESC g_aArgDumpPTAddr[] =
199	{
200	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
201	{ 1, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address of the page table entry to start dumping from." },
202	};
203
204
205	/** 'dt' arguments. */
206	static const DBGCVARDESC g_aArgDumpTSS[] =
207	{
208	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
209	{ 0, 1, DBGCVAR_CAT_NUMBER, 0, "tss", "TSS selector number." },
210	{ 0, 1, DBGCVAR_CAT_POINTER, 0, "tss:ign\|addr", "TSS address. If the selector is a TSS selector, the offset will be ignored." }
211	};
212
213
214	/** 'dti' arguments. */
215	static const DBGCVARDESC g_aArgDumpTypeInfo[] =
216	{
217	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
218	{ 1, 1, DBGCVAR_CAT_STRING, 0, "type", "The type to dump" },
219	{ 0, 1, DBGCVAR_CAT_NUMBER, 0, "levels", "How many levels to dump the type information" }
220	};
221
222
223	/** 'dtv' arguments. */
224	static const DBGCVARDESC g_aArgDumpTypedVal[] =
225	{
226	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
227	{ 1, 1, DBGCVAR_CAT_STRING, 0, "type", "The type to use" },
228	{ 1, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address to start dumping from." },
229	{ 0, 1, DBGCVAR_CAT_NUMBER, 0, "levels", "How many levels to dump" }
230	};
231
232
233	/** 'e?' arguments. */
234	static const DBGCVARDESC g_aArgEditMem[] =
235	{
236	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
237	{ 1, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address where to write." },
238	{ 1, ~0U, DBGCVAR_CAT_NUMBER, 0, "value", "Value to write." },
239	};
240
241
242	/** 'g' arguments. */
243	static const DBGCVARDESC g_aArgGo[] =
244	{
245	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
246	{ 0, 1, DBGCVAR_CAT_NUMBER, 0, "idCpu", "CPU ID." },
247	};
248
249
250	/** 'lm' arguments. */
251	static const DBGCVARDESC g_aArgListMods[] =
252	{
253	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
254	{ 0, ~0U, DBGCVAR_CAT_STRING, 0, "module", "Module name." },
255	};
256
257
258	/** 'ln' arguments. */
259	static const DBGCVARDESC g_aArgListNear[] =
260	{
261	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
262	{ 0, ~0U, DBGCVAR_CAT_POINTER, 0, "address", "Address of the symbol to look up." },
263	{ 0, ~0U, DBGCVAR_CAT_SYMBOL, 0, "symbol", "Symbol to lookup." },
264	};
265
266
267	/** 'ls' arguments. */
268	static const DBGCVARDESC g_aArgListSource[] =
269	{
270	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
271	{ 0, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address where to start looking for source lines." },
272	};
273
274
275	/** 'm' argument. */
276	static const DBGCVARDESC g_aArgMemoryInfo[] =
277	{
278	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
279	{ 1, 1, DBGCVAR_CAT_POINTER, 0, "address", "Pointer to obtain info about." },
280	};
281
282
283	/** 'p', 'pc', 'pt', 't', 'tc' and 'tt' arguments. */
284	static const DBGCVARDESC g_aArgStepTrace[] =
285	{
286	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
287	{ 0, 1, DBGCVAR_CAT_NUMBER, 0, "count", "Number of instructions or source lines to step." },
288	{ 0, 1, DBGCVAR_CAT_STRING, 0, "cmds", "String of commands to be executed afterwards. Quote it!" },
289	};
290
291
292	/** 'pa' and 'ta' arguments. */
293	static const DBGCVARDESC g_aArgStepTraceTo[] =
294	{
295	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
296	{ 1, 1, DBGCVAR_CAT_POINTER, 0, "address", "Where to stop" },
297	{ 0, 1, DBGCVAR_CAT_STRING, 0, "cmds", "String of commands to be executed afterwards. Quote it!" },
298	};
299
300
301	/** 'r' arguments. */
302	static const DBGCVARDESC g_aArgReg[] =
303	{
304	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
305	{ 0, 1, DBGCVAR_CAT_SYMBOL, 0, "register", "Register to show or set." },
306	{ 0, 1, DBGCVAR_CAT_STRING, DBGCVD_FLAGS_DEP_PREV, "=", "Equal sign." },
307	{ 0, 1, DBGCVAR_CAT_NUMBER, DBGCVD_FLAGS_DEP_PREV, "value", "New register value." },
308	};
309
310
311	/** 's' arguments. */
312	static const DBGCVARDESC g_aArgSearchMem[] =
313	{
314	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
315	{ 0, 1, DBGCVAR_CAT_OPTION, 0, "-b", "Byte string." },
316	{ 0, 1, DBGCVAR_CAT_OPTION, 0, "-w", "Word string." },
317	{ 0, 1, DBGCVAR_CAT_OPTION, 0, "-d", "DWord string." },
318	{ 0, 1, DBGCVAR_CAT_OPTION, 0, "-q", "QWord string." },
319	{ 0, 1, DBGCVAR_CAT_OPTION, 0, "-a", "ASCII string." },
320	{ 0, 1, DBGCVAR_CAT_OPTION, 0, "-u", "Unicode string." },
321	{ 0, 1, DBGCVAR_CAT_OPTION_NUMBER, 0, "-n <Hits>", "Maximum number of hits." },
322	{ 0, 1, DBGCVAR_CAT_GC_POINTER, 0, "range", "Register to show or set." },
323	{ 0, ~0U, DBGCVAR_CAT_ANY, 0, "pattern", "Pattern to search for." },
324	};
325
326
327	/** 's?' arguments. */
328	static const DBGCVARDESC g_aArgSearchMemType[] =
329	{
330	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
331	{ 1, 1, DBGCVAR_CAT_GC_POINTER, 0, "range", "Register to show or set." },
332	{ 1, ~0U, DBGCVAR_CAT_ANY, 0, "pattern", "Pattern to search for." },
333	};
334
335
336	/** 'sxe', 'sxn', 'sxi', 'sx-' arguments. */
337	static const DBGCVARDESC g_aArgEventCtrl[] =
338	{
339	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
340	{ 0, 1, DBGCVAR_CAT_STRING, 0, "-c", "The -c option, requires <cmds>." },
341	{ 0, 1, DBGCVAR_CAT_STRING, DBGCVD_FLAGS_DEP_PREV, "cmds", "Command to execute on this event." },
342	{ 0 /weird/, ~0U, DBGCVAR_CAT_STRING, 0, "event", "One or more events, 'all' refering to all events." },
343	};
344
345	/** 'sx' and 'sr' arguments. */
346	static const DBGCVARDESC g_aArgEventCtrlOpt[] =
347	{
348	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
349	{ 0, ~0U, DBGCVAR_CAT_STRING, 0, "event", "Zero or more events, 'all' refering to all events and being the default." },
350	};
351
352	/** 'u' arguments. */
353	static const DBGCVARDESC g_aArgUnassemble[] =
354	{
355	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
356	{ 0, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address where to start disassembling." },
357	};
358
359	/** 'ucfg' arguments. */
360	static const DBGCVARDESC g_aArgUnassembleCfg[] =
361	{
362	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
363	{ 0, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address where to start disassembling." },
364	};
365
366	/** 'x' arguments. */
367	static const DBGCVARDESC g_aArgListSyms[] =
368	{
369	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
370	{ 1, 1, DBGCVAR_CAT_STRING, 0, "symbols", "The symbols to list, format is Module!Symbol with wildcards being supoprted." }
371	};
372
373
374	/** Command descriptors for the CodeView / WinDbg emulation.
375	* The emulation isn't attempting to be identical, only somewhat similar.
376	*/
377	const DBGCCMD g_aCmdsCodeView[] =
378	{
379	/* pszCmd, cArgsMin, cArgsMax, paArgDescs, cArgDescs, fFlags, pfnHandler pszSyntax, ....pszDescription */
380	{ "ba", 3, 6, &g_aArgBrkAcc[0], RT_ELEMENTS(g_aArgBrkAcc), 0, dbgcCmdBrkAccess, "<access> <size> <address> [passes [max passes]] [cmds]",
381	"Sets a data access breakpoint." },
382	{ "bc", 1, ~0U, &g_aArgBrks[0], RT_ELEMENTS(g_aArgBrks), 0, dbgcCmdBrkClear, "all \| <bp#> [bp# []]", "Deletes a set of breakpoints." },
383	{ "bd", 1, ~0U, &g_aArgBrks[0], RT_ELEMENTS(g_aArgBrks), 0, dbgcCmdBrkDisable, "all \| <bp#> [bp# []]", "Disables a set of breakpoints." },
384	{ "be", 1, ~0U, &g_aArgBrks[0], RT_ELEMENTS(g_aArgBrks), 0, dbgcCmdBrkEnable, "all \| <bp#> [bp# []]", "Enables a set of breakpoints." },
385	{ "bl", 0, 0, NULL, 0, 0, dbgcCmdBrkList, "", "Lists all the breakpoints." },
386	{ "bp", 1, 4, &g_aArgBrkSet[0], RT_ELEMENTS(g_aArgBrkSet), 0, dbgcCmdBrkSet, "<address> [passes [max passes]] [cmds]",
387	"Sets a breakpoint (int 3)." },
388	{ "br", 1, 4, &g_aArgBrkREM[0], RT_ELEMENTS(g_aArgBrkREM), 0, dbgcCmdBrkREM, "<address> [passes [max passes]] [cmds]",
389	"Sets a recompiler specific breakpoint." },
390	{ "d", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), 0, dbgcCmdDumpMem, "[addr]", "Dump memory using last element size and type." },
391	{ "dF", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), 0, dbgcCmdDumpMem, "[addr]", "Dump memory as far 16:16." },
392	{ "dFs", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), 0, dbgcCmdDumpMem, "[addr]", "Dump memory as far 16:16 with near symbols." },
393	{ "da", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), 0, dbgcCmdDumpMem, "[addr]", "Dump memory as ascii string." },
394	{ "db", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), 0, dbgcCmdDumpMem, "[addr]", "Dump memory in bytes." },
395	{ "dd", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), 0, dbgcCmdDumpMem, "[addr]", "Dump memory in double words." },
396	{ "dds", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), 0, dbgcCmdDumpMem, "[addr]", "Dump memory as double words with near symbols." },
397	{ "da", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), 0, dbgcCmdDumpMem, "[addr]", "Dump memory as ascii string." },
398	{ "dg", 0, ~0U, &g_aArgDumpDT[0], RT_ELEMENTS(g_aArgDumpDT), 0, dbgcCmdDumpDT, "[sel [..]]", "Dump the global descriptor table (GDT)." },
399	{ "dga", 0, ~0U, &g_aArgDumpDT[0], RT_ELEMENTS(g_aArgDumpDT), 0, dbgcCmdDumpDT, "[sel [..]]", "Dump the global descriptor table (GDT) including not-present entries." },
400	{ "di", 0, ~0U, &g_aArgDumpIDT[0], RT_ELEMENTS(g_aArgDumpIDT), 0, dbgcCmdDumpIDT, "[int [..]]", "Dump the interrupt descriptor table (IDT)." },
401	{ "dia", 0, ~0U, &g_aArgDumpIDT[0], RT_ELEMENTS(g_aArgDumpIDT), 0, dbgcCmdDumpIDT, "[int [..]]", "Dump the interrupt descriptor table (IDT) including not-present entries." },
402	{ "dl", 0, ~0U, &g_aArgDumpDT[0], RT_ELEMENTS(g_aArgDumpDT), 0, dbgcCmdDumpDT, "[sel [..]]", "Dump the local descriptor table (LDT)." },
403	{ "dla", 0, ~0U, &g_aArgDumpDT[0], RT_ELEMENTS(g_aArgDumpDT), 0, dbgcCmdDumpDT, "[sel [..]]", "Dump the local descriptor table (LDT) including not-present entries." },
404	{ "dpd", 0, 1, &g_aArgDumpPD[0], RT_ELEMENTS(g_aArgDumpPD), 0, dbgcCmdDumpPageDir, "[addr\|index]", "Dumps page directory entries of the default context." },
405	{ "dpda", 0, 1, &g_aArgDumpPDAddr[0],RT_ELEMENTS(g_aArgDumpPDAddr), 0, dbgcCmdDumpPageDir, "[addr]", "Dumps memory at given address as a page directory." },
406	{ "dpdb", 0, 1, &g_aArgDumpPD[0], RT_ELEMENTS(g_aArgDumpPD), 0, dbgcCmdDumpPageDirBoth, "[addr\|index]", "Dumps page directory entries of the guest and the hypervisor. " },
407	{ "dpdg", 0, 1, &g_aArgDumpPD[0], RT_ELEMENTS(g_aArgDumpPD), 0, dbgcCmdDumpPageDir, "[addr\|index]", "Dumps page directory entries of the guest." },
408	{ "dpdh", 0, 1, &g_aArgDumpPD[0], RT_ELEMENTS(g_aArgDumpPD), 0, dbgcCmdDumpPageDir, "[addr\|index]", "Dumps page directory entries of the hypervisor. " },
409	{ "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." },
410	{ "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." },
411	{ "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." },
412	{ "dp", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), 0, dbgcCmdDumpMem, "[addr]", "Dump memory in mode sized words." },
413	{ "dps", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), 0, dbgcCmdDumpMem, "[addr]", "Dump memory in mode sized words with near symbols." },
414	{ "dpt", 1, 1, &g_aArgDumpPT[0], RT_ELEMENTS(g_aArgDumpPT), 0, dbgcCmdDumpPageTable,"<addr>", "Dumps page table entries of the default context." },
415	{ "dpta", 1, 1, &g_aArgDumpPTAddr[0],RT_ELEMENTS(g_aArgDumpPTAddr), 0, dbgcCmdDumpPageTable,"<addr>", "Dumps memory at given address as a page table." },
416	{ "dptb", 1, 1, &g_aArgDumpPT[0], RT_ELEMENTS(g_aArgDumpPT), 0, dbgcCmdDumpPageTableBoth,"<addr>", "Dumps page table entries of the guest and the hypervisor." },
417	{ "dptg", 1, 1, &g_aArgDumpPT[0], RT_ELEMENTS(g_aArgDumpPT), 0, dbgcCmdDumpPageTable,"<addr>", "Dumps page table entries of the guest." },
418	{ "dpth", 1, 1, &g_aArgDumpPT[0], RT_ELEMENTS(g_aArgDumpPT), 0, dbgcCmdDumpPageTable,"<addr>", "Dumps page table entries of the hypervisor." },
419	{ "dq", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), 0, dbgcCmdDumpMem, "[addr]", "Dump memory in quad words." },
420	{ "dqs", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), 0, dbgcCmdDumpMem, "[addr]", "Dump memory as quad words with near symbols." },
421	{ "dt", 0, 1, &g_aArgDumpTSS[0], RT_ELEMENTS(g_aArgDumpTSS), 0, dbgcCmdDumpTSS, "[tss\|tss:ign\|addr]", "Dump the task state segment (TSS)." },
422	{ "dt16", 0, 1, &g_aArgDumpTSS[0], RT_ELEMENTS(g_aArgDumpTSS), 0, dbgcCmdDumpTSS, "[tss\|tss:ign\|addr]", "Dump the 16-bit task state segment (TSS)." },
423	{ "dt32", 0, 1, &g_aArgDumpTSS[0], RT_ELEMENTS(g_aArgDumpTSS), 0, dbgcCmdDumpTSS, "[tss\|tss:ign\|addr]", "Dump the 32-bit task state segment (TSS)." },
424	{ "dt64", 0, 1, &g_aArgDumpTSS[0], RT_ELEMENTS(g_aArgDumpTSS), 0, dbgcCmdDumpTSS, "[tss\|tss:ign\|addr]", "Dump the 64-bit task state segment (TSS)." },
425	{ "dti", 1, 2, &g_aArgDumpTypeInfo[0],RT_ELEMENTS(g_aArgDumpTypeInfo), 0, dbgcCmdDumpTypeInfo,"<type> [levels]", "Dump type information." },
426	{ "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." },
427	{ "du", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), 0, dbgcCmdDumpMem, "[addr]", "Dump memory as unicode string (little endian)." },
428	{ "dw", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), 0, dbgcCmdDumpMem, "[addr]", "Dump memory in words." },
429	/** @todo add 'e', 'ea str', 'eza str', 'eu str' and 'ezu str'. See also
430	* dbgcCmdSearchMem and its dbgcVarsToBytes usage. */
431	{ "eb", 2, 2, &g_aArgEditMem[0], RT_ELEMENTS(g_aArgEditMem), 0, dbgcCmdEditMem, "<addr> <value>", "Write a 1-byte value to memory." },
432	{ "ew", 2, 2, &g_aArgEditMem[0], RT_ELEMENTS(g_aArgEditMem), 0, dbgcCmdEditMem, "<addr> <value>", "Write a 2-byte value to memory." },
433	{ "ed", 2, 2, &g_aArgEditMem[0], RT_ELEMENTS(g_aArgEditMem), 0, dbgcCmdEditMem, "<addr> <value>", "Write a 4-byte value to memory." },
434	{ "eq", 2, 2, &g_aArgEditMem[0], RT_ELEMENTS(g_aArgEditMem), 0, dbgcCmdEditMem, "<addr> <value>", "Write a 8-byte value to memory." },
435	{ "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.)" },
436	{ "gu", 0, 0, NULL, 0, 0, dbgcCmdGoUp, "", "Go up - continue execution till after return." },
437	{ "k", 0, 0, NULL, 0, 0, dbgcCmdStack, "", "Callstack." },
438	{ "kv", 0, 0, NULL, 0, 0, dbgcCmdStack, "", "Verbose callstack." },
439	{ "kg", 0, 0, NULL, 0, 0, dbgcCmdStack, "", "Callstack - guest." },
440	{ "kgv", 0, 0, NULL, 0, 0, dbgcCmdStack, "", "Verbose callstack - guest." },
441	{ "kh", 0, 0, NULL, 0, 0, dbgcCmdStack, "", "Callstack - hypervisor." },
442	{ "lm", 0, ~0U, &g_aArgListMods[0], RT_ELEMENTS(g_aArgListMods), 0, dbgcCmdListModules, "[module [..]]", "List modules." },
443	{ "lmv", 0, ~0U, &g_aArgListMods[0], RT_ELEMENTS(g_aArgListMods), 0, dbgcCmdListModules, "[module [..]]", "List modules, verbose." },
444	{ "lmo", 0, ~0U, &g_aArgListMods[0], RT_ELEMENTS(g_aArgListMods), 0, dbgcCmdListModules, "[module [..]]", "List modules and their segments." },
445	{ "lmov", 0, ~0U, &g_aArgListMods[0], RT_ELEMENTS(g_aArgListMods), 0, dbgcCmdListModules, "[module [..]]", "List modules and their segments, verbose." },
446	{ "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." },
447	{ "ls", 0, 1, &g_aArgListSource[0],RT_ELEMENTS(g_aArgListSource), 0, dbgcCmdListSource, "[addr]", "Source." },
448	{ "m", 1, 1, &g_aArgMemoryInfo[0],RT_ELEMENTS(g_aArgMemoryInfo), 0, dbgcCmdMemoryInfo, "<addr>", "Display information about that piece of memory." },
449	{ "p", 0, 2, &g_aArgStepTrace[0], RT_ELEMENTS(g_aArgStepTrace), 0, dbgcCmdStepTrace, "[count] [cmds]", "Step over." },
450	{ "pr", 0, 0, NULL, 0, 0, dbgcCmdStepTraceToggle, "", "Toggle displaying registers for tracing & stepping (no code executed)." },
451	{ "pa", 1, 1, &g_aArgStepTraceTo[0], RT_ELEMENTS(g_aArgStepTraceTo), 0, dbgcCmdStepTraceTo, "<addr> [count] [cmds]","Step to the given address." },
452	{ "pc", 0, 0, &g_aArgStepTrace[0], RT_ELEMENTS(g_aArgStepTrace), 0, dbgcCmdStepTrace, "[count] [cmds]", "Step to the next call instruction." },
453	{ "pt", 0, 0, &g_aArgStepTrace[0], RT_ELEMENTS(g_aArgStepTrace), 0, dbgcCmdStepTrace, "[count] [cmds]", "Step to the next return instruction." },
454	{ "r", 0, 3, &g_aArgReg[0], RT_ELEMENTS(g_aArgReg), 0, dbgcCmdReg, "[reg [[=] newval]]", "Show or set register(s) - active reg set." },
455	{ "rg", 0, 3, &g_aArgReg[0], RT_ELEMENTS(g_aArgReg), 0, dbgcCmdRegGuest, "[reg [[=] newval]]", "Show or set register(s) - guest reg set." },
456	{ "rg32", 0, 0, NULL, 0, 0, dbgcCmdRegGuest, "", "Show 32-bit guest registers." },
457	{ "rg64", 0, 0, NULL, 0, 0, dbgcCmdRegGuest, "", "Show 64-bit guest registers." },
458	{ "rt", 0, 0, NULL, 0, 0, dbgcCmdRegTerse, "", "Toggles terse / verbose register info." },
459	{ "s", 0, ~0U, &g_aArgSearchMem[0], RT_ELEMENTS(g_aArgSearchMem), 0, dbgcCmdSearchMem, "[options] <range> <pattern>", "Continue last search." },
460	{ "sa", 2, ~0U, &g_aArgSearchMemType[0], RT_ELEMENTS(g_aArgSearchMemType),0, dbgcCmdSearchMemType, "<range> <pattern>", "Search memory for an ascii string." },
461	{ "sb", 2, ~0U, &g_aArgSearchMemType[0], RT_ELEMENTS(g_aArgSearchMemType),0, dbgcCmdSearchMemType, "<range> <pattern>", "Search memory for one or more bytes." },
462	{ "sd", 2, ~0U, &g_aArgSearchMemType[0], RT_ELEMENTS(g_aArgSearchMemType),0, dbgcCmdSearchMemType, "<range> <pattern>", "Search memory for one or more double words." },
463	{ "sq", 2, ~0U, &g_aArgSearchMemType[0], RT_ELEMENTS(g_aArgSearchMemType),0, dbgcCmdSearchMemType, "<range> <pattern>", "Search memory for one or more quad words." },
464	{ "su", 2, ~0U, &g_aArgSearchMemType[0], RT_ELEMENTS(g_aArgSearchMemType),0, dbgcCmdSearchMemType, "<range> <pattern>", "Search memory for an unicode string." },
465	{ "sw", 2, ~0U, &g_aArgSearchMemType[0], RT_ELEMENTS(g_aArgSearchMemType),0, dbgcCmdSearchMemType, "<range> <pattern>", "Search memory for one or more words." },
466	{ "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." },
467	{ "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." },
468	{ "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." },
469	{ "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." },
470	{ "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." },
471	{ "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." },
472	{ "t", 0, 2, &g_aArgStepTrace[0], RT_ELEMENTS(g_aArgStepTrace), 0, dbgcCmdStepTrace, "[count] [cmds]", "Trace ." },
473	{ "tr", 0, 0, NULL, 0, 0, dbgcCmdStepTraceToggle, "", "Toggle displaying registers for tracing & stepping (no code executed)." },
474	{ "ta", 1, 1, &g_aArgStepTraceTo[0], RT_ELEMENTS(g_aArgStepTraceTo), 0, dbgcCmdStepTraceTo, "<addr> [count] [cmds]","Trace to the given address." },
475	{ "tc", 0, 0, &g_aArgStepTrace[0], RT_ELEMENTS(g_aArgStepTrace), 0, dbgcCmdStepTrace, "[count] [cmds]", "Trace to the next call instruction." },
476	{ "tt", 0, 0, &g_aArgStepTrace[0], RT_ELEMENTS(g_aArgStepTrace), 0, dbgcCmdStepTrace, "[count] [cmds]", "Trace to the next return instruction." },
477	{ "u", 0, 1, &g_aArgUnassemble[0],RT_ELEMENTS(g_aArgUnassemble), 0, dbgcCmdUnassemble, "[addr]", "Unassemble." },
478	{ "u64", 0, 1, &g_aArgUnassemble[0],RT_ELEMENTS(g_aArgUnassemble), 0, dbgcCmdUnassemble, "[addr]", "Unassemble 64-bit code." },
479	{ "u32", 0, 1, &g_aArgUnassemble[0],RT_ELEMENTS(g_aArgUnassemble), 0, dbgcCmdUnassemble, "[addr]", "Unassemble 32-bit code." },
480	{ "u16", 0, 1, &g_aArgUnassemble[0],RT_ELEMENTS(g_aArgUnassemble), 0, dbgcCmdUnassemble, "[addr]", "Unassemble 16-bit code." },
481	{ "uv86", 0, 1, &g_aArgUnassemble[0],RT_ELEMENTS(g_aArgUnassemble), 0, dbgcCmdUnassemble, "[addr]", "Unassemble 16-bit code with v8086/real mode addressing." },
482	{ "ucfg", 0, 1, &g_aArgUnassembleCfg[0], RT_ELEMENTS(g_aArgUnassembleCfg), 0, dbgcCmdUnassembleCfg, "[addr]", "Unassemble creating a control flow graph." },
483	{ "ucfgc", 0, 1, &g_aArgUnassembleCfg[0], RT_ELEMENTS(g_aArgUnassembleCfg), 0, dbgcCmdUnassembleCfg, "[addr]", "Unassemble creating a control flow graph with colors." },
484	{ "x", 1, 1, &g_aArgListSyms[0], RT_ELEMENTS(g_aArgListSyms), 0, dbgcCmdListSymbols, "* \| <Module!Symbol>", "Examine symbols." },
485	};
486
487	/** The number of commands in the CodeView/WinDbg emulation. */
488	const uint32_t g_cCmdsCodeView = RT_ELEMENTS(g_aCmdsCodeView);
489
490
491	/**
492	* Selectable debug event descriptors.
493	*
494	* @remarks Sorted by DBGCSXEVT::enmType value.
495	*/
496	const DBGCSXEVT g_aDbgcSxEvents[] =
497	{
498	{ DBGFEVENT_INTERRUPT_HARDWARE, "hwint", NULL, kDbgcSxEventKind_Interrupt, kDbgcEvtState_Disabled, 0, "Hardware interrupt" },
499	{ DBGFEVENT_INTERRUPT_SOFTWARE, "swint", NULL, kDbgcSxEventKind_Interrupt, kDbgcEvtState_Disabled, 0, "Software interrupt" },
500	{ DBGFEVENT_TRIPLE_FAULT, "triplefault", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Enabled, 0, "Triple fault "},
501	{ DBGFEVENT_XCPT_DE, "xcpt_de", "de", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, "#DE (integer divide error)" },
502	{ DBGFEVENT_XCPT_DB, "xcpt_db", "db", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, "#DB (debug)" },
503	{ DBGFEVENT_XCPT_02, "xcpt_02", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
504	{ DBGFEVENT_XCPT_BP, "xcpt_bp", "bp", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, "#BP (breakpoint)" },
505	{ DBGFEVENT_XCPT_OF, "xcpt_of", "of", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, "#OF (overflow (INTO))" },
506	{ DBGFEVENT_XCPT_BR, "xcpt_br", "br", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, "#BR (bound range exceeded)" },
507	{ DBGFEVENT_XCPT_UD, "xcpt_ud", "ud", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, "#UD (undefined opcode)" },
508	{ DBGFEVENT_XCPT_NM, "xcpt_nm", "nm", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, "#NM (FPU not available)" },
509	{ DBGFEVENT_XCPT_DF, "xcpt_df", "df", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, "#DF (double fault)" },
510	{ DBGFEVENT_XCPT_09, "xcpt_09", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, "Coprocessor segment overrun" },
511	{ DBGFEVENT_XCPT_TS, "xcpt_ts", "ts", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, DBGCSXEVT_F_TAKE_ARG, "#TS (task switch)" },
512	{ DBGFEVENT_XCPT_NP, "xcpt_np", "np", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, DBGCSXEVT_F_TAKE_ARG, "#NP (segment not present)" },
513	{ DBGFEVENT_XCPT_SS, "xcpt_ss", "ss", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, DBGCSXEVT_F_TAKE_ARG, "#SS (stack segment fault)" },
514	{ DBGFEVENT_XCPT_GP, "xcpt_gp", "gp", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, DBGCSXEVT_F_TAKE_ARG, "#GP (general protection fault)" },
515	{ DBGFEVENT_XCPT_PF, "xcpt_pf", "pf", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, DBGCSXEVT_F_TAKE_ARG, "#PF (page fault)" },
516	{ DBGFEVENT_XCPT_0f, "xcpt_0f", "xcpt0f", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
517	{ DBGFEVENT_XCPT_MF, "xcpt_mf", "mf", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, "#MF (math fault)" },
518	{ DBGFEVENT_XCPT_AC, "xcpt_ac", "ac", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, "#AC (alignment check)" },
519	{ DBGFEVENT_XCPT_MC, "xcpt_mc", "mc", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, "#MC (machine check)" },
520	{ DBGFEVENT_XCPT_XF, "xcpt_xf", "xf", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, "#XF (SIMD floating-point exception)" },
521	{ DBGFEVENT_XCPT_VE, "xcpt_vd", "ve", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, "#VE (virtualization exception)" },
522	{ DBGFEVENT_XCPT_15, "xcpt_15", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
523	{ DBGFEVENT_XCPT_16, "xcpt_16", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
524	{ DBGFEVENT_XCPT_17, "xcpt_17", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
525	{ DBGFEVENT_XCPT_18, "xcpt_18", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
526	{ DBGFEVENT_XCPT_19, "xcpt_19", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
527	{ DBGFEVENT_XCPT_1a, "xcpt_1a", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
528	{ DBGFEVENT_XCPT_1b, "xcpt_1b", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
529	{ DBGFEVENT_XCPT_1c, "xcpt_1c", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
530	{ DBGFEVENT_XCPT_1d, "xcpt_1d", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
531	{ DBGFEVENT_XCPT_SX, "xcpt_sx", "sx", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, DBGCSXEVT_F_TAKE_ARG, "#SX (security exception)" },
532	{ DBGFEVENT_XCPT_1f, "xcpt_1f", "xcpt1f", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
533	{ DBGFEVENT_INSTR_HALT, "instr_halt", "hlt", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
534	{ DBGFEVENT_INSTR_MWAIT, "instr_mwait", "mwait", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
535	{ DBGFEVENT_INSTR_MONITOR, "instr_monitor", "monitor", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
536	{ DBGFEVENT_INSTR_CPUID, "instr_cpuid", "cpuid", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
537	{ DBGFEVENT_INSTR_INVD, "instr_invd", "invd", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
538	{ DBGFEVENT_INSTR_WBINVD, "instr_wbinvd", "wbinvd", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
539	{ DBGFEVENT_INSTR_INVLPG, "instr_invlpg", "invlpg", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
540	{ DBGFEVENT_INSTR_RDTSC, "instr_rdtsc", "rdtsc", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
541	{ DBGFEVENT_INSTR_RDTSCP, "instr_rdtscp", "rdtscp", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
542	{ DBGFEVENT_INSTR_RDPMC, "instr_rdpmc", "rdpmc", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
543	{ DBGFEVENT_INSTR_RDMSR, "instr_rdmsr", "rdmsr", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
544	{ DBGFEVENT_INSTR_WRMSR, "instr_wrmsr", "wrmsr", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
545	{ DBGFEVENT_INSTR_CRX_READ, "instr_crx_read", "crx_read", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, DBGCSXEVT_F_TAKE_ARG, NULL },
546	{ DBGFEVENT_INSTR_CRX_WRITE, "instr_crx_write", "crx_write",kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, DBGCSXEVT_F_TAKE_ARG, NULL },
547	{ DBGFEVENT_INSTR_DRX_READ, "instr_drx_read", "drx_read", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, DBGCSXEVT_F_TAKE_ARG, NULL },
548	{ DBGFEVENT_INSTR_DRX_WRITE, "instr_drx_write", "drx_write",kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, DBGCSXEVT_F_TAKE_ARG, NULL },
549	{ DBGFEVENT_INSTR_PAUSE, "instr_pause", "pause", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
550	{ DBGFEVENT_INSTR_XSETBV, "instr_xsetbv", "xsetbv", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
551	{ DBGFEVENT_INSTR_SIDT, "instr_sidt", "sidt", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
552	{ DBGFEVENT_INSTR_LIDT, "instr_lidt", "lidt", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
553	{ DBGFEVENT_INSTR_SGDT, "instr_sgdt", "sgdt", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
554	{ DBGFEVENT_INSTR_LGDT, "instr_lgdt", "lgdt", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
555	{ DBGFEVENT_INSTR_SLDT, "instr_sldt", "sldt", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
556	{ DBGFEVENT_INSTR_LLDT, "instr_lldt", "lldt", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
557	{ DBGFEVENT_INSTR_STR, "instr_str", "str", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
558	{ DBGFEVENT_INSTR_LTR, "instr_ltr", "ltr", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
559	{ DBGFEVENT_INSTR_GETSEC, "instr_getsec", "getsec", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
560	{ DBGFEVENT_INSTR_RSM, "instr_rsm", "rsm", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
561	{ DBGFEVENT_INSTR_RDRAND, "instr_rdrand", "rdrand", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
562	{ DBGFEVENT_INSTR_RDSEED, "instr_rdseed", "rdseed", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
563	{ DBGFEVENT_INSTR_XSAVES, "instr_xsaves", "xsaves", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
564	{ DBGFEVENT_INSTR_XRSTORS, "instr_xrstors", "xrstors", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
565	{ DBGFEVENT_INSTR_VMM_CALL, "instr_vmm_call", "vmm_call", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
566	{ DBGFEVENT_INSTR_VMX_VMCLEAR, "instr_vmx_vmclear", "vmclear", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
567	{ DBGFEVENT_INSTR_VMX_VMLAUNCH, "instr_vmx_vmlaunch", "vmlaunch", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
568	{ DBGFEVENT_INSTR_VMX_VMPTRLD, "instr_vmx_vmptrld", "vmptrld", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
569	{ DBGFEVENT_INSTR_VMX_VMPTRST, "instr_vmx_vmptrst", "vmptrst", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
570	{ DBGFEVENT_INSTR_VMX_VMREAD, "instr_vmx_vmread", "vmread", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
571	{ DBGFEVENT_INSTR_VMX_VMRESUME, "instr_vmx_vmresume", "vmresume", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
572	{ DBGFEVENT_INSTR_VMX_VMWRITE, "instr_vmx_vmwrite", "vmwrite", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
573	{ DBGFEVENT_INSTR_VMX_VMXOFF, "instr_vmx_vmxoff", "vmxoff", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
574	{ DBGFEVENT_INSTR_VMX_VMXON, "instr_vmx_vmxon", "vmxon", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
575	{ DBGFEVENT_INSTR_VMX_VMFUNC, "instr_vmx_vmfunc", "vmfunc", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
576	{ DBGFEVENT_INSTR_VMX_INVEPT, "instr_vmx_invept", "invept", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
577	{ DBGFEVENT_INSTR_VMX_INVVPID, "instr_vmx_invvpid", "invvpid", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
578	{ DBGFEVENT_INSTR_VMX_INVPCID, "instr_vmx_invpcid", "invpcid", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
579	{ DBGFEVENT_INSTR_SVM_VMRUN, "instr_svm_vmrun", "vmrun", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
580	{ DBGFEVENT_INSTR_SVM_VMLOAD, "instr_svm_vmload", "vmload", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
581	{ DBGFEVENT_INSTR_SVM_VMSAVE, "instr_svm_vmsave", "vmsave", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
582	{ DBGFEVENT_INSTR_SVM_STGI, "instr_svm_stgi", "stgi", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
583	{ DBGFEVENT_INSTR_SVM_CLGI, "instr_svm_clgi", "clgi", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
584	{ DBGFEVENT_EXIT_TASK_SWITCH, "exit_task_switch", "task_switch", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
585	{ DBGFEVENT_EXIT_HALT, "exit_halt", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
586	{ DBGFEVENT_EXIT_MWAIT, "exit_mwait", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
587	{ DBGFEVENT_EXIT_MONITOR, "exit_monitor", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
588	{ DBGFEVENT_EXIT_CPUID, "exit_cpuid", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
589	{ DBGFEVENT_EXIT_INVD, "exit_invd", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
590	{ DBGFEVENT_EXIT_WBINVD, "exit_wbinvd", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
591	{ DBGFEVENT_EXIT_INVLPG, "exit_invlpg", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
592	{ DBGFEVENT_EXIT_RDTSC, "exit_rdtsc", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
593	{ DBGFEVENT_EXIT_RDTSCP, "exit_rdtscp", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
594	{ DBGFEVENT_EXIT_RDPMC, "exit_rdpmc", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
595	{ DBGFEVENT_EXIT_RDMSR, "exit_rdmsr", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
596	{ DBGFEVENT_EXIT_WRMSR, "exit_wrmsr", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
597	{ DBGFEVENT_EXIT_CRX_READ, "exit_crx_read", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
598	{ DBGFEVENT_EXIT_CRX_WRITE, "exit_crx_write", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
599	{ DBGFEVENT_EXIT_DRX_READ, "exit_drx_read", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
600	{ DBGFEVENT_EXIT_DRX_WRITE, "exit_drx_write", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
601	{ DBGFEVENT_EXIT_PAUSE, "exit_pause", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
602	{ DBGFEVENT_EXIT_XSETBV, "exit_xsetbv", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
603	{ DBGFEVENT_EXIT_SIDT, "exit_sidt", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
604	{ DBGFEVENT_EXIT_LIDT, "exit_lidt", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
605	{ DBGFEVENT_EXIT_SGDT, "exit_sgdt", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
606	{ DBGFEVENT_EXIT_LGDT, "exit_lgdt", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
607	{ DBGFEVENT_EXIT_SLDT, "exit_sldt", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
608	{ DBGFEVENT_EXIT_LLDT, "exit_lldt", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
609	{ DBGFEVENT_EXIT_STR, "exit_str", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
610	{ DBGFEVENT_EXIT_LTR, "exit_ltr", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
611	{ DBGFEVENT_EXIT_GETSEC, "exit_getsec", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
612	{ DBGFEVENT_EXIT_RSM, "exit_rsm", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
613	{ DBGFEVENT_EXIT_RDRAND, "exit_rdrand", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
614	{ DBGFEVENT_EXIT_RDSEED, "exit_rdseed", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
615	{ DBGFEVENT_EXIT_XSAVES, "exit_xsaves", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
616	{ DBGFEVENT_EXIT_XRSTORS, "exit_xrstors", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
617	{ DBGFEVENT_EXIT_VMM_CALL, "exit_vmm_call", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
618	{ DBGFEVENT_EXIT_VMX_VMCLEAR, "exit_vmx_vmclear", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
619	{ DBGFEVENT_EXIT_VMX_VMLAUNCH, "exit_vmx_vmlaunch", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
620	{ DBGFEVENT_EXIT_VMX_VMPTRLD, "exit_vmx_vmptrld", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
621	{ DBGFEVENT_EXIT_VMX_VMPTRST, "exit_vmx_vmptrst", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
622	{ DBGFEVENT_EXIT_VMX_VMREAD, "exit_vmx_vmread", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
623	{ DBGFEVENT_EXIT_VMX_VMRESUME, "exit_vmx_vmresume", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
624	{ DBGFEVENT_EXIT_VMX_VMWRITE, "exit_vmx_vmwrite", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
625	{ DBGFEVENT_EXIT_VMX_VMXOFF, "exit_vmx_vmxoff", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
626	{ DBGFEVENT_EXIT_VMX_VMXON, "exit_vmx_vmxon", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
627	{ DBGFEVENT_EXIT_VMX_VMFUNC, "exit_vmx_vmfunc", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
628	{ DBGFEVENT_EXIT_VMX_INVEPT, "exit_vmx_invept", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
629	{ DBGFEVENT_EXIT_VMX_INVVPID, "exit_vmx_invvpid", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
630	{ DBGFEVENT_EXIT_VMX_INVPCID, "exit_vmx_invpcid", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
631	{ DBGFEVENT_EXIT_VMX_EPT_VIOLATION, "exit_vmx_ept_violation", "eptvio", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
632	{ DBGFEVENT_EXIT_VMX_EPT_MISCONFIG, "exit_vmx_ept_misconfig", "eptmis", kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
633	{ DBGFEVENT_EXIT_VMX_VAPIC_ACCESS, "exit_vmx_vapic_access", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
634	{ DBGFEVENT_EXIT_VMX_VAPIC_WRITE, "exit_vmx_vapic_write", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
635	{ DBGFEVENT_EXIT_SVM_VMRUN, "exit_svm_vmrun", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
636	{ DBGFEVENT_EXIT_SVM_VMLOAD, "exit_svm_vmload", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
637	{ DBGFEVENT_EXIT_SVM_VMSAVE, "exit_svm_vmsave", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
638	{ DBGFEVENT_EXIT_SVM_STGI, "exit_svm_stgi", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
639	{ DBGFEVENT_EXIT_SVM_CLGI, "exit_svm_clgi", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
640	{ DBGFEVENT_IOPORT_UNASSIGNED, "pio_unassigned", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
641	{ DBGFEVENT_IOPORT_UNUSED, "pio_unused", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
642	{ DBGFEVENT_MEMORY_UNASSIGNED, "mmio_unassigned", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
643	{ DBGFEVENT_MEMORY_ROM_WRITE, "rom_write", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, 0, NULL },
644	{ DBGFEVENT_BSOD_MSR, "bsod_msr", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, DBGCSXEVT_F_BUGCHECK, NULL },
645	{ DBGFEVENT_BSOD_EFI, "bsod_efi", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, DBGCSXEVT_F_BUGCHECK, NULL },
646	{ DBGFEVENT_BSOD_VMMDEV, "bsod_vmmdev", NULL, kDbgcSxEventKind_Plain, kDbgcEvtState_Disabled, DBGCSXEVT_F_BUGCHECK, NULL },
647	};
648	/** Number of entries in g_aDbgcSxEvents. */
649	const uint32_t g_cDbgcSxEvents = RT_ELEMENTS(g_aDbgcSxEvents);
650
651
652
653	/**
654	* @callback_method_impl{FNDBGCCMD, The 'g' command.}
655	*/
656	static DECLCALLBACK(int) dbgcCmdGo(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
657	{
658	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
659
660	/*
661	* Parse arguments.
662	*/
663	VMCPUID idCpu = VMCPUID_ALL;
664	if (cArgs == 1)
665	{
666	VMCPUID cCpus = DBGFR3CpuGetCount(pUVM);
667	if (paArgs[0].u.u64Number >= cCpus)
668	return DBGCCmdHlpFail(pCmdHlp, pCmd, "idCpu %RU64 is out of range! Highest valid ID is %u.\n",
669	paArgs[0].u.u64Number, cCpus - 1);
670	idCpu = (VMCPUID)paArgs[0].u.u64Number;
671	}
672	else
673	Assert(cArgs == 0);
674
675	/*
676	* Try resume the VM or CPU.
677	*/
678	int rc = DBGFR3Resume(pUVM, idCpu);
679	if (RT_SUCCESS(rc))
680	{
681	Assert(rc == VINF_SUCCESS \|\| rc == VWRN_DBGF_ALREADY_RUNNING);
682	if (rc != VWRN_DBGF_ALREADY_RUNNING)
683	return VINF_SUCCESS;
684	if (idCpu == VMCPUID_ALL)
685	return DBGCCmdHlpFail(pCmdHlp, pCmd, "The VM is already running");
686	return DBGCCmdHlpFail(pCmdHlp, pCmd, "CPU %u is already running", idCpu);
687	}
688	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGFR3Resume");
689	}
690
691
692	/**
693	* @callback_method_impl{FNDBGCCMD, The 'gu' command.}
694	*/
695	static DECLCALLBACK(int) dbgcCmdGoUp(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
696	{
697	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
698	RT_NOREF(pCmd, paArgs, cArgs);
699
700	/* The simple way out. */
701	PDBGFADDRESS pStackPop = NULL; /** @todo try set up some stack limitations */
702	RTGCPTR cbStackPop = 0;
703	int rc = DBGFR3StepEx(pUVM, pDbgc->idCpu, DBGF_STEP_F_OVER \| DBGF_STEP_F_STOP_AFTER_RET, NULL, pStackPop, cbStackPop, _512K);
704	if (RT_SUCCESS(rc))
705	pDbgc->fReady = false;
706	else
707	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGFR3StepEx(,,DBGF_STEP_F_OVER \| DBGF_STEP_F_STOP_AFTER_RET,) failed");
708	return rc;
709	}
710
711
712	/**
713	* @callback_method_impl{FNDBGCCMD, The 'ba' command.}
714	*/
715	static DECLCALLBACK(int) dbgcCmdBrkAccess(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
716	{
717	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
718
719	/*
720	* Interpret access type.
721	*/
722	if ( !strchr("xrwi", paArgs[0].u.pszString[0])
723	\|\| paArgs[0].u.pszString[1])
724	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Invalid access type '%s' for '%s'. Valid types are 'e', 'r', 'w' and 'i'",
725	paArgs[0].u.pszString, pCmd->pszCmd);
726	uint8_t fType = 0;
727	switch (paArgs[0].u.pszString[0])
728	{
729	case 'x': fType = X86_DR7_RW_EO; break;
730	case 'r': fType = X86_DR7_RW_RW; break;
731	case 'w': fType = X86_DR7_RW_WO; break;
732	case 'i': fType = X86_DR7_RW_IO; break;
733	}
734
735	/*
736	* Validate size.
737	*/
738	if (fType == X86_DR7_RW_EO && paArgs[1].u.u64Number != 1)
739	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Invalid access size %RX64 for '%s'. 'x' access type requires size 1!",
740	paArgs[1].u.u64Number, pCmd->pszCmd);
741	switch (paArgs[1].u.u64Number)
742	{
743	case 1:
744	case 2:
745	case 4:
746	break;
747	/case 8: - later/
748	default:
749	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Invalid access size %RX64 for '%s'. 1, 2 or 4!",
750	paArgs[1].u.u64Number, pCmd->pszCmd);
751	}
752	uint8_t cb = (uint8_t)paArgs[1].u.u64Number;
753
754	/*
755	* Convert the pointer to a DBGF address.
756	*/
757	DBGFADDRESS Address;
758	int rc = DBGCCmdHlpVarToDbgfAddr(pCmdHlp, &paArgs[2], &Address);
759	if (RT_FAILURE(rc))
760	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGCCmdHlpVarToDbgfAddr(,%DV,)", &paArgs[2]);
761
762	/*
763	* Pick out the optional arguments.
764	*/
765	uint64_t iHitTrigger = 0;
766	uint64_t iHitDisable = UINT64_MAX;
767	const char *pszCmds = NULL;
768	unsigned iArg = 3;
769	if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_NUMBER)
770	{
771	iHitTrigger = paArgs[iArg].u.u64Number;
772	iArg++;
773	if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_NUMBER)
774	{
775	iHitDisable = paArgs[iArg].u.u64Number;
776	iArg++;
777	}
778	}
779	if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_STRING)
780	{
781	pszCmds = paArgs[iArg].u.pszString;
782	iArg++;
783	}
784
785	/*
786	* Try set the breakpoint.
787	*/
788	uint32_t iBp;
789	rc = DBGFR3BpSetReg(pUVM, &Address, iHitTrigger, iHitDisable, fType, cb, &iBp);
790	if (RT_SUCCESS(rc))
791	{
792	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
793	rc = dbgcBpAdd(pDbgc, iBp, pszCmds);
794	if (RT_SUCCESS(rc))
795	return DBGCCmdHlpPrintf(pCmdHlp, "Set access breakpoint %u at %RGv\n", iBp, Address.FlatPtr);
796	if (rc == VERR_DBGC_BP_EXISTS)
797	{
798	rc = dbgcBpUpdate(pDbgc, iBp, pszCmds);
799	if (RT_SUCCESS(rc))
800	return DBGCCmdHlpPrintf(pCmdHlp, "Updated access breakpoint %u at %RGv\n", iBp, Address.FlatPtr);
801	}
802	int rc2 = DBGFR3BpClear(pDbgc->pUVM, iBp);
803	AssertRC(rc2);
804	}
805	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "Failed to set access breakpoint at %RGv", Address.FlatPtr);
806	}
807
808
809	/**
810	* @callback_method_impl{FNDBGCCMD, The 'bc' command.}
811	*/
812	static DECLCALLBACK(int) dbgcCmdBrkClear(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
813	{
814	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
815
816	/*
817	* Enumerate the arguments.
818	*/
819	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
820	int rc = VINF_SUCCESS;
821	for (unsigned iArg = 0; iArg < cArgs && RT_SUCCESS(rc); iArg++)
822	{
823	if (paArgs[iArg].enmType != DBGCVAR_TYPE_STRING)
824	{
825	/* one */
826	uint32_t iBp = (uint32_t)paArgs[iArg].u.u64Number;
827	if (iBp == paArgs[iArg].u.u64Number)
828	{
829	int rc2 = DBGFR3BpClear(pUVM, iBp);
830	if (RT_FAILURE(rc2))
831	rc = DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc2, "DBGFR3BpClear(,%#x)", iBp);
832	if (RT_SUCCESS(rc2) \|\| rc2 == VERR_DBGF_BP_NOT_FOUND)
833	dbgcBpDelete(pDbgc, iBp);
834	}
835	else
836	rc = DBGCCmdHlpFail(pCmdHlp, pCmd, "Breakpoint id %RX64 is too large", paArgs[iArg].u.u64Number);
837	}
838	else if (!strcmp(paArgs[iArg].u.pszString, "all"))
839	{
840	/* all */
841	PDBGCBP pBp = pDbgc->pFirstBp;
842	while (pBp)
843	{
844	uint32_t iBp = pBp->iBp;
845	pBp = pBp->pNext;
846
847	int rc2 = DBGFR3BpClear(pUVM, iBp);
848	if (RT_FAILURE(rc2))
849	rc = DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc2, "DBGFR3BpClear(,%#x)", iBp);
850	if (RT_SUCCESS(rc2) \|\| rc2 == VERR_DBGF_BP_NOT_FOUND)
851	dbgcBpDelete(pDbgc, iBp);
852	}
853	}
854	else
855	rc = DBGCCmdHlpFail(pCmdHlp, pCmd, "Invalid argument '%s'", paArgs[iArg].u.pszString);
856	}
857	return rc;
858	}
859
860
861	/**
862	* @callback_method_impl{FNDBGCCMD, The 'bd' command.}
863	*/
864	static DECLCALLBACK(int) dbgcCmdBrkDisable(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
865	{
866	/*
867	* Enumerate the arguments.
868	*/
869	int rc = VINF_SUCCESS;
870	for (unsigned iArg = 0; iArg < cArgs && RT_SUCCESS(rc); iArg++)
871	{
872	if (paArgs[iArg].enmType != DBGCVAR_TYPE_STRING)
873	{
874	/* one */
875	uint32_t iBp = (uint32_t)paArgs[iArg].u.u64Number;
876	if (iBp == paArgs[iArg].u.u64Number)
877	{
878	rc = DBGFR3BpDisable(pUVM, iBp);
879	if (RT_FAILURE(rc))
880	rc = DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGFR3BpDisable failed for breakpoint %#x", iBp);
881	}
882	else
883	rc = DBGCCmdHlpFail(pCmdHlp, pCmd, "Breakpoint id %RX64 is too large", paArgs[iArg].u.u64Number);
884	}
885	else if (!strcmp(paArgs[iArg].u.pszString, "all"))
886	{
887	/* all */
888	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
889	for (PDBGCBP pBp = pDbgc->pFirstBp; pBp; pBp = pBp->pNext)
890	{
891	int rc2 = DBGFR3BpDisable(pUVM, pBp->iBp);
892	if (RT_FAILURE(rc2))
893	rc = DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc2, "DBGFR3BpDisable failed for breakpoint %#x", pBp->iBp);
894	}
895	}
896	else
897	rc = DBGCCmdHlpFail(pCmdHlp, pCmd, "Invalid argument '%s'", paArgs[iArg].u.pszString);
898	}
899	return rc;
900	}
901
902
903	/**
904	* @callback_method_impl{FNDBGCCMD, The 'be' command.}
905	*/
906	static DECLCALLBACK(int) dbgcCmdBrkEnable(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
907	{
908	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
909
910	/*
911	* Enumerate the arguments.
912	*/
913	int rc = VINF_SUCCESS;
914	for (unsigned iArg = 0; iArg < cArgs && RT_SUCCESS(rc); iArg++)
915	{
916	if (paArgs[iArg].enmType != DBGCVAR_TYPE_STRING)
917	{
918	/* one */
919	uint32_t iBp = (uint32_t)paArgs[iArg].u.u64Number;
920	if (iBp == paArgs[iArg].u.u64Number)
921	{
922	rc = DBGFR3BpEnable(pUVM, iBp);
923	if (RT_FAILURE(rc))
924	rc = DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGFR3BpEnable failed for breakpoint %#x", iBp);
925	}
926	else
927	rc = DBGCCmdHlpFail(pCmdHlp, pCmd, "Breakpoint id %RX64 is too large", paArgs[iArg].u.u64Number);
928	}
929	else if (!strcmp(paArgs[iArg].u.pszString, "all"))
930	{
931	/* all */
932	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
933	for (PDBGCBP pBp = pDbgc->pFirstBp; pBp; pBp = pBp->pNext)
934	{
935	int rc2 = DBGFR3BpEnable(pUVM, pBp->iBp);
936	if (RT_FAILURE(rc2))
937	rc = DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc2, "DBGFR3BpEnable failed for breakpoint %#x", pBp->iBp);
938	}
939	}
940	else
941	rc = DBGCCmdHlpFail(pCmdHlp, pCmd, "Invalid argument '%s'", paArgs[iArg].u.pszString);
942	}
943	return rc;
944	}
945
946
947	/**
948	* Breakpoint enumeration callback function.
949	*
950	* @returns VBox status code. Any failure will stop the enumeration.
951	* @param pUVM The user mode VM handle.
952	* @param pvUser The user argument.
953	* @param hBp The DBGF breakpoint handle.
954	* @param pBp Pointer to the breakpoint information. (readonly)
955	*/
956	static DECLCALLBACK(int) dbgcEnumBreakpointsCallback(PUVM pUVM, void *pvUser, DBGFBP hBp, PCDBGFBPPUB pBp)
957	{
958	PDBGC pDbgc = (PDBGC)pvUser;
959	PDBGCBP pDbgcBp = dbgcBpGet(pDbgc, hBp);
960
961	/*
962	* BP type and size.
963	*/
964	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "%#4x %c ", hBp, DBGF_BP_PUB_IS_ENABLED(pBp->fFlagsAndType) ? 'e' : 'd');
965	bool fHasAddress = false;
966	switch (DBGF_BP_PUB_GET_TYPE(pBp->fFlagsAndType))
967	{
968	case DBGFBPTYPE_INT3:
969	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, " p %RGv", pBp->u.Int3.GCPtr);
970	fHasAddress = true;
971	break;
972	case DBGFBPTYPE_REG:
973	{
974	char chType;
975	switch (pBp->u.Reg.fType)
976	{
977	case X86_DR7_RW_EO: chType = 'x'; break;
978	case X86_DR7_RW_WO: chType = 'w'; break;
979	case X86_DR7_RW_IO: chType = 'i'; break;
980	case X86_DR7_RW_RW: chType = 'r'; break;
981	default: chType = '?'; break;
982
983	}
984	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "%d %c %RGv", pBp->u.Reg.cb, chType, pBp->u.Reg.GCPtr);
985	fHasAddress = true;
986	break;
987	}
988
989	/** @todo realign the list when I/O and MMIO breakpoint command have been added and it's possible to test this code. */
990	case DBGFBPTYPE_PORT_IO:
991	case DBGFBPTYPE_MMIO:
992	{
993	uint32_t fAccess = DBGF_BP_PUB_GET_TYPE(pBp->fFlagsAndType) == DBGFBPTYPE_PORT_IO ? pBp->u.PortIo.fAccess : pBp->u.Mmio.fAccess;
994	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, DBGF_BP_PUB_GET_TYPE(pBp->fFlagsAndType) == DBGFBPTYPE_PORT_IO ? " i" : " m");
995	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, " %c%c%c%c%c%c",
996	fAccess & DBGFBPIOACCESS_READ_MASK ? 'r' : '-',
997	fAccess & DBGFBPIOACCESS_READ_BYTE ? '1' : '-',
998	fAccess & DBGFBPIOACCESS_READ_WORD ? '2' : '-',
999	fAccess & DBGFBPIOACCESS_READ_DWORD ? '4' : '-',
1000	fAccess & DBGFBPIOACCESS_READ_QWORD ? '8' : '-',
1001	fAccess & DBGFBPIOACCESS_READ_OTHER ? '+' : '-');
1002	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, " %c%c%c%c%c%c",
1003	fAccess & DBGFBPIOACCESS_WRITE_MASK ? 'w' : '-',
1004	fAccess & DBGFBPIOACCESS_WRITE_BYTE ? '1' : '-',
1005	fAccess & DBGFBPIOACCESS_WRITE_WORD ? '2' : '-',
1006	fAccess & DBGFBPIOACCESS_WRITE_DWORD ? '4' : '-',
1007	fAccess & DBGFBPIOACCESS_WRITE_QWORD ? '8' : '-',
1008	fAccess & DBGFBPIOACCESS_WRITE_OTHER ? '+' : '-');
1009	if (DBGF_BP_PUB_GET_TYPE(pBp->fFlagsAndType) == DBGFBPTYPE_PORT_IO)
1010	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, " %04x-%04x",
1011	pBp->u.PortIo.uPort, pBp->u.PortIo.uPort + pBp->u.PortIo.cPorts - 1);
1012	else
1013	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "%RGp LB %03x", pBp->u.Mmio.PhysAddr, pBp->u.Mmio.cb);
1014	break;
1015	}
1016
1017	default:
1018	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, " unknown type %d!!", DBGF_BP_PUB_GET_TYPE(pBp->fFlagsAndType));
1019	AssertFailed();
1020	break;
1021
1022	}
1023	if (pBp->iHitDisable == ~(uint64_t)0)
1024	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, " %04RX64 (%04RX64 to ~0) ", pBp->cHits, pBp->iHitTrigger);
1025	else
1026	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, " %04RX64 (%04RX64 to %04RX64)", pBp->cHits, pBp->iHitTrigger, pBp->iHitDisable);
1027
1028	/*
1029	* Try resolve the address if it has one.
1030	*/
1031	if (fHasAddress)
1032	{
1033	RTDBGSYMBOL Sym;
1034	RTINTPTR off;
1035	DBGFADDRESS Addr;
1036	int rc = DBGFR3AsSymbolByAddr(pUVM, pDbgc->hDbgAs, DBGFR3AddrFromFlat(pDbgc->pUVM, &Addr, pBp->u.GCPtr),
1037	RTDBGSYMADDR_FLAGS_LESS_OR_EQUAL \| RTDBGSYMADDR_FLAGS_SKIP_ABS_IN_DEFERRED,
1038	&off, &Sym, NULL);
1039	if (RT_SUCCESS(rc))
1040	{
1041	if (!off)
1042	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "%s", Sym.szName);
1043	else if (off > 0)
1044	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "%s+%RGv", Sym.szName, off);
1045	else
1046	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "%s-%RGv", Sym.szName, -off);
1047	}
1048	}
1049
1050	/*
1051	* The commands.
1052	*/
1053	if (pDbgcBp)
1054	{
1055	if (pDbgcBp->cchCmd)
1056	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "\n cmds: '%s'\n", pDbgcBp->szCmd);
1057	else
1058	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "\n");
1059	}
1060	else
1061	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, " [unknown bp]\n");
1062
1063	return VINF_SUCCESS;
1064	}
1065
1066
1067	/**
1068	* @callback_method_impl{FNDBGCCMD, The 'bl' command.}
1069	*/
1070	static DECLCALLBACK(int) dbgcCmdBrkList(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
1071	{
1072	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
1073	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, -1, cArgs == 0);
1074	NOREF(paArgs);
1075
1076	/*
1077	* Enumerate the breakpoints.
1078	*/
1079	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1080	int rc = DBGFR3BpEnum(pUVM, dbgcEnumBreakpointsCallback, pDbgc);
1081	if (RT_FAILURE(rc))
1082	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGFR3BpEnum");
1083	return rc;
1084	}
1085
1086
1087	/**
1088	* @callback_method_impl{FNDBGCCMD, The 'bp' command.}
1089	*/
1090	static DECLCALLBACK(int) dbgcCmdBrkSet(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
1091	{
1092	/*
1093	* Convert the pointer to a DBGF address.
1094	*/
1095	DBGFADDRESS Address;
1096	int rc = DBGCCmdHlpVarToDbgfAddr(pCmdHlp, &paArgs[0], &Address);
1097	if (RT_FAILURE(rc))
1098	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGCCmdHlpVarToDbgfAddr(,'%DV',)", &paArgs[0]);
1099
1100	/*
1101	* Pick out the optional arguments.
1102	*/
1103	uint64_t iHitTrigger = 0;
1104	uint64_t iHitDisable = UINT64_MAX;
1105	const char *pszCmds = NULL;
1106	unsigned iArg = 1;
1107	if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_NUMBER)
1108	{
1109	iHitTrigger = paArgs[iArg].u.u64Number;
1110	iArg++;
1111	if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_NUMBER)
1112	{
1113	iHitDisable = paArgs[iArg].u.u64Number;
1114	iArg++;
1115	}
1116	}
1117	if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_STRING)
1118	{
1119	pszCmds = paArgs[iArg].u.pszString;
1120	iArg++;
1121	}
1122
1123	/*
1124	* Try set the breakpoint.
1125	*/
1126	uint32_t iBp;
1127	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1128	rc = DBGFR3BpSetInt3(pUVM, pDbgc->idCpu, &Address, iHitTrigger, iHitDisable, &iBp);
1129	if (RT_SUCCESS(rc))
1130	{
1131	rc = dbgcBpAdd(pDbgc, iBp, pszCmds);
1132	if (RT_SUCCESS(rc))
1133	return DBGCCmdHlpPrintf(pCmdHlp, "Set breakpoint %u at %RGv\n", iBp, Address.FlatPtr);
1134	if (rc == VERR_DBGC_BP_EXISTS)
1135	{
1136	rc = dbgcBpUpdate(pDbgc, iBp, pszCmds);
1137	if (RT_SUCCESS(rc))
1138	return DBGCCmdHlpPrintf(pCmdHlp, "Updated breakpoint %u at %RGv\n", iBp, Address.FlatPtr);
1139	}
1140	int rc2 = DBGFR3BpClear(pDbgc->pUVM, iBp);
1141	AssertRC(rc2);
1142	}
1143	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "Failed to set breakpoint at %RGv", Address.FlatPtr);
1144	}
1145
1146
1147	/**
1148	* @callback_method_impl{FNDBGCCMD, The 'br' command.}
1149	*/
1150	static DECLCALLBACK(int) dbgcCmdBrkREM(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
1151	{
1152	/*
1153	* Convert the pointer to a DBGF address.
1154	*/
1155	DBGFADDRESS Address;
1156	int rc = DBGCCmdHlpVarToDbgfAddr(pCmdHlp, &paArgs[0], &Address);
1157	if (RT_FAILURE(rc))
1158	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGCCmdHlpVarToDbgfAddr(,'%DV',)", &paArgs[0]);
1159
1160	/*
1161	* Pick out the optional arguments.
1162	*/
1163	uint64_t iHitTrigger = 0;
1164	uint64_t iHitDisable = UINT64_MAX;
1165	const char *pszCmds = NULL;
1166	unsigned iArg = 1;
1167	if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_NUMBER)
1168	{
1169	iHitTrigger = paArgs[iArg].u.u64Number;
1170	iArg++;
1171	if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_NUMBER)
1172	{
1173	iHitDisable = paArgs[iArg].u.u64Number;
1174	iArg++;
1175	}
1176	}
1177	if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_STRING)
1178	{
1179	pszCmds = paArgs[iArg].u.pszString;
1180	iArg++;
1181	}
1182
1183	/*
1184	* Try set the breakpoint.
1185	*/
1186	uint32_t iBp;
1187	rc = DBGFR3BpSetREM(pUVM, &Address, iHitTrigger, iHitDisable, &iBp);
1188	if (RT_SUCCESS(rc))
1189	{
1190	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1191	rc = dbgcBpAdd(pDbgc, iBp, pszCmds);
1192	if (RT_SUCCESS(rc))
1193	return DBGCCmdHlpPrintf(pCmdHlp, "Set REM breakpoint %u at %RGv\n", iBp, Address.FlatPtr);
1194	if (rc == VERR_DBGC_BP_EXISTS)
1195	{
1196	rc = dbgcBpUpdate(pDbgc, iBp, pszCmds);
1197	if (RT_SUCCESS(rc))
1198	return DBGCCmdHlpPrintf(pCmdHlp, "Updated REM breakpoint %u at %RGv\n", iBp, Address.FlatPtr);
1199	}
1200	int rc2 = DBGFR3BpClear(pDbgc->pUVM, iBp);
1201	AssertRC(rc2);
1202	}
1203	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "Failed to set REM breakpoint at %RGv", Address.FlatPtr);
1204	}
1205
1206
1207	/**
1208	* Helps the unassmble ('u') command display symbols it starts at and passes.
1209	*
1210	* @param pUVM The user mode VM handle.
1211	* @param pCmdHlp The command helpers for printing via.
1212	* @param hDbgAs The address space to look up addresses in.
1213	* @param pAddress The current address.
1214	* @param pcbCallAgain Where to return the distance to the next check (in
1215	* instruction bytes).
1216	*/
1217	static void dbgcCmdUnassambleHelpListNear(PUVM pUVM, PDBGCCMDHLP pCmdHlp, RTDBGAS hDbgAs, PCDBGFADDRESS pAddress,
1218	PRTUINTPTR pcbCallAgain)
1219	{
1220	RTDBGSYMBOL Symbol;
1221	RTGCINTPTR offDispSym;
1222	int rc = DBGFR3AsSymbolByAddr(pUVM, hDbgAs, pAddress,
1223	RTDBGSYMADDR_FLAGS_LESS_OR_EQUAL \| RTDBGSYMADDR_FLAGS_SKIP_ABS_IN_DEFERRED,
1224	&offDispSym, &Symbol, NULL);
1225	if (RT_FAILURE(rc) \|\| offDispSym > _1G)
1226	rc = DBGFR3AsSymbolByAddr(pUVM, hDbgAs, pAddress,
1227	RTDBGSYMADDR_FLAGS_GREATER_OR_EQUAL \| RTDBGSYMADDR_FLAGS_SKIP_ABS_IN_DEFERRED,
1228	&offDispSym, &Symbol, NULL);
1229	if (RT_SUCCESS(rc) && offDispSym < _1G)
1230	{
1231	if (!offDispSym)
1232	{
1233	DBGCCmdHlpPrintf(pCmdHlp, "%s:\n", Symbol.szName);
1234	*pcbCallAgain = !Symbol.cb ? 64 : Symbol.cb;
1235	}
1236	else if (offDispSym > 0)
1237	{
1238	DBGCCmdHlpPrintf(pCmdHlp, "%s+%#llx:\n", Symbol.szName, (uint64_t)offDispSym);
1239	*pcbCallAgain = !Symbol.cb ? 64 : Symbol.cb > (RTGCUINTPTR)offDispSym ? Symbol.cb - (RTGCUINTPTR)offDispSym : 1;
1240	}
1241	else
1242	{
1243	DBGCCmdHlpPrintf(pCmdHlp, "%s-%#llx:\n", Symbol.szName, (uint64_t)-offDispSym);
1244	*pcbCallAgain = !Symbol.cb ? 64 : (RTGCUINTPTR)-offDispSym + Symbol.cb;
1245	}
1246	}
1247	else
1248	*pcbCallAgain = UINT32_MAX;
1249	}
1250
1251
1252	/**
1253	* @callback_method_impl{FNDBGCCMD, The 'u' command.}
1254	*/
1255	static DECLCALLBACK(int) dbgcCmdUnassemble(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
1256	{
1257	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1258
1259	/*
1260	* Validate input.
1261	*/
1262	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
1263	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, -1, cArgs <= 1);
1264	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, cArgs == 0 \|\| DBGCVAR_ISPOINTER(paArgs[0].enmType));
1265
1266	if (!cArgs && !DBGCVAR_ISPOINTER(pDbgc->DisasmPos.enmType))
1267	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Don't know where to start disassembling");
1268
1269	/*
1270	* Check the desired mode.
1271	*/
1272	unsigned fFlags = DBGF_DISAS_FLAGS_NO_ADDRESS \| DBGF_DISAS_FLAGS_UNPATCHED_BYTES \| DBGF_DISAS_FLAGS_ANNOTATE_PATCHED;
1273	switch (pCmd->pszCmd[1])
1274	{
1275	default: AssertFailed(); RT_FALL_THRU();
1276	case '\0': fFlags \|= DBGF_DISAS_FLAGS_DEFAULT_MODE; break;
1277	case '6': fFlags \|= DBGF_DISAS_FLAGS_64BIT_MODE; break;
1278	case '3': fFlags \|= DBGF_DISAS_FLAGS_32BIT_MODE; break;
1279	case '1': fFlags \|= DBGF_DISAS_FLAGS_16BIT_MODE; break;
1280	case 'v': fFlags \|= DBGF_DISAS_FLAGS_16BIT_REAL_MODE; break;
1281	}
1282
1283	/** @todo should use DBGFADDRESS for everything */
1284
1285	/*
1286	* Find address.
1287	*/
1288	if (!cArgs)
1289	{
1290	if (!DBGCVAR_ISPOINTER(pDbgc->DisasmPos.enmType))
1291	{
1292	/** @todo Batch query CS, RIP, CPU mode and flags. */
1293	PVMCPU pVCpu = VMMR3GetCpuByIdU(pUVM, pDbgc->idCpu);
1294	if (CPUMIsGuestIn64BitCode(pVCpu))
1295	{
1296	pDbgc->DisasmPos.enmType = DBGCVAR_TYPE_GC_FLAT;
1297	pDbgc->SourcePos.u.GCFlat = CPUMGetGuestRIP(pVCpu);
1298	}
1299	else
1300	{
1301	pDbgc->DisasmPos.enmType = DBGCVAR_TYPE_GC_FAR;
1302	pDbgc->SourcePos.u.GCFar.off = CPUMGetGuestEIP(pVCpu);
1303	pDbgc->SourcePos.u.GCFar.sel = CPUMGetGuestCS(pVCpu);
1304	if ( (fFlags & DBGF_DISAS_FLAGS_MODE_MASK) == DBGF_DISAS_FLAGS_DEFAULT_MODE
1305	&& (CPUMGetGuestEFlags(pVCpu) & X86_EFL_VM))
1306	{
1307	fFlags &= ~DBGF_DISAS_FLAGS_MODE_MASK;
1308	fFlags \|= DBGF_DISAS_FLAGS_16BIT_REAL_MODE;
1309	}
1310	}
1311
1312	fFlags \|= DBGF_DISAS_FLAGS_CURRENT_GUEST;
1313	}
1314	else if ((fFlags & DBGF_DISAS_FLAGS_MODE_MASK) == DBGF_DISAS_FLAGS_DEFAULT_MODE && pDbgc->fDisasm)
1315	{
1316	fFlags &= ~DBGF_DISAS_FLAGS_MODE_MASK;
1317	fFlags \|= pDbgc->fDisasm & DBGF_DISAS_FLAGS_MODE_MASK;
1318	}
1319	pDbgc->DisasmPos.enmRangeType = DBGCVAR_RANGE_NONE;
1320	}
1321	else
1322	pDbgc->DisasmPos = paArgs[0];
1323	pDbgc->pLastPos = &pDbgc->DisasmPos;
1324
1325	/*
1326	* Range.
1327	*/
1328	switch (pDbgc->DisasmPos.enmRangeType)
1329	{
1330	case DBGCVAR_RANGE_NONE:
1331	pDbgc->DisasmPos.enmRangeType = DBGCVAR_RANGE_ELEMENTS;
1332	pDbgc->DisasmPos.u64Range = 10;
1333	break;
1334
1335	case DBGCVAR_RANGE_ELEMENTS:
1336	if (pDbgc->DisasmPos.u64Range > 2048)
1337	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Too many lines requested. Max is 2048 lines");
1338	break;
1339
1340	case DBGCVAR_RANGE_BYTES:
1341	if (pDbgc->DisasmPos.u64Range > 65536)
1342	return DBGCCmdHlpFail(pCmdHlp, pCmd, "The requested range is too big. Max is 64KB");
1343	break;
1344
1345	default:
1346	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Unknown range type %d", pDbgc->DisasmPos.enmRangeType);
1347	}
1348
1349	/*
1350	* Convert physical and host addresses to guest addresses.
1351	*/
1352	RTDBGAS hDbgAs = pDbgc->hDbgAs;
1353	int rc;
1354	switch (pDbgc->DisasmPos.enmType)
1355	{
1356	case DBGCVAR_TYPE_GC_FLAT:
1357	case DBGCVAR_TYPE_GC_FAR:
1358	break;
1359	case DBGCVAR_TYPE_GC_PHYS:
1360	hDbgAs = DBGF_AS_PHYS;
1361	RT_FALL_THRU();
1362	case DBGCVAR_TYPE_HC_FLAT:
1363	case DBGCVAR_TYPE_HC_PHYS:
1364	{
1365	DBGCVAR VarTmp;
1366	rc = DBGCCmdHlpEval(pCmdHlp, &VarTmp, "%%(%Dv)", &pDbgc->DisasmPos);
1367	if (RT_FAILURE(rc))
1368	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "failed to evaluate '%%(%Dv)'", &pDbgc->DisasmPos);
1369	pDbgc->DisasmPos = VarTmp;
1370	break;
1371	}
1372	default: AssertFailed(); break;
1373	}
1374
1375	DBGFADDRESS CurAddr;
1376	if ( (fFlags & DBGF_DISAS_FLAGS_MODE_MASK) == DBGF_DISAS_FLAGS_16BIT_REAL_MODE
1377	&& pDbgc->DisasmPos.enmType == DBGCVAR_TYPE_GC_FAR)
1378	DBGFR3AddrFromFlat(pUVM, &CurAddr, ((uint32_t)pDbgc->DisasmPos.u.GCFar.sel << 4) + pDbgc->DisasmPos.u.GCFar.off);
1379	else
1380	{
1381	rc = DBGCCmdHlpVarToDbgfAddr(pCmdHlp, &pDbgc->DisasmPos, &CurAddr);
1382	if (RT_FAILURE(rc))
1383	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGCCmdHlpVarToDbgfAddr failed on '%Dv'", &pDbgc->DisasmPos);
1384	}
1385
1386	pDbgc->fDisasm = fFlags;
1387
1388	/*
1389	* Figure out where we are and display it. Also calculate when we need to
1390	* check for a new symbol if possible.
1391	*/
1392	RTGCUINTPTR cbCheckSymbol;
1393	dbgcCmdUnassambleHelpListNear(pUVM, pCmdHlp, hDbgAs, &CurAddr, &cbCheckSymbol);
1394
1395	/*
1396	* Do the disassembling.
1397	*/
1398	unsigned cTries = 32;
1399	int iRangeLeft = (int)pDbgc->DisasmPos.u64Range;
1400	if (iRangeLeft == 0) /* kludge for 'r'. */
1401	iRangeLeft = -1;
1402	for (;;)
1403	{
1404	/*
1405	* Disassemble the instruction.
1406	*/
1407	char szDis[256];
1408	uint32_t cbInstr = 1;
1409	if (pDbgc->DisasmPos.enmType == DBGCVAR_TYPE_GC_FLAT)
1410	rc = DBGFR3DisasInstrEx(pUVM, pDbgc->idCpu, DBGF_SEL_FLAT, pDbgc->DisasmPos.u.GCFlat, fFlags,
1411	&szDis[0], sizeof(szDis), &cbInstr);
1412	else
1413	rc = DBGFR3DisasInstrEx(pUVM, pDbgc->idCpu, pDbgc->DisasmPos.u.GCFar.sel, pDbgc->DisasmPos.u.GCFar.off, fFlags,
1414	&szDis[0], sizeof(szDis), &cbInstr);
1415	if (RT_SUCCESS(rc))
1416	{
1417	/* print it */
1418	rc = DBGCCmdHlpPrintf(pCmdHlp, "%-16DV %s\n", &pDbgc->DisasmPos, &szDis[0]);
1419	if (RT_FAILURE(rc))
1420	return rc;
1421	}
1422	else
1423	{
1424	/* bitch. */
1425	int rc2 = DBGCCmdHlpPrintf(pCmdHlp, "Failed to disassemble instruction, skipping one byte.\n");
1426	if (RT_FAILURE(rc2))
1427	return rc2;
1428	if (cTries-- > 0)
1429	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "Too many disassembly failures. Giving up");
1430	cbInstr = 1;
1431	}
1432
1433	/* advance */
1434	if (iRangeLeft < 0) /* 'r' */
1435	break;
1436	if (pDbgc->DisasmPos.enmRangeType == DBGCVAR_RANGE_ELEMENTS)
1437	iRangeLeft--;
1438	else
1439	iRangeLeft -= cbInstr;
1440	rc = DBGCCmdHlpEval(pCmdHlp, &pDbgc->DisasmPos, "(%Dv) + %x", &pDbgc->DisasmPos, cbInstr);
1441	if (RT_FAILURE(rc))
1442	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGCCmdHlpEval(,,'(%Dv) + %x')", &pDbgc->DisasmPos, cbInstr);
1443	if (iRangeLeft <= 0)
1444	break;
1445	fFlags &= ~DBGF_DISAS_FLAGS_CURRENT_GUEST;
1446
1447	/* Print next symbol? */
1448	if (cbCheckSymbol <= cbInstr)
1449	{
1450	if ( (fFlags & DBGF_DISAS_FLAGS_MODE_MASK) == DBGF_DISAS_FLAGS_16BIT_REAL_MODE
1451	&& pDbgc->DisasmPos.enmType == DBGCVAR_TYPE_GC_FAR)
1452	DBGFR3AddrFromFlat(pUVM, &CurAddr, ((uint32_t)pDbgc->DisasmPos.u.GCFar.sel << 4) + pDbgc->DisasmPos.u.GCFar.off);
1453	else
1454	rc = DBGCCmdHlpVarToDbgfAddr(pCmdHlp, &pDbgc->DisasmPos, &CurAddr);
1455	if (RT_SUCCESS(rc))
1456	dbgcCmdUnassambleHelpListNear(pUVM, pCmdHlp, hDbgAs, &CurAddr, &cbCheckSymbol);
1457	else
1458	cbCheckSymbol = UINT32_MAX;
1459	}
1460	else
1461	cbCheckSymbol -= cbInstr;
1462	}
1463
1464	NOREF(pCmd);
1465	return VINF_SUCCESS;
1466	}
1467
1468
1469	/**
1470	* @callback_method_impl{FNDGCSCREENBLIT}
1471	*/
1472	static DECLCALLBACK(int) dbgcCmdUnassembleCfgBlit(const char psz, void pvUser)
1473	{
1474	PDBGCCMDHLP pCmdHlp = (PDBGCCMDHLP)pvUser;
1475	return DBGCCmdHlpPrintf(pCmdHlp, "%s", psz);
1476	}
1477
1478
1479	/**
1480	* Checks whether both addresses are equal.
1481	*
1482	* @returns true if both addresses point to the same location, false otherwise.
1483	* @param pAddr1 First address.
1484	* @param pAddr2 Second address.
1485	*/
1486	static bool dbgcCmdUnassembleCfgAddrEqual(PDBGFADDRESS pAddr1, PDBGFADDRESS pAddr2)
1487	{
1488	return pAddr1->Sel == pAddr2->Sel
1489	&& pAddr1->off == pAddr2->off;
1490	}
1491
1492
1493	/**
1494	* Checks whether the first given address is lower than the second one.
1495	*
1496	* @returns true if both addresses point to the same location, false otherwise.
1497	* @param pAddr1 First address.
1498	* @param pAddr2 Second address.
1499	*/
1500	static bool dbgcCmdUnassembleCfgAddrLower(PDBGFADDRESS pAddr1, PDBGFADDRESS pAddr2)
1501	{
1502	return pAddr1->Sel == pAddr2->Sel
1503	&& pAddr1->off < pAddr2->off;
1504	}
1505
1506
1507	/**
1508	* Calculates the size required for the given basic block including the
1509	* border and spacing on the edges.
1510	*
1511	* @returns nothing.
1512	* @param hFlowBb The basic block handle.
1513	* @param pDumpBb The dumper state to fill in for the basic block.
1514	*/
1515	static void dbgcCmdUnassembleCfgDumpCalcBbSize(DBGFFLOWBB hFlowBb, PDBGCFLOWBBDUMP pDumpBb)
1516	{
1517	uint32_t fFlags = DBGFR3FlowBbGetFlags(hFlowBb);
1518	uint32_t cInstr = DBGFR3FlowBbGetInstrCount(hFlowBb);
1519
1520	pDumpBb->hFlowBb = hFlowBb;
1521	pDumpBb->cchHeight = cInstr + 4; /* Include spacing and border top and bottom. */
1522	pDumpBb->cchWidth = 0;
1523	DBGFR3FlowBbGetStartAddress(hFlowBb, &pDumpBb->AddrStart);
1524
1525	DBGFFLOWBBENDTYPE enmType = DBGFR3FlowBbGetType(hFlowBb);
1526	if ( enmType == DBGFFLOWBBENDTYPE_COND
1527	\|\| enmType == DBGFFLOWBBENDTYPE_UNCOND_JMP
1528	\|\| enmType == DBGFFLOWBBENDTYPE_UNCOND_INDIRECT_JMP)
1529	DBGFR3FlowBbGetBranchAddress(hFlowBb, &pDumpBb->AddrTarget);
1530
1531	if (fFlags & DBGF_FLOW_BB_F_INCOMPLETE_ERR)
1532	{
1533	const char *pszErr = NULL;
1534	DBGFR3FlowBbQueryError(hFlowBb, &pszErr);
1535	if (pszErr)
1536	{
1537	pDumpBb->cchHeight++;
1538	pDumpBb->cchWidth = RT_MAX(pDumpBb->cchWidth, (uint32_t)strlen(pszErr));
1539	}
1540	}
1541	for (unsigned i = 0; i < cInstr; i++)
1542	{
1543	const char *pszInstr = NULL;
1544	int rc = DBGFR3FlowBbQueryInstr(hFlowBb, i, NULL, NULL, &pszInstr);
1545	AssertRC(rc);
1546	pDumpBb->cchWidth = RT_MAX(pDumpBb->cchWidth, (uint32_t)strlen(pszInstr));
1547	}
1548	pDumpBb->cchWidth += 4; /* Include spacing and border left and right. */
1549	}
1550
1551
1552	/**
1553	* Dumps a top or bottom boundary line.
1554	*
1555	* @returns nothing.
1556	* @param hScreen The screen to draw to.
1557	* @param uStartX Where to start drawing the boundary.
1558	* @param uStartY Y coordinate.
1559	* @param cchWidth Width of the boundary.
1560	* @param enmColor The color to use for drawing.
1561	*/
1562	static void dbgcCmdUnassembleCfgDumpBbBoundary(DBGCSCREEN hScreen, uint32_t uStartX, uint32_t uStartY, uint32_t cchWidth,
1563	DBGCSCREENCOLOR enmColor)
1564	{
1565	dbgcScreenAsciiDrawCharacter(hScreen, uStartX, uStartY, '+', enmColor);
1566	dbgcScreenAsciiDrawLineHorizontal(hScreen, uStartX + 1, uStartX + 1 + cchWidth - 2,
1567	uStartY, '-', enmColor);
1568	dbgcScreenAsciiDrawCharacter(hScreen, uStartX + cchWidth - 1, uStartY, '+', enmColor);
1569	}
1570
1571
1572	/**
1573	* Dumps a spacing line between the top or bottom boundary and the actual disassembly.
1574	*
1575	* @returns nothing.
1576	* @param hScreen The screen to draw to.
1577	* @param uStartX Where to start drawing the spacing.
1578	* @param uStartY Y coordinate.
1579	* @param cchWidth Width of the spacing.
1580	* @param enmColor The color to use for drawing.
1581	*/
1582	static void dbgcCmdUnassembleCfgDumpBbSpacing(DBGCSCREEN hScreen, uint32_t uStartX, uint32_t uStartY, uint32_t cchWidth,
1583	DBGCSCREENCOLOR enmColor)
1584	{
1585	dbgcScreenAsciiDrawCharacter(hScreen, uStartX, uStartY, '\|', enmColor);
1586	dbgcScreenAsciiDrawLineHorizontal(hScreen, uStartX + 1, uStartX + 1 + cchWidth - 2,
1587	uStartY, ' ', enmColor);
1588	dbgcScreenAsciiDrawCharacter(hScreen, uStartX + cchWidth - 1, uStartY, '\|', enmColor);
1589	}
1590
1591
1592	/**
1593	* Writes a given text to the screen.
1594	*
1595	* @returns nothing.
1596	* @param hScreen The screen to draw to.
1597	* @param uStartX Where to start drawing the line.
1598	* @param uStartY Y coordinate.
1599	* @param cchWidth Maximum width of the text.
1600	* @param pszText The text to write.
1601	* @param enmTextColor The color to use for drawing the text.
1602	* @param enmBorderColor The color to use for drawing the border.
1603	*/
1604	static void dbgcCmdUnassembleCfgDumpBbText(DBGCSCREEN hScreen, uint32_t uStartX, uint32_t uStartY,
1605	uint32_t cchWidth, const char *pszText,
1606	DBGCSCREENCOLOR enmTextColor, DBGCSCREENCOLOR enmBorderColor)
1607	{
1608	dbgcScreenAsciiDrawCharacter(hScreen, uStartX, uStartY, '\|', enmBorderColor);
1609	dbgcScreenAsciiDrawCharacter(hScreen, uStartX + 1, uStartY, ' ', enmTextColor);
1610	dbgcScreenAsciiDrawString(hScreen, uStartX + 2, uStartY, pszText, enmTextColor);
1611	dbgcScreenAsciiDrawCharacter(hScreen, uStartX + cchWidth - 1, uStartY, '\|', enmBorderColor);
1612	}
1613
1614
1615	/**
1616	* Dumps one basic block using the dumper callback.
1617	*
1618	* @returns nothing.
1619	* @param pDumpBb The basic block dump state to dump.
1620	* @param hScreen The screen to draw to.
1621	*/
1622	static void dbgcCmdUnassembleCfgDumpBb(PDBGCFLOWBBDUMP pDumpBb, DBGCSCREEN hScreen)
1623	{
1624	uint32_t uStartY = pDumpBb->uStartY;
1625	bool fError = RT_BOOL(DBGFR3FlowBbGetFlags(pDumpBb->hFlowBb) & DBGF_FLOW_BB_F_INCOMPLETE_ERR);
1626	DBGCSCREENCOLOR enmColor = fError ? DBGCSCREENCOLOR_RED_BRIGHT : DBGCSCREENCOLOR_DEFAULT;
1627
1628	dbgcCmdUnassembleCfgDumpBbBoundary(hScreen, pDumpBb->uStartX, uStartY, pDumpBb->cchWidth, enmColor);
1629	uStartY++;
1630	dbgcCmdUnassembleCfgDumpBbSpacing(hScreen, pDumpBb->uStartX, uStartY, pDumpBb->cchWidth, enmColor);
1631	uStartY++;
1632
1633	uint32_t cInstr = DBGFR3FlowBbGetInstrCount(pDumpBb->hFlowBb);
1634	for (unsigned i = 0; i < cInstr; i++)
1635	{
1636	const char *pszInstr = NULL;
1637	DBGFR3FlowBbQueryInstr(pDumpBb->hFlowBb, i, NULL, NULL, &pszInstr);
1638	dbgcCmdUnassembleCfgDumpBbText(hScreen, pDumpBb->uStartX, uStartY + i,
1639	pDumpBb->cchWidth, pszInstr, DBGCSCREENCOLOR_DEFAULT,
1640	enmColor);
1641	}
1642	uStartY += cInstr;
1643
1644	if (fError)
1645	{
1646	const char *pszErr = NULL;
1647	DBGFR3FlowBbQueryError(pDumpBb->hFlowBb, &pszErr);
1648	if (pszErr)
1649	dbgcCmdUnassembleCfgDumpBbText(hScreen, pDumpBb->uStartX, uStartY,
1650	pDumpBb->cchWidth, pszErr, enmColor,
1651	enmColor);
1652	uStartY++;
1653	}
1654
1655	dbgcCmdUnassembleCfgDumpBbSpacing(hScreen, pDumpBb->uStartX, uStartY, pDumpBb->cchWidth, enmColor);
1656	uStartY++;
1657	dbgcCmdUnassembleCfgDumpBbBoundary(hScreen, pDumpBb->uStartX, uStartY, pDumpBb->cchWidth, enmColor);
1658	uStartY++;
1659	}
1660
1661
1662	/**
1663	* Dumps one branch table using the dumper callback.
1664	*
1665	* @returns nothing.
1666	* @param pDumpBranchTbl The basic block dump state to dump.
1667	* @param hScreen The screen to draw to.
1668	*/
1669	static void dbgcCmdUnassembleCfgDumpBranchTbl(PDBGCFLOWBRANCHTBLDUMP pDumpBranchTbl, DBGCSCREEN hScreen)
1670	{
1671	uint32_t uStartY = pDumpBranchTbl->uStartY;
1672	DBGCSCREENCOLOR enmColor = DBGCSCREENCOLOR_CYAN_BRIGHT;
1673
1674	dbgcCmdUnassembleCfgDumpBbBoundary(hScreen, pDumpBranchTbl->uStartX, uStartY, pDumpBranchTbl->cchWidth, enmColor);
1675	uStartY++;
1676	dbgcCmdUnassembleCfgDumpBbSpacing(hScreen, pDumpBranchTbl->uStartX, uStartY, pDumpBranchTbl->cchWidth, enmColor);
1677	uStartY++;
1678
1679	uint32_t cSlots = DBGFR3FlowBranchTblGetSlots(pDumpBranchTbl->hFlowBranchTbl);
1680	for (unsigned i = 0; i < cSlots; i++)
1681	{
1682	DBGFADDRESS Addr;
1683	char szAddr[128];
1684
1685	RT_ZERO(szAddr);
1686	DBGFR3FlowBranchTblGetAddrAtSlot(pDumpBranchTbl->hFlowBranchTbl, i, &Addr);
1687
1688	if (Addr.Sel == DBGF_SEL_FLAT)
1689	RTStrPrintf(&szAddr[0], sizeof(szAddr), "%RGv", Addr.FlatPtr);
1690	else
1691	RTStrPrintf(&szAddr[0], sizeof(szAddr), "%04x:%RGv", Addr.Sel, Addr.off);
1692
1693	dbgcCmdUnassembleCfgDumpBbText(hScreen, pDumpBranchTbl->uStartX, uStartY + i,
1694	pDumpBranchTbl->cchWidth, &szAddr[0], DBGCSCREENCOLOR_DEFAULT,
1695	enmColor);
1696	}
1697	uStartY += cSlots;
1698
1699	dbgcCmdUnassembleCfgDumpBbSpacing(hScreen, pDumpBranchTbl->uStartX, uStartY, pDumpBranchTbl->cchWidth, enmColor);
1700	uStartY++;
1701	dbgcCmdUnassembleCfgDumpBbBoundary(hScreen, pDumpBranchTbl->uStartX, uStartY, pDumpBranchTbl->cchWidth, enmColor);
1702	uStartY++;
1703	}
1704
1705
1706	/**
1707	* Fills in the dump states for the basic blocks and branch tables.
1708	*
1709	* @returns VBox status code.
1710	* @param hFlowIt The control flow graph iterator handle.
1711	* @param hFlowBranchTblIt The control flow graph branch table iterator handle.
1712	* @param paDumpBb The array of basic block dump states.
1713	* @param paDumpBranchTbl The array of branch table dump states.
1714	* @param cBbs Number of basic blocks.
1715	* @param cBranchTbls Number of branch tables.
1716	*/
1717	static int dbgcCmdUnassembleCfgDumpCalcDimensions(DBGFFLOWIT hFlowIt, DBGFFLOWBRANCHTBLIT hFlowBranchTblIt,
1718	PDBGCFLOWBBDUMP paDumpBb, PDBGCFLOWBRANCHTBLDUMP paDumpBranchTbl,
1719	uint32_t cBbs, uint32_t cBranchTbls)
1720	{
1721	RT_NOREF2(cBbs, cBranchTbls);
1722
1723	/* Calculate the sizes of each basic block first. */
1724	DBGFFLOWBB hFlowBb = DBGFR3FlowItNext(hFlowIt);
1725	uint32_t idx = 0;
1726	while (hFlowBb)
1727	{
1728	dbgcCmdUnassembleCfgDumpCalcBbSize(hFlowBb, &paDumpBb[idx]);
1729	idx++;
1730	hFlowBb = DBGFR3FlowItNext(hFlowIt);
1731	}
1732
1733	if (paDumpBranchTbl)
1734	{
1735	idx = 0;
1736	DBGFFLOWBRANCHTBL hFlowBranchTbl = DBGFR3FlowBranchTblItNext(hFlowBranchTblIt);
1737	while (hFlowBranchTbl)
1738	{
1739	paDumpBranchTbl[idx].hFlowBranchTbl = hFlowBranchTbl;
1740	paDumpBranchTbl[idx].cchHeight = DBGFR3FlowBranchTblGetSlots(hFlowBranchTbl) + 4; /* Spacing and border. */
1741	paDumpBranchTbl[idx].cchWidth = 25 + 4; /* Spacing and border. */
1742	idx++;
1743	hFlowBranchTbl = DBGFR3FlowBranchTblItNext(hFlowBranchTblIt);
1744	}
1745	}
1746
1747	return VINF_SUCCESS;
1748	}
1749
1750	/**
1751	* Dumps the given control flow graph to the output.
1752	*
1753	* @returns VBox status code.
1754	* @param hCfg The control flow graph handle.
1755	* @param fUseColor Flag whether the output should be colorized.
1756	* @param pCmdHlp The command helper callback table.
1757	*/
1758	static int dbgcCmdUnassembleCfgDump(DBGFFLOW hCfg, bool fUseColor, PDBGCCMDHLP pCmdHlp)
1759	{
1760	int rc = VINF_SUCCESS;
1761	DBGFFLOWIT hCfgIt = NULL;
1762	DBGFFLOWBRANCHTBLIT hFlowBranchTblIt = NULL;
1763	uint32_t cBbs = DBGFR3FlowGetBbCount(hCfg);
1764	uint32_t cBranchTbls = DBGFR3FlowGetBranchTblCount(hCfg);
1765	PDBGCFLOWBBDUMP paDumpBb = (PDBGCFLOWBBDUMP)RTMemTmpAllocZ(cBbs * sizeof(DBGCFLOWBBDUMP));
1766	PDBGCFLOWBRANCHTBLDUMP paDumpBranchTbl = NULL;
1767
1768	if (cBranchTbls)
1769	paDumpBranchTbl = (PDBGCFLOWBRANCHTBLDUMP)RTMemAllocZ(cBranchTbls * sizeof(DBGCFLOWBRANCHTBLDUMP));
1770
1771	if (RT_UNLIKELY(!paDumpBb \|\| (!paDumpBranchTbl && cBranchTbls > 0)))
1772	rc = VERR_NO_MEMORY;
1773	if (RT_SUCCESS(rc))
1774	rc = DBGFR3FlowItCreate(hCfg, DBGFFLOWITORDER_BY_ADDR_LOWEST_FIRST, &hCfgIt);
1775	if (RT_SUCCESS(rc) && cBranchTbls > 0)
1776	rc = DBGFR3FlowBranchTblItCreate(hCfg, DBGFFLOWITORDER_BY_ADDR_LOWEST_FIRST, &hFlowBranchTblIt);
1777
1778	if (RT_SUCCESS(rc))
1779	{
1780	rc = dbgcCmdUnassembleCfgDumpCalcDimensions(hCfgIt, hFlowBranchTblIt, paDumpBb, paDumpBranchTbl,
1781	cBbs, cBranchTbls);
1782
1783	/* Calculate the ASCII screen dimensions and create one. */
1784	uint32_t cchWidth = 0;
1785	uint32_t cchLeftExtra = 5;
1786	uint32_t cchRightExtra = 5;
1787	uint32_t cchHeight = 0;
1788	for (unsigned i = 0; i < cBbs; i++)
1789	{
1790	PDBGCFLOWBBDUMP pDumpBb = &paDumpBb[i];
1791	cchWidth = RT_MAX(cchWidth, pDumpBb->cchWidth);
1792	cchHeight += pDumpBb->cchHeight;
1793
1794	/* Incomplete blocks don't have a successor. */
1795	if (DBGFR3FlowBbGetFlags(pDumpBb->hFlowBb) & DBGF_FLOW_BB_F_INCOMPLETE_ERR)
1796	continue;
1797
1798	switch (DBGFR3FlowBbGetType(pDumpBb->hFlowBb))
1799	{
1800	case DBGFFLOWBBENDTYPE_EXIT:
1801	case DBGFFLOWBBENDTYPE_LAST_DISASSEMBLED:
1802	break;
1803	case DBGFFLOWBBENDTYPE_UNCOND_JMP:
1804	if ( dbgcCmdUnassembleCfgAddrLower(&pDumpBb->AddrTarget, &pDumpBb->AddrStart)
1805	\|\| dbgcCmdUnassembleCfgAddrEqual(&pDumpBb->AddrTarget, &pDumpBb->AddrStart))
1806	cchLeftExtra++;
1807	else
1808	cchRightExtra++;
1809	break;
1810	case DBGFFLOWBBENDTYPE_UNCOND:
1811	cchHeight += 2; /* For the arrow down to the next basic block. */
1812	break;
1813	case DBGFFLOWBBENDTYPE_COND:
1814	cchHeight += 2; /* For the arrow down to the next basic block. */
1815	if ( dbgcCmdUnassembleCfgAddrLower(&pDumpBb->AddrTarget, &pDumpBb->AddrStart)
1816	\|\| dbgcCmdUnassembleCfgAddrEqual(&pDumpBb->AddrTarget, &pDumpBb->AddrStart))
1817	cchLeftExtra++;
1818	else
1819	cchRightExtra++;
1820	break;
1821	case DBGFFLOWBBENDTYPE_UNCOND_INDIRECT_JMP:
1822	default:
1823	AssertFailed();
1824	}
1825	}
1826
1827	for (unsigned i = 0; i < cBranchTbls; i++)
1828	{
1829	PDBGCFLOWBRANCHTBLDUMP pDumpBranchTbl = &paDumpBranchTbl[i];
1830	cchWidth = RT_MAX(cchWidth, pDumpBranchTbl->cchWidth);
1831	cchHeight += pDumpBranchTbl->cchHeight;
1832	}
1833
1834	cchWidth += 2;
1835
1836	DBGCSCREEN hScreen = NULL;
1837	rc = dbgcScreenAsciiCreate(&hScreen, cchWidth + cchLeftExtra + cchRightExtra, cchHeight);
1838	if (RT_SUCCESS(rc))
1839	{
1840	uint32_t uY = 0;
1841
1842	/* Dump the branch tables first. */
1843	for (unsigned i = 0; i < cBranchTbls; i++)
1844	{
1845	paDumpBranchTbl[i].uStartX = cchLeftExtra + (cchWidth - paDumpBranchTbl[i].cchWidth) / 2;
1846	paDumpBranchTbl[i].uStartY = uY;
1847	dbgcCmdUnassembleCfgDumpBranchTbl(&paDumpBranchTbl[i], hScreen);
1848	uY += paDumpBranchTbl[i].cchHeight;
1849	}
1850
1851	/* Dump the basic blocks and connections to the immediate successor. */
1852	for (unsigned i = 0; i < cBbs; i++)
1853	{
1854	paDumpBb[i].uStartX = cchLeftExtra + (cchWidth - paDumpBb[i].cchWidth) / 2;
1855	paDumpBb[i].uStartY = uY;
1856	dbgcCmdUnassembleCfgDumpBb(&paDumpBb[i], hScreen);
1857	uY += paDumpBb[i].cchHeight;
1858
1859	/* Incomplete blocks don't have a successor. */
1860	if (DBGFR3FlowBbGetFlags(paDumpBb[i].hFlowBb) & DBGF_FLOW_BB_F_INCOMPLETE_ERR)
1861	continue;
1862
1863	switch (DBGFR3FlowBbGetType(paDumpBb[i].hFlowBb))
1864	{
1865	case DBGFFLOWBBENDTYPE_EXIT:
1866	case DBGFFLOWBBENDTYPE_LAST_DISASSEMBLED:
1867	case DBGFFLOWBBENDTYPE_UNCOND_JMP:
1868	case DBGFFLOWBBENDTYPE_UNCOND_INDIRECT_JMP:
1869	break;
1870	case DBGFFLOWBBENDTYPE_UNCOND:
1871	/* Draw the arrow down to the next block. */
1872	dbgcScreenAsciiDrawCharacter(hScreen, cchLeftExtra + cchWidth / 2, uY,
1873	'\|', DBGCSCREENCOLOR_BLUE_BRIGHT);
1874	uY++;
1875	dbgcScreenAsciiDrawCharacter(hScreen, cchLeftExtra + cchWidth / 2, uY,
1876	'V', DBGCSCREENCOLOR_BLUE_BRIGHT);
1877	uY++;
1878	break;
1879	case DBGFFLOWBBENDTYPE_COND:
1880	/* Draw the arrow down to the next block. */
1881	dbgcScreenAsciiDrawCharacter(hScreen, cchLeftExtra + cchWidth / 2, uY,
1882	'\|', DBGCSCREENCOLOR_RED_BRIGHT);
1883	uY++;
1884	dbgcScreenAsciiDrawCharacter(hScreen, cchLeftExtra + cchWidth / 2, uY,
1885	'V', DBGCSCREENCOLOR_RED_BRIGHT);
1886	uY++;
1887	break;
1888	default:
1889	AssertFailed();
1890	}
1891	}
1892
1893	/* Last pass, connect all remaining branches. */
1894	uint32_t uBackConns = 0;
1895	uint32_t uFwdConns = 0;
1896	for (unsigned i = 0; i < cBbs; i++)
1897	{
1898	PDBGCFLOWBBDUMP pDumpBb = &paDumpBb[i];
1899	DBGFFLOWBBENDTYPE enmEndType = DBGFR3FlowBbGetType(pDumpBb->hFlowBb);
1900
1901	/* Incomplete blocks don't have a successor. */
1902	if (DBGFR3FlowBbGetFlags(pDumpBb->hFlowBb) & DBGF_FLOW_BB_F_INCOMPLETE_ERR)
1903	continue;
1904
1905	switch (enmEndType)
1906	{
1907	case DBGFFLOWBBENDTYPE_EXIT:
1908	case DBGFFLOWBBENDTYPE_LAST_DISASSEMBLED:
1909	case DBGFFLOWBBENDTYPE_UNCOND:
1910	break;
1911	case DBGFFLOWBBENDTYPE_COND:
1912	case DBGFFLOWBBENDTYPE_UNCOND_JMP:
1913	{
1914	/* Find the target first to get the coordinates. */
1915	PDBGCFLOWBBDUMP pDumpBbTgt = NULL;
1916	for (unsigned idxDumpBb = 0; idxDumpBb < cBbs; idxDumpBb++)
1917	{
1918	pDumpBbTgt = &paDumpBb[idxDumpBb];
1919	if (dbgcCmdUnassembleCfgAddrEqual(&pDumpBb->AddrTarget, &pDumpBbTgt->AddrStart))
1920	break;
1921	}
1922
1923	DBGCSCREENCOLOR enmColor = enmEndType == DBGFFLOWBBENDTYPE_UNCOND_JMP
1924	? DBGCSCREENCOLOR_YELLOW_BRIGHT
1925	: DBGCSCREENCOLOR_GREEN_BRIGHT;
1926
1927	/*
1928	* Use the right side for targets with higher addresses,
1929	* left when jumping backwards.
1930	*/
1931	if ( dbgcCmdUnassembleCfgAddrLower(&pDumpBb->AddrTarget, &pDumpBb->AddrStart)
1932	\|\| dbgcCmdUnassembleCfgAddrEqual(&pDumpBb->AddrTarget, &pDumpBb->AddrStart))
1933	{
1934	/* Going backwards. */
1935	uint32_t uXVerLine = /cchLeftExtra - 1 -/ uBackConns + 1;
1936	uint32_t uYHorLine = pDumpBb->uStartY + pDumpBb->cchHeight - 1 - 2;
1937	uBackConns++;
1938
1939	/* Draw the arrow pointing to the target block. */
1940	dbgcScreenAsciiDrawCharacter(hScreen, pDumpBbTgt->uStartX - 1, pDumpBbTgt->uStartY,
1941	'>', enmColor);
1942	/* Draw the horizontal line. */
1943	dbgcScreenAsciiDrawLineHorizontal(hScreen, uXVerLine + 1, pDumpBbTgt->uStartX - 2,
1944	pDumpBbTgt->uStartY, '-', enmColor);
1945	dbgcScreenAsciiDrawCharacter(hScreen, uXVerLine, pDumpBbTgt->uStartY, '+',
1946	enmColor);
1947	/* Draw the vertical line down to the source block. */
1948	dbgcScreenAsciiDrawLineVertical(hScreen, uXVerLine, pDumpBbTgt->uStartY + 1, uYHorLine - 1,
1949	'\|', enmColor);
1950	dbgcScreenAsciiDrawCharacter(hScreen, uXVerLine, uYHorLine, '+', enmColor);
1951	/* Draw the horizontal connection between the source block and vertical part. */
1952	dbgcScreenAsciiDrawLineHorizontal(hScreen, uXVerLine + 1, pDumpBb->uStartX - 1,
1953	uYHorLine, '-', enmColor);
1954
1955	}
1956	else
1957	{
1958	/* Going forward. */
1959	uint32_t uXVerLine = cchWidth + cchLeftExtra + (cchRightExtra - uFwdConns) - 1;
1960	uint32_t uYHorLine = pDumpBb->uStartY + pDumpBb->cchHeight - 1 - 2;
1961	uFwdConns++;
1962
1963	/* Draw the horizontal line. */
1964	dbgcScreenAsciiDrawLineHorizontal(hScreen, pDumpBb->uStartX + pDumpBb->cchWidth,
1965	uXVerLine - 1, uYHorLine, '-', enmColor);
1966	dbgcScreenAsciiDrawCharacter(hScreen, uXVerLine, uYHorLine, '+', enmColor);
1967	/* Draw the vertical line down to the target block. */
1968	dbgcScreenAsciiDrawLineVertical(hScreen, uXVerLine, uYHorLine + 1, pDumpBbTgt->uStartY - 1,
1969	'\|', enmColor);
1970	/* Draw the horizontal connection between the target block and vertical part. */
1971	dbgcScreenAsciiDrawLineHorizontal(hScreen, pDumpBbTgt->uStartX + pDumpBbTgt->cchWidth,
1972	uXVerLine, pDumpBbTgt->uStartY, '-', enmColor);
1973	dbgcScreenAsciiDrawCharacter(hScreen, uXVerLine, pDumpBbTgt->uStartY, '+',
1974	enmColor);
1975	/* Draw the arrow pointing to the target block. */
1976	dbgcScreenAsciiDrawCharacter(hScreen, pDumpBbTgt->uStartX + pDumpBbTgt->cchWidth,
1977	pDumpBbTgt->uStartY, '<', enmColor);
1978	}
1979	break;
1980	}
1981	case DBGFFLOWBBENDTYPE_UNCOND_INDIRECT_JMP:
1982	default:
1983	AssertFailed();
1984	}
1985	}
1986
1987	rc = dbgcScreenAsciiBlit(hScreen, dbgcCmdUnassembleCfgBlit, pCmdHlp, fUseColor);
1988	dbgcScreenAsciiDestroy(hScreen);
1989	}
1990	}
1991
1992	if (paDumpBb)
1993	{
1994	for (unsigned i = 0; i < cBbs; i++)
1995	DBGFR3FlowBbRelease(paDumpBb[i].hFlowBb);
1996	RTMemTmpFree(paDumpBb);
1997	}
1998
1999	if (paDumpBranchTbl)
2000	{
2001	for (unsigned i = 0; i < cBranchTbls; i++)
2002	DBGFR3FlowBranchTblRelease(paDumpBranchTbl[i].hFlowBranchTbl);
2003	RTMemTmpFree(paDumpBranchTbl);
2004	}
2005
2006	if (hCfgIt)
2007	DBGFR3FlowItDestroy(hCfgIt);
2008	if (hFlowBranchTblIt)
2009	DBGFR3FlowBranchTblItDestroy(hFlowBranchTblIt);
2010
2011	return rc;
2012	}
2013
2014
2015	/**
2016	* @callback_method_impl{FNDBGCCMD, The 'ucfg' command.}
2017	*/
2018	static DECLCALLBACK(int) dbgcCmdUnassembleCfg(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
2019	{
2020	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2021
2022	/*
2023	* Validate input.
2024	*/
2025	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
2026	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, -1, cArgs <= 1);
2027	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, cArgs == 0 \|\| DBGCVAR_ISPOINTER(paArgs[0].enmType));
2028
2029	if (!cArgs && !DBGCVAR_ISPOINTER(pDbgc->DisasmPos.enmType))
2030	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Don't know where to start disassembling");
2031
2032	/*
2033	* Check the desired mode.
2034	*/
2035	unsigned fFlags = DBGF_DISAS_FLAGS_UNPATCHED_BYTES \| DBGF_DISAS_FLAGS_ANNOTATE_PATCHED;
2036	bool fUseColor = false;
2037	switch (pCmd->pszCmd[4])
2038	{
2039	default: AssertFailed(); RT_FALL_THRU();
2040	case '\0': fFlags \|= DBGF_DISAS_FLAGS_DEFAULT_MODE; break;
2041	case '6': fFlags \|= DBGF_DISAS_FLAGS_64BIT_MODE; break;
2042	case '3': fFlags \|= DBGF_DISAS_FLAGS_32BIT_MODE; break;
2043	case '1': fFlags \|= DBGF_DISAS_FLAGS_16BIT_MODE; break;
2044	case 'v': fFlags \|= DBGF_DISAS_FLAGS_16BIT_REAL_MODE; break;
2045	case 'c': fUseColor = true; break;
2046	}
2047
2048	/** @todo should use DBGFADDRESS for everything */
2049
2050	/*
2051	* Find address.
2052	*/
2053	if (!cArgs)
2054	{
2055	if (!DBGCVAR_ISPOINTER(pDbgc->DisasmPos.enmType))
2056	{
2057	/** @todo Batch query CS, RIP, CPU mode and flags. */
2058	PVMCPU pVCpu = VMMR3GetCpuByIdU(pUVM, pDbgc->idCpu);
2059	if (CPUMIsGuestIn64BitCode(pVCpu))
2060	{
2061	pDbgc->DisasmPos.enmType = DBGCVAR_TYPE_GC_FLAT;
2062	pDbgc->SourcePos.u.GCFlat = CPUMGetGuestRIP(pVCpu);
2063	}
2064	else
2065	{
2066	pDbgc->DisasmPos.enmType = DBGCVAR_TYPE_GC_FAR;
2067	pDbgc->SourcePos.u.GCFar.off = CPUMGetGuestEIP(pVCpu);
2068	pDbgc->SourcePos.u.GCFar.sel = CPUMGetGuestCS(pVCpu);
2069	if ( (fFlags & DBGF_DISAS_FLAGS_MODE_MASK) == DBGF_DISAS_FLAGS_DEFAULT_MODE
2070	&& (CPUMGetGuestEFlags(pVCpu) & X86_EFL_VM))
2071	{
2072	fFlags &= ~DBGF_DISAS_FLAGS_MODE_MASK;
2073	fFlags \|= DBGF_DISAS_FLAGS_16BIT_REAL_MODE;
2074	}
2075	}
2076
2077	fFlags \|= DBGF_DISAS_FLAGS_CURRENT_GUEST;
2078	}
2079	else if ((fFlags & DBGF_DISAS_FLAGS_MODE_MASK) == DBGF_DISAS_FLAGS_DEFAULT_MODE && pDbgc->fDisasm)
2080	{
2081	fFlags &= ~DBGF_DISAS_FLAGS_MODE_MASK;
2082	fFlags \|= pDbgc->fDisasm & DBGF_DISAS_FLAGS_MODE_MASK;
2083	}
2084	pDbgc->DisasmPos.enmRangeType = DBGCVAR_RANGE_NONE;
2085	}
2086	else
2087	pDbgc->DisasmPos = paArgs[0];
2088	pDbgc->pLastPos = &pDbgc->DisasmPos;
2089
2090	/*
2091	* Range.
2092	*/
2093	switch (pDbgc->DisasmPos.enmRangeType)
2094	{
2095	case DBGCVAR_RANGE_NONE:
2096	pDbgc->DisasmPos.enmRangeType = DBGCVAR_RANGE_ELEMENTS;
2097	pDbgc->DisasmPos.u64Range = 10;
2098	break;
2099
2100	case DBGCVAR_RANGE_ELEMENTS:
2101	if (pDbgc->DisasmPos.u64Range > 2048)
2102	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Too many lines requested. Max is 2048 lines");
2103	break;
2104
2105	case DBGCVAR_RANGE_BYTES:
2106	if (pDbgc->DisasmPos.u64Range > 65536)
2107	return DBGCCmdHlpFail(pCmdHlp, pCmd, "The requested range is too big. Max is 64KB");
2108	break;
2109
2110	default:
2111	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Unknown range type %d", pDbgc->DisasmPos.enmRangeType);
2112	}
2113
2114	/*
2115	* Convert physical and host addresses to guest addresses.
2116	*/
2117	RTDBGAS hDbgAs = pDbgc->hDbgAs;
2118	int rc;
2119	switch (pDbgc->DisasmPos.enmType)
2120	{
2121	case DBGCVAR_TYPE_GC_FLAT:
2122	case DBGCVAR_TYPE_GC_FAR:
2123	break;
2124	case DBGCVAR_TYPE_GC_PHYS:
2125	hDbgAs = DBGF_AS_PHYS;
2126	RT_FALL_THRU();
2127	case DBGCVAR_TYPE_HC_FLAT:
2128	case DBGCVAR_TYPE_HC_PHYS:
2129	{
2130	DBGCVAR VarTmp;
2131	rc = DBGCCmdHlpEval(pCmdHlp, &VarTmp, "%%(%Dv)", &pDbgc->DisasmPos);
2132	if (RT_FAILURE(rc))
2133	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "failed to evaluate '%%(%Dv)'", &pDbgc->DisasmPos);
2134	pDbgc->DisasmPos = VarTmp;
2135	break;
2136	}
2137	default: AssertFailed(); break;
2138	}
2139
2140	DBGFADDRESS CurAddr;
2141	if ( (fFlags & DBGF_DISAS_FLAGS_MODE_MASK) == DBGF_DISAS_FLAGS_16BIT_REAL_MODE
2142	&& pDbgc->DisasmPos.enmType == DBGCVAR_TYPE_GC_FAR)
2143	DBGFR3AddrFromFlat(pUVM, &CurAddr, ((uint32_t)pDbgc->DisasmPos.u.GCFar.sel << 4) + pDbgc->DisasmPos.u.GCFar.off);
2144	else
2145	{
2146	rc = DBGCCmdHlpVarToDbgfAddr(pCmdHlp, &pDbgc->DisasmPos, &CurAddr);
2147	if (RT_FAILURE(rc))
2148	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGCCmdHlpVarToDbgfAddr failed on '%Dv'", &pDbgc->DisasmPos);
2149	}
2150
2151	DBGFFLOW hCfg;
2152	rc = DBGFR3FlowCreate(pUVM, pDbgc->idCpu, &CurAddr, 0 /cbDisasmMax/,
2153	DBGF_FLOW_CREATE_F_TRY_RESOLVE_INDIRECT_BRANCHES, fFlags, &hCfg);
2154	if (RT_SUCCESS(rc))
2155	{
2156	/* Dump the graph. */
2157	rc = dbgcCmdUnassembleCfgDump(hCfg, fUseColor, pCmdHlp);
2158	DBGFR3FlowRelease(hCfg);
2159	}
2160	else
2161	rc = DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGFR3FlowCreate failed on '%Dv'", &pDbgc->DisasmPos);
2162
2163	NOREF(pCmd);
2164	return rc;
2165	}
2166
2167
2168	/**
2169	* @callback_method_impl{FNDBGCCMD, The 'ls' command.}
2170	*/
2171	static DECLCALLBACK(int) dbgcCmdListSource(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
2172	{
2173	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2174
2175	/*
2176	* Validate input.
2177	*/
2178	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, cArgs <= 1);
2179	if (cArgs == 1)
2180	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, DBGCVAR_ISPOINTER(paArgs[0].enmType));
2181	if (!pUVM && !cArgs && !DBGCVAR_ISPOINTER(pDbgc->SourcePos.enmType))
2182	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Don't know where to start listing...");
2183	if (!pUVM && cArgs && DBGCVAR_ISGCPOINTER(paArgs[0].enmType))
2184	return DBGCCmdHlpFail(pCmdHlp, pCmd, "GC address but no VM");
2185
2186	/*
2187	* Find address.
2188	*/
2189	if (!cArgs)
2190	{
2191	if (!DBGCVAR_ISPOINTER(pDbgc->SourcePos.enmType))
2192	{
2193	PVMCPU pVCpu = VMMR3GetCpuByIdU(pUVM, pDbgc->idCpu);
2194	pDbgc->SourcePos.enmType = DBGCVAR_TYPE_GC_FAR;
2195	pDbgc->SourcePos.u.GCFar.off = CPUMGetGuestEIP(pVCpu);
2196	pDbgc->SourcePos.u.GCFar.sel = CPUMGetGuestCS(pVCpu);
2197	}
2198	pDbgc->SourcePos.enmRangeType = DBGCVAR_RANGE_NONE;
2199	}
2200	else
2201	pDbgc->SourcePos = paArgs[0];
2202	pDbgc->pLastPos = &pDbgc->SourcePos;
2203
2204	/*
2205	* Ensure the source address is flat GC.
2206	*/
2207	switch (pDbgc->SourcePos.enmType)
2208	{
2209	case DBGCVAR_TYPE_GC_FLAT:
2210	break;
2211	case DBGCVAR_TYPE_GC_PHYS:
2212	case DBGCVAR_TYPE_GC_FAR:
2213	case DBGCVAR_TYPE_HC_FLAT:
2214	case DBGCVAR_TYPE_HC_PHYS:
2215	{
2216	int rc = DBGCCmdHlpEval(pCmdHlp, &pDbgc->SourcePos, "%%(%Dv)", &pDbgc->SourcePos);
2217	if (RT_FAILURE(rc))
2218	return DBGCCmdHlpPrintf(pCmdHlp, "error: Invalid address or address type. (rc=%d)\n", rc);
2219	break;
2220	}
2221	default: AssertFailed(); break;
2222	}
2223
2224	/*
2225	* Range.
2226	*/
2227	switch (pDbgc->SourcePos.enmRangeType)
2228	{
2229	case DBGCVAR_RANGE_NONE:
2230	pDbgc->SourcePos.enmRangeType = DBGCVAR_RANGE_ELEMENTS;
2231	pDbgc->SourcePos.u64Range = 10;
2232	break;
2233
2234	case DBGCVAR_RANGE_ELEMENTS:
2235	if (pDbgc->SourcePos.u64Range > 2048)
2236	return DBGCCmdHlpPrintf(pCmdHlp, "error: Too many lines requested. Max is 2048 lines.\n");
2237	break;
2238
2239	case DBGCVAR_RANGE_BYTES:
2240	if (pDbgc->SourcePos.u64Range > 65536)
2241	return DBGCCmdHlpPrintf(pCmdHlp, "error: The requested range is too big. Max is 64KB.\n");
2242	break;
2243
2244	default:
2245	return DBGCCmdHlpPrintf(pCmdHlp, "internal error: Unknown range type %d.\n", pDbgc->SourcePos.enmRangeType);
2246	}
2247
2248	/*
2249	* Do the disassembling.
2250	*/
2251	bool fFirst = 1;
2252	RTDBGLINE LinePrev = { 0, 0, 0, 0, 0, "" };
2253	int iRangeLeft = (int)pDbgc->SourcePos.u64Range;
2254	if (iRangeLeft == 0) /* kludge for 'r'. */
2255	iRangeLeft = -1;
2256	for (;;)
2257	{
2258	/*
2259	* Get line info.
2260	*/
2261	RTDBGLINE Line;
2262	RTGCINTPTR off;
2263	DBGFADDRESS SourcePosAddr;
2264	int rc = DBGCCmdHlpVarToDbgfAddr(pCmdHlp, &pDbgc->SourcePos, &SourcePosAddr);
2265	if (RT_FAILURE(rc))
2266	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGCCmdHlpVarToDbgfAddr(,%Dv)", &pDbgc->SourcePos);
2267	rc = DBGFR3AsLineByAddr(pUVM, pDbgc->hDbgAs, &SourcePosAddr, &off, &Line, NULL);
2268	if (RT_FAILURE(rc))
2269	return VINF_SUCCESS;
2270
2271	unsigned cLines = 0;
2272	if (memcmp(&Line, &LinePrev, sizeof(Line)))
2273	{
2274	/*
2275	* Print filenamename
2276	*/
2277	if (!fFirst && strcmp(Line.szFilename, LinePrev.szFilename))
2278	fFirst = true;
2279	if (fFirst)
2280	{
2281	rc = DBGCCmdHlpPrintf(pCmdHlp, "[%s @ %d]\n", Line.szFilename, Line.uLineNo);
2282	if (RT_FAILURE(rc))
2283	return rc;
2284	}
2285
2286	/*
2287	* Try open the file and read the line.
2288	*/
2289	FILE *phFile = fopen(Line.szFilename, "r");
2290	if (phFile)
2291	{
2292	/* Skip ahead to the desired line. */
2293	char szLine[4096];
2294	unsigned cBefore = fFirst ? RT_MIN(2, Line.uLineNo - 1) : Line.uLineNo - LinePrev.uLineNo - 1;
2295	if (cBefore > 7)
2296	cBefore = 0;
2297	unsigned cLeft = Line.uLineNo - cBefore;
2298	while (cLeft > 0)
2299	{
2300	szLine[0] = '\0';
2301	if (!fgets(szLine, sizeof(szLine), phFile))
2302	break;
2303	cLeft--;
2304	}
2305	if (!cLeft)
2306	{
2307	/* print the before lines */
2308	for (;;)
2309	{
2310	size_t cch = strlen(szLine);
2311	while (cch > 0 && (szLine[cch - 1] == '\r' \|\| szLine[cch - 1] == '\n' \|\| RT_C_IS_SPACE(szLine[cch - 1])) )
2312	szLine[--cch] = '\0';
2313	if (cBefore-- <= 0)
2314	break;
2315
2316	rc = DBGCCmdHlpPrintf(pCmdHlp, " %4d: %s\n", Line.uLineNo - cBefore - 1, szLine);
2317	szLine[0] = '\0';
2318	const char *pszShutUpGcc = fgets(szLine, sizeof(szLine), phFile); NOREF(pszShutUpGcc);
2319	cLines++;
2320	}
2321	/* print the actual line */
2322	rc = DBGCCmdHlpPrintf(pCmdHlp, "%08llx %4d: %s\n", Line.Address, Line.uLineNo, szLine);
2323	}
2324	fclose(phFile);
2325	if (RT_FAILURE(rc))
2326	return rc;
2327	fFirst = false;
2328	}
2329	else
2330	return DBGCCmdHlpPrintf(pCmdHlp, "Warning: couldn't open source file '%s'\n", Line.szFilename);
2331
2332	LinePrev = Line;
2333	}
2334
2335
2336	/*
2337	* Advance
2338	*/
2339	if (iRangeLeft < 0) /* 'r' */
2340	break;
2341	if (pDbgc->SourcePos.enmRangeType == DBGCVAR_RANGE_ELEMENTS)
2342	iRangeLeft -= cLines;
2343	else
2344	iRangeLeft -= 1;
2345	rc = DBGCCmdHlpEval(pCmdHlp, &pDbgc->SourcePos, "(%Dv) + %x", &pDbgc->SourcePos, 1);
2346	if (RT_FAILURE(rc))
2347	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Expression: (%Dv) + %x\n", &pDbgc->SourcePos, 1);
2348	if (iRangeLeft <= 0)
2349	break;
2350	}
2351
2352	NOREF(pCmd);
2353	return 0;
2354	}
2355
2356
2357	/**
2358	* @callback_method_impl{FNDBGCCMD, The 'r' command.}
2359	*/
2360	static DECLCALLBACK(int) dbgcCmdReg(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
2361	{
2362	return dbgcCmdRegGuest(pCmd, pCmdHlp, pUVM, paArgs, cArgs);
2363	}
2364
2365
2366	/**
2367	* @callback_method_impl{FNDBGCCMD, Common worker for the dbgcCmdReg*()
2368	* commands.}
2369	*/
2370	static DECLCALLBACK(int) dbgcCmdRegCommon(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs,
2371	const char *pszPrefix)
2372	{
2373	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2374	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, cArgs == 1 \|\| cArgs == 2 \|\| cArgs == 3);
2375	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, paArgs[0].enmType == DBGCVAR_TYPE_STRING
2376	\|\| paArgs[0].enmType == DBGCVAR_TYPE_SYMBOL);
2377
2378	/*
2379	* Parse the register name and kind.
2380	*/
2381	const char *pszReg = paArgs[0].u.pszString;
2382	if (*pszReg == '@')
2383	pszReg++;
2384	VMCPUID idCpu = pDbgc->idCpu;
2385	if (*pszPrefix)
2386	idCpu \|= DBGFREG_HYPER_VMCPUID;
2387	if (*pszReg == '.')
2388	{
2389	pszReg++;
2390	idCpu \|= DBGFREG_HYPER_VMCPUID;
2391	}
2392	const char * const pszActualPrefix = idCpu & DBGFREG_HYPER_VMCPUID ? "." : "";
2393
2394	/*
2395	* Query the register type & value (the setter needs the type).
2396	*/
2397	DBGFREGVALTYPE enmType;
2398	DBGFREGVAL Value;
2399	int rc = DBGFR3RegNmQuery(pUVM, idCpu, pszReg, &Value, &enmType);
2400	if (RT_FAILURE(rc))
2401	{
2402	if (rc == VERR_DBGF_REGISTER_NOT_FOUND)
2403	return DBGCCmdHlpVBoxError(pCmdHlp, VERR_INVALID_PARAMETER, "Unknown register: '%s%s'.\n",
2404	pszActualPrefix, pszReg);
2405	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "DBGFR3RegNmQuery failed querying '%s%s': %Rrc.\n",
2406	pszActualPrefix, pszReg, rc);
2407	}
2408	if (cArgs == 1)
2409	{
2410	/*
2411	* Show the register.
2412	*/
2413	char szValue[160];
2414	rc = DBGFR3RegFormatValue(szValue, sizeof(szValue), &Value, enmType, true /fSpecial/);
2415	if (RT_SUCCESS(rc))
2416	rc = DBGCCmdHlpPrintf(pCmdHlp, "%s%s=%s\n", pszActualPrefix, pszReg, szValue);
2417	else
2418	rc = DBGCCmdHlpVBoxError(pCmdHlp, rc, "DBGFR3RegFormatValue failed: %Rrc.\n", rc);
2419	}
2420	else
2421	{
2422	DBGCVAR NewValueTmp;
2423	PCDBGCVAR pNewValue;
2424	if (cArgs == 3)
2425	{
2426	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 1, paArgs[1].enmType == DBGCVAR_TYPE_STRING);
2427	if (strcmp(paArgs[1].u.pszString, "="))
2428	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Second argument must be '='.");
2429	pNewValue = &paArgs[2];
2430	}
2431	else
2432	{
2433	/* Not possible to convince the parser to support both codeview and
2434	windbg syntax and make the equal sign optional. Try help it. */
2435	/** @todo make DBGCCmdHlpConvert do more with strings. */
2436	rc = DBGCCmdHlpConvert(pCmdHlp, &paArgs[1], DBGCVAR_TYPE_NUMBER, true /fConvSyms/, &NewValueTmp);
2437	if (RT_FAILURE(rc))
2438	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "The last argument must be a value or valid symbol.");
2439	pNewValue = &NewValueTmp;
2440	}
2441
2442	/*
2443	* Modify the register.
2444	*/
2445	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 1, pNewValue->enmType == DBGCVAR_TYPE_NUMBER);
2446	if (enmType != DBGFREGVALTYPE_DTR)
2447	{
2448	enmType = DBGFREGVALTYPE_U64;
2449	rc = DBGCCmdHlpVarToNumber(pCmdHlp, pNewValue, &Value.u64);
2450	}
2451	else
2452	{
2453	enmType = DBGFREGVALTYPE_DTR;
2454	rc = DBGCCmdHlpVarToNumber(pCmdHlp, pNewValue, &Value.dtr.u64Base);
2455	if (RT_SUCCESS(rc) && pNewValue->enmRangeType != DBGCVAR_RANGE_NONE)
2456	Value.dtr.u32Limit = (uint32_t)pNewValue->u64Range;
2457	}
2458	if (RT_SUCCESS(rc))
2459	{
2460	rc = DBGFR3RegNmSet(pUVM, idCpu, pszReg, &Value, enmType);
2461	if (RT_FAILURE(rc))
2462	rc = DBGCCmdHlpVBoxError(pCmdHlp, rc, "DBGFR3RegNmSet failed settings '%s%s': %Rrc\n",
2463	pszActualPrefix, pszReg, rc);
2464	if (rc != VINF_SUCCESS)
2465	DBGCCmdHlpPrintf(pCmdHlp, "%s: warning: %Rrc\n", pCmd->pszCmd, rc);
2466	}
2467	else
2468	rc = DBGCCmdHlpVBoxError(pCmdHlp, rc, "DBGFR3RegFormatValue failed: %Rrc.\n", rc);
2469	}
2470	return rc;
2471	}
2472
2473
2474	/**
2475	* @callback_method_impl{FNDBGCCMD,
2476	* The 'rg'\, 'rg64' and 'rg32' commands\, worker for 'r'.}
2477	*/
2478	static DECLCALLBACK(int) dbgcCmdRegGuest(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
2479	{
2480	/*
2481	* Show all registers our selves.
2482	*/
2483	if (cArgs == 0)
2484	{
2485	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2486	bool const f64BitMode = !strcmp(pCmd->pszCmd, "rg64")
2487	\|\| ( strcmp(pCmd->pszCmd, "rg32") != 0
2488	&& DBGFR3CpuIsIn64BitCode(pUVM, pDbgc->idCpu));
2489	return DBGCCmdHlpRegPrintf(pCmdHlp, pDbgc->idCpu, f64BitMode, pDbgc->fRegTerse);
2490	}
2491	return dbgcCmdRegCommon(pCmd, pCmdHlp, pUVM, paArgs, cArgs, "");
2492	}
2493
2494
2495	/**
2496	* @callback_method_impl{FNDBGCCMD, The 'rt' command.}
2497	*/
2498	static DECLCALLBACK(int) dbgcCmdRegTerse(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
2499	{
2500	NOREF(pCmd); NOREF(pUVM); NOREF(paArgs); NOREF(cArgs);
2501
2502	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2503	pDbgc->fRegTerse = !pDbgc->fRegTerse;
2504	return DBGCCmdHlpPrintf(pCmdHlp, pDbgc->fRegTerse ? "info: Terse register info.\n" : "info: Verbose register info.\n");
2505	}
2506
2507
2508	/**
2509	* @callback_method_impl{FNDBGCCMD, The 'pr' and 'tr' commands.}
2510	*/
2511	static DECLCALLBACK(int) dbgcCmdStepTraceToggle(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
2512	{
2513	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2514	Assert(cArgs == 0); NOREF(pCmd); NOREF(pUVM); NOREF(paArgs); NOREF(cArgs);
2515
2516	/* Note! windbg accepts 'r' as a flag to 'p', 'pa', 'pc', 'pt', 't',
2517	'ta', 'tc' and 'tt'. We've simplified it. */
2518	pDbgc->fStepTraceRegs = !pDbgc->fStepTraceRegs;
2519	return VINF_SUCCESS;
2520	}
2521
2522
2523	/**
2524	* @callback_method_impl{FNDBGCCMD, The 'p'\, 'pc'\, 'pt'\, 't'\, 'tc'\, and 'tt' commands.}
2525	*/
2526	static DECLCALLBACK(int) dbgcCmdStepTrace(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
2527	{
2528	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2529	if (cArgs != 0)
2530	return DBGCCmdHlpFail(pCmdHlp, pCmd,
2531	"Sorry, but the '%s' command does not currently implement any arguments.\n", pCmd->pszCmd);
2532
2533	/* The 'count' has to be implemented by DBGC, whereas the
2534	filtering is taken care of by DBGF. */
2535
2536	/*
2537	* Convert the command to DBGF_STEP_F_XXX and other API input.
2538	*/
2539	//DBGFADDRESS StackPop;
2540	PDBGFADDRESS pStackPop = NULL;
2541	RTGCPTR cbStackPop = 0;
2542	uint32_t cMaxSteps = pCmd->pszCmd[0] == 'p' ? _512K : _64K;
2543	uint32_t fFlags = pCmd->pszCmd[0] == 'p' ? DBGF_STEP_F_OVER : DBGF_STEP_F_INTO;
2544	if (pCmd->pszCmd[1] == 'c')
2545	fFlags \|= DBGF_STEP_F_STOP_ON_CALL;
2546	else if (pCmd->pszCmd[1] == 't')
2547	fFlags \|= DBGF_STEP_F_STOP_ON_RET;
2548	else if (pCmd->pszCmd[0] != 'p')
2549	cMaxSteps = 1;
2550	else
2551	{
2552	/** @todo consider passing RSP + 1 in for 'p' and something else sensible for
2553	* the 'pt' command. */
2554	}
2555
2556	int rc = DBGFR3StepEx(pUVM, pDbgc->idCpu, fFlags, NULL, pStackPop, cbStackPop, cMaxSteps);
2557	if (RT_SUCCESS(rc))
2558	pDbgc->fReady = false;
2559	else
2560	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGFR3StepEx(,,%#x,) failed", fFlags);
2561
2562	NOREF(pCmd); NOREF(paArgs); NOREF(cArgs);
2563	return rc;
2564	}
2565
2566
2567	/**
2568	* @callback_method_impl{FNDBGCCMD, The 'pa' and 'ta' commands.}
2569	*/
2570	static DECLCALLBACK(int) dbgcCmdStepTraceTo(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
2571	{
2572	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2573	if (cArgs != 1)
2574	return DBGCCmdHlpFail(pCmdHlp, pCmd,
2575	"Sorry, but the '%s' command only implements a single argument at present.\n", pCmd->pszCmd);
2576	DBGFADDRESS Address;
2577	int rc = pCmdHlp->pfnVarToDbgfAddr(pCmdHlp, &paArgs[0], &Address);
2578	if (RT_FAILURE(rc))
2579	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "VarToDbgfAddr(,%Dv,)\n", &paArgs[0]);
2580
2581	uint32_t cMaxSteps = pCmd->pszCmd[0] == 'p' ? _512K : 1;
2582	uint32_t fFlags = pCmd->pszCmd[0] == 'p' ? DBGF_STEP_F_OVER : DBGF_STEP_F_INTO;
2583	rc = DBGFR3StepEx(pUVM, pDbgc->idCpu, fFlags, &Address, NULL, 0, cMaxSteps);
2584	if (RT_SUCCESS(rc))
2585	pDbgc->fReady = false;
2586	else
2587	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGFR3StepEx(,,%#x,) failed", fFlags);
2588	return rc;
2589	}
2590
2591
2592	/**
2593	* Helper that tries to resolve a far address to a symbol and formats it.
2594	*
2595	* @returns Pointer to symbol string on success, NULL if not resolved.
2596	* Free using RTStrFree.
2597	* @param pCmdHlp The command helper structure.
2598	* @param hAs The address space to use. NIL_RTDBGAS means no symbol resolving.
2599	* @param sel The selector part of the address.
2600	* @param off The offset part of the address.
2601	* @param pszPrefix How to prefix the symbol string.
2602	* @param pszSuffix How to suffix the symbol string.
2603	*/
2604	static char *dbgcCmdHlpFarAddrToSymbol(PDBGCCMDHLP pCmdHlp, RTDBGAS hAs, RTSEL sel, uint64_t off,
2605	const char pszPrefix, const char pszSuffix)
2606	{
2607	char *pszRet = NULL;
2608	if (hAs != NIL_RTDBGAS)
2609	{
2610	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2611	DBGFADDRESS Addr;
2612	int rc = DBGFR3AddrFromSelOff(pDbgc->pUVM, pDbgc->idCpu, &Addr, sel, off);
2613	if (RT_SUCCESS(rc))
2614	{
2615	RTGCINTPTR offDispSym = 0;
2616	PRTDBGSYMBOL pSymbol = DBGFR3AsSymbolByAddrA(pDbgc->pUVM, hAs, &Addr,
2617	RTDBGSYMADDR_FLAGS_GREATER_OR_EQUAL
2618	\| RTDBGSYMADDR_FLAGS_SKIP_ABS_IN_DEFERRED,
2619	&offDispSym, NULL);
2620	if (pSymbol)
2621	{
2622	if (offDispSym == 0)
2623	pszRet = RTStrAPrintf2("%s%s%s", pszPrefix, pSymbol->szName, pszSuffix);
2624	else if (offDispSym > 0)
2625	pszRet = RTStrAPrintf2("%s%s+%llx%s", pszPrefix, pSymbol->szName, (int64_t)offDispSym, pszSuffix);
2626	else
2627	pszRet = RTStrAPrintf2("%s%s-%llx%s", pszPrefix, pSymbol->szName, -(int64_t)offDispSym, pszSuffix);
2628	RTDbgSymbolFree(pSymbol);
2629	}
2630	}
2631	}
2632	return pszRet;
2633	}
2634
2635
2636	/**
2637	* @callback_method_impl{FNDBGCCMD, The 'k'\, 'kg' and 'kh' commands.}
2638	*/
2639	static DECLCALLBACK(int) dbgcCmdStack(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
2640	{
2641	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2642
2643	/*
2644	* Figure which context we're called for and start walking that stack.
2645	*/
2646	int rc;
2647	PCDBGFSTACKFRAME pFirstFrame;
2648	bool const fGuest = true;
2649	bool const fVerbose = pCmd->pszCmd[1] == 'v'
2650	\|\| (pCmd->pszCmd[1] != '\0' && pCmd->pszCmd[2] == 'v');
2651	rc = DBGFR3StackWalkBegin(pUVM, pDbgc->idCpu, fGuest ? DBGFCODETYPE_GUEST : DBGFCODETYPE_HYPER, &pFirstFrame);
2652	if (RT_FAILURE(rc))
2653	return DBGCCmdHlpPrintf(pCmdHlp, "Failed to begin stack walk, rc=%Rrc\n", rc);
2654
2655	/*
2656	* Print the frames.
2657	*/
2658	char szTmp[1024];
2659	uint32_t fBitFlags = 0;
2660	for (PCDBGFSTACKFRAME pFrame = pFirstFrame;
2661	pFrame;
2662	pFrame = DBGFR3StackWalkNext(pFrame))
2663	{
2664	uint32_t const fCurBitFlags = pFrame->fFlags & (DBGFSTACKFRAME_FLAGS_16BIT \| DBGFSTACKFRAME_FLAGS_32BIT \| DBGFSTACKFRAME_FLAGS_64BIT);
2665	if (fCurBitFlags & DBGFSTACKFRAME_FLAGS_16BIT)
2666	{
2667	if (fCurBitFlags != fBitFlags)
2668	pCmdHlp->pfnPrintf(pCmdHlp, NULL, "# SS:BP Ret SS:BP Ret CS:EIP Arg0 Arg1 Arg2 Arg3 CS:EIP / Symbol [line]\n");
2669	rc = DBGCCmdHlpPrintf(pCmdHlp, "%02x %04RX16:%04RX16 %04RX16:%04RX16 %04RX32:%08RX32 %08RX32 %08RX32 %08RX32 %08RX32",
2670	pFrame->iFrame,
2671	pFrame->AddrFrame.Sel,
2672	(uint16_t)pFrame->AddrFrame.off,
2673	pFrame->AddrReturnFrame.Sel,
2674	(uint16_t)pFrame->AddrReturnFrame.off,
2675	(uint32_t)pFrame->AddrReturnPC.Sel,
2676	(uint32_t)pFrame->AddrReturnPC.off,
2677	pFrame->Args.au32[0],
2678	pFrame->Args.au32[1],
2679	pFrame->Args.au32[2],
2680	pFrame->Args.au32[3]);
2681	}
2682	else if (fCurBitFlags & DBGFSTACKFRAME_FLAGS_32BIT)
2683	{
2684	if (fCurBitFlags != fBitFlags)
2685	pCmdHlp->pfnPrintf(pCmdHlp, NULL, "# EBP Ret EBP Ret CS:EIP Arg0 Arg1 Arg2 Arg3 CS:EIP / Symbol [line]\n");
2686	rc = DBGCCmdHlpPrintf(pCmdHlp, "%02x %08RX32 %08RX32 %04RX32:%08RX32 %08RX32 %08RX32 %08RX32 %08RX32",
2687	pFrame->iFrame,
2688	(uint32_t)pFrame->AddrFrame.off,
2689	(uint32_t)pFrame->AddrReturnFrame.off,
2690	(uint32_t)pFrame->AddrReturnPC.Sel,
2691	(uint32_t)pFrame->AddrReturnPC.off,
2692	pFrame->Args.au32[0],
2693	pFrame->Args.au32[1],
2694	pFrame->Args.au32[2],
2695	pFrame->Args.au32[3]);
2696	}
2697	else if (fCurBitFlags & DBGFSTACKFRAME_FLAGS_64BIT)
2698	{
2699	if (fCurBitFlags != fBitFlags)
2700	pCmdHlp->pfnPrintf(pCmdHlp, NULL, "# RBP Ret SS:RBP Ret RIP CS:RIP / Symbol [line]\n");
2701	rc = DBGCCmdHlpPrintf(pCmdHlp, "%02x %016RX64 %04RX16:%016RX64 %016RX64",
2702	pFrame->iFrame,
2703	(uint64_t)pFrame->AddrFrame.off,
2704	pFrame->AddrReturnFrame.Sel,
2705	(uint64_t)pFrame->AddrReturnFrame.off,
2706	(uint64_t)pFrame->AddrReturnPC.off);
2707	}
2708	if (RT_FAILURE(rc))
2709	break;
2710	if (!pFrame->pSymPC)
2711	rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
2712	fCurBitFlags & DBGFSTACKFRAME_FLAGS_64BIT
2713	? " %RTsel:%016RGv"
2714	: fCurBitFlags & DBGFSTACKFRAME_FLAGS_32BIT
2715	? " %RTsel:%08RGv"
2716	: " %RTsel:%04RGv"
2717	, pFrame->AddrPC.Sel, pFrame->AddrPC.off);
2718	else
2719	{
2720	RTGCINTPTR offDisp = pFrame->AddrPC.FlatPtr - pFrame->pSymPC->Value; /** @todo this isn't 100% correct for segmented stuff. */
2721	if (offDisp > 0)
2722	rc = DBGCCmdHlpPrintf(pCmdHlp, " %s+%llx", pFrame->pSymPC->szName, (int64_t)offDisp);
2723	else if (offDisp < 0)
2724	rc = DBGCCmdHlpPrintf(pCmdHlp, " %s-%llx", pFrame->pSymPC->szName, -(int64_t)offDisp);
2725	else
2726	rc = DBGCCmdHlpPrintf(pCmdHlp, " %s", pFrame->pSymPC->szName);
2727	}
2728	if (RT_SUCCESS(rc) && pFrame->pLinePC)
2729	rc = DBGCCmdHlpPrintf(pCmdHlp, " [%s @ 0i%d]", pFrame->pLinePC->szFilename, pFrame->pLinePC->uLineNo);
2730	if (RT_SUCCESS(rc))
2731	rc = DBGCCmdHlpPrintf(pCmdHlp, "\n");
2732
2733	if (fVerbose && RT_SUCCESS(rc))
2734	{
2735	/*
2736	* Display verbose frame info.
2737	*/
2738	const char *pszRetType = "invalid";
2739	switch (pFrame->enmReturnType)
2740	{
2741	case RTDBGRETURNTYPE_NEAR16: pszRetType = "retn/16"; break;
2742	case RTDBGRETURNTYPE_NEAR32: pszRetType = "retn/32"; break;
2743	case RTDBGRETURNTYPE_NEAR64: pszRetType = "retn/64"; break;
2744	case RTDBGRETURNTYPE_FAR16: pszRetType = "retf/16"; break;
2745	case RTDBGRETURNTYPE_FAR32: pszRetType = "retf/32"; break;
2746	case RTDBGRETURNTYPE_FAR64: pszRetType = "retf/64"; break;
2747	case RTDBGRETURNTYPE_IRET16: pszRetType = "iret-16"; break;
2748	case RTDBGRETURNTYPE_IRET32: pszRetType = "iret/32s"; break;
2749	case RTDBGRETURNTYPE_IRET32_PRIV: pszRetType = "iret/32p"; break;
2750	case RTDBGRETURNTYPE_IRET32_V86: pszRetType = "iret/v86"; break;
2751	case RTDBGRETURNTYPE_IRET64: pszRetType = "iret/64"; break;
2752
2753	case RTDBGRETURNTYPE_END:
2754	case RTDBGRETURNTYPE_INVALID:
2755	case RTDBGRETURNTYPE_32BIT_HACK:
2756	break;
2757	}
2758	size_t cchLine = DBGCCmdHlpPrintfLen(pCmdHlp, " %s", pszRetType);
2759	if (pFrame->fFlags & DBGFSTACKFRAME_FLAGS_USED_UNWIND_INFO)
2760	cchLine += DBGCCmdHlpPrintfLen(pCmdHlp, " used-unwind-info");
2761	if (pFrame->fFlags & DBGFSTACKFRAME_FLAGS_USED_ODD_EVEN)
2762	cchLine += DBGCCmdHlpPrintfLen(pCmdHlp, " used-odd-even");
2763	if (pFrame->fFlags & DBGFSTACKFRAME_FLAGS_REAL_V86)
2764	cchLine += DBGCCmdHlpPrintfLen(pCmdHlp, " real-v86");
2765	if (pFrame->fFlags & DBGFSTACKFRAME_FLAGS_MAX_DEPTH)
2766	cchLine += DBGCCmdHlpPrintfLen(pCmdHlp, " max-depth");
2767	if (pFrame->fFlags & DBGFSTACKFRAME_FLAGS_TRAP_FRAME)
2768	cchLine += DBGCCmdHlpPrintfLen(pCmdHlp, " trap-frame");
2769
2770	if (pFrame->cSureRegs > 0)
2771	{
2772	cchLine = 1024; /* force new line */
2773	for (uint32_t i = 0; i < pFrame->cSureRegs; i++)
2774	{
2775	if (cchLine > 80)
2776	{
2777	DBGCCmdHlpPrintf(pCmdHlp, "\n ");
2778	cchLine = 2;
2779	}
2780
2781	szTmp[0] = '\0';
2782	DBGFR3RegFormatValue(szTmp, sizeof(szTmp), &pFrame->paSureRegs[i].Value,
2783	pFrame->paSureRegs[i].enmType, false);
2784	const char *pszName = pFrame->paSureRegs[i].enmReg != DBGFREG_END
2785	? DBGFR3RegCpuName(pUVM, pFrame->paSureRegs[i].enmReg, pFrame->paSureRegs[i].enmType)
2786	: pFrame->paSureRegs[i].pszName;
2787	cchLine += DBGCCmdHlpPrintfLen(pCmdHlp, " %s=%s", pszName, szTmp);
2788	}
2789	}
2790
2791	if (RT_SUCCESS(rc))
2792	rc = DBGCCmdHlpPrintf(pCmdHlp, "\n");
2793	}
2794
2795	if (RT_FAILURE(rc))
2796	break;
2797
2798	fBitFlags = fCurBitFlags;
2799	}
2800
2801	DBGFR3StackWalkEnd(pFirstFrame);
2802
2803	NOREF(paArgs); NOREF(cArgs);
2804	return rc;
2805	}
2806
2807
2808	/**
2809	* Worker function that displays one descriptor entry (GDT, LDT, IDT).
2810	*
2811	* @returns pfnPrintf status code.
2812	* @param pCmdHlp The DBGC command helpers.
2813	* @param pDesc The descriptor to display.
2814	* @param iEntry The descriptor entry number.
2815	* @param fHyper Whether the selector belongs to the hypervisor or not.
2816	* @param hAs Address space to use when resolving symbols.
2817	* @param pfDblEntry Where to indicate whether the entry is two entries wide.
2818	* Optional.
2819	*/
2820	static int dbgcCmdDumpDTWorker64(PDBGCCMDHLP pCmdHlp, PCX86DESC64 pDesc, unsigned iEntry, bool fHyper, RTDBGAS hAs,
2821	bool *pfDblEntry)
2822	{
2823	/* GUEST64 */
2824	int rc;
2825
2826	const char *pszHyper = fHyper ? " HYPER" : "";
2827	const char *pszPresent = pDesc->Gen.u1Present ? "P " : "NP";
2828	if (pDesc->Gen.u1DescType)
2829	{
2830	static const char * const s_apszTypes[] =
2831	{
2832	"DataRO", /* 0 Read-Only */
2833	"DataRO", /* 1 Read-Only - Accessed */
2834	"DataRW", /* 2 Read/Write */
2835	"DataRW", /* 3 Read/Write - Accessed */
2836	"DownRO", /* 4 Expand-down, Read-Only */
2837	"DownRO", /* 5 Expand-down, Read-Only - Accessed */
2838	"DownRW", /* 6 Expand-down, Read/Write */
2839	"DownRW", /* 7 Expand-down, Read/Write - Accessed */
2840	"CodeEO", /* 8 Execute-Only */
2841	"CodeEO", /* 9 Execute-Only - Accessed */
2842	"CodeER", /* A Execute/Readable */
2843	"CodeER", /* B Execute/Readable - Accessed */
2844	"ConfE0", /* C Conforming, Execute-Only */
2845	"ConfE0", /* D Conforming, Execute-Only - Accessed */
2846	"ConfER", /* E Conforming, Execute/Readable */
2847	"ConfER" /* F Conforming, Execute/Readable - Accessed */
2848	};
2849	const char *pszAccessed = pDesc->Gen.u4Type & RT_BIT(0) ? "A " : "NA";
2850	const char *pszGranularity = pDesc->Gen.u1Granularity ? "G" : " ";
2851	const char *pszBig = pDesc->Gen.u1DefBig ? "BIG" : " ";
2852	uint32_t u32Base = X86DESC_BASE(pDesc);
2853	uint32_t cbLimit = X86DESC_LIMIT_G(pDesc);
2854
2855	rc = DBGCCmdHlpPrintf(pCmdHlp, "%04x %s Bas=%08x Lim=%08x DPL=%d %s %s %s %s AVL=%d L=%d%s\n",
2856	iEntry, s_apszTypes[pDesc->Gen.u4Type], u32Base, cbLimit,
2857	pDesc->Gen.u2Dpl, pszPresent, pszAccessed, pszGranularity, pszBig,
2858	pDesc->Gen.u1Available, pDesc->Gen.u1Long, pszHyper);
2859	}
2860	else
2861	{
2862	static const char * const s_apszTypes[] =
2863	{
2864	"Ill-0 ", /* 0 0000 Reserved (Illegal) */
2865	"Ill-1 ", /* 1 0001 Available 16-bit TSS */
2866	"LDT ", /* 2 0010 LDT */
2867	"Ill-3 ", /* 3 0011 Busy 16-bit TSS */
2868	"Ill-4 ", /* 4 0100 16-bit Call Gate */
2869	"Ill-5 ", /* 5 0101 Task Gate */
2870	"Ill-6 ", /* 6 0110 16-bit Interrupt Gate */
2871	"Ill-7 ", /* 7 0111 16-bit Trap Gate */
2872	"Ill-8 ", /* 8 1000 Reserved (Illegal) */
2873	"Tss64A", /* 9 1001 Available 32-bit TSS */
2874	"Ill-A ", /* A 1010 Reserved (Illegal) */
2875	"Tss64B", /* B 1011 Busy 32-bit TSS */
2876	"Call64", /* C 1100 32-bit Call Gate */
2877	"Ill-D ", /* D 1101 Reserved (Illegal) */
2878	"Int64 ", /* E 1110 32-bit Interrupt Gate */
2879	"Trap64" /* F 1111 32-bit Trap Gate */
2880	};
2881	switch (pDesc->Gen.u4Type)
2882	{
2883	/* raw */
2884	case X86_SEL_TYPE_SYS_UNDEFINED:
2885	case X86_SEL_TYPE_SYS_UNDEFINED2:
2886	case X86_SEL_TYPE_SYS_UNDEFINED4:
2887	case X86_SEL_TYPE_SYS_UNDEFINED3:
2888	case X86_SEL_TYPE_SYS_286_TSS_AVAIL:
2889	case X86_SEL_TYPE_SYS_286_TSS_BUSY:
2890	case X86_SEL_TYPE_SYS_286_CALL_GATE:
2891	case X86_SEL_TYPE_SYS_286_INT_GATE:
2892	case X86_SEL_TYPE_SYS_286_TRAP_GATE:
2893	case X86_SEL_TYPE_SYS_TASK_GATE:
2894	rc = DBGCCmdHlpPrintf(pCmdHlp, "%04x %s %.8Rhxs DPL=%d %s%s\n",
2895	iEntry, s_apszTypes[pDesc->Gen.u4Type], pDesc,
2896	pDesc->Gen.u2Dpl, pszPresent, pszHyper);
2897	break;
2898
2899	case X86_SEL_TYPE_SYS_386_TSS_AVAIL:
2900	case X86_SEL_TYPE_SYS_386_TSS_BUSY:
2901	case X86_SEL_TYPE_SYS_LDT:
2902	{
2903	const char *pszBusy = pDesc->Gen.u4Type & RT_BIT(1) ? "B " : "NB";
2904	const char *pszBig = pDesc->Gen.u1DefBig ? "BIG" : " ";
2905	const char *pszLong = pDesc->Gen.u1Long ? "LONG" : " ";
2906
2907	uint64_t u64Base = X86DESC64_BASE(pDesc);
2908	uint32_t cbLimit = X86DESC_LIMIT_G(pDesc);
2909
2910	rc = DBGCCmdHlpPrintf(pCmdHlp, "%04x %s Bas=%016RX64 Lim=%08x DPL=%d %s %s %s %sAVL=%d R=%d%s\n",
2911	iEntry, s_apszTypes[pDesc->Gen.u4Type], u64Base, cbLimit,
2912	pDesc->Gen.u2Dpl, pszPresent, pszBusy, pszLong, pszBig,
2913	pDesc->Gen.u1Available, pDesc->Gen.u1Long \| (pDesc->Gen.u1DefBig << 1),
2914	pszHyper);
2915	if (pfDblEntry)
2916	*pfDblEntry = true;
2917	break;
2918	}
2919
2920	case X86_SEL_TYPE_SYS_386_CALL_GATE:
2921	{
2922	unsigned cParams = pDesc->au8[4] & 0x1f;
2923	const char *pszCountOf = pDesc->Gen.u4Type & RT_BIT(3) ? "DC" : "WC";
2924	RTSEL sel = pDesc->au16[1];
2925	uint64_t off = pDesc->au16[0]
2926	\| ((uint64_t)pDesc->au16[3] << 16)
2927	\| ((uint64_t)pDesc->Gen.u32BaseHigh3 << 32);
2928	char *pszSymbol = dbgcCmdHlpFarAddrToSymbol(pCmdHlp, hAs, sel, off, " (", ")");
2929	rc = DBGCCmdHlpPrintf(pCmdHlp, "%04x %s Sel:Off=%04x:%016RX64 DPL=%d %s %s=%d%s%s\n",
2930	iEntry, s_apszTypes[pDesc->Gen.u4Type], sel, off,
2931	pDesc->Gen.u2Dpl, pszPresent, pszCountOf, cParams, pszHyper, pszSymbol ? pszSymbol : "");
2932	RTStrFree(pszSymbol);
2933	if (pfDblEntry)
2934	*pfDblEntry = true;
2935	break;
2936	}
2937
2938	case X86_SEL_TYPE_SYS_386_INT_GATE:
2939	case X86_SEL_TYPE_SYS_386_TRAP_GATE:
2940	{
2941	RTSEL sel = pDesc->Gate.u16Sel;
2942	uint64_t off = pDesc->Gate.u16OffsetLow
2943	\| ((uint64_t)pDesc->Gate.u16OffsetHigh << 16)
2944	\| ((uint64_t)pDesc->Gate.u32OffsetTop << 32);
2945	char *pszSymbol = dbgcCmdHlpFarAddrToSymbol(pCmdHlp, hAs, sel, off, " (", ")");
2946	rc = DBGCCmdHlpPrintf(pCmdHlp, "%04x %s Sel:Off=%04x:%016RX64 DPL=%u %s IST=%u%s%s\n",
2947	iEntry, s_apszTypes[pDesc->Gate.u4Type], sel, off,
2948	pDesc->Gate.u2Dpl, pszPresent, pDesc->Gate.u3IST, pszHyper, pszSymbol ? pszSymbol : "");
2949	RTStrFree(pszSymbol);
2950	if (pfDblEntry)
2951	*pfDblEntry = true;
2952	break;
2953	}
2954
2955	/* impossible, just it's necessary to keep gcc happy. */
2956	default:
2957	return VINF_SUCCESS;
2958	}
2959	}
2960	return VINF_SUCCESS;
2961	}
2962
2963
2964	/**
2965	* Worker function that displays one descriptor entry (GDT, LDT, IDT).
2966	*
2967	* @returns pfnPrintf status code.
2968	* @param pCmdHlp The DBGC command helpers.
2969	* @param pDesc The descriptor to display.
2970	* @param iEntry The descriptor entry number.
2971	* @param fHyper Whether the selector belongs to the hypervisor or not.
2972	* @param hAs Address space to use when resolving symbols.
2973	*/
2974	static int dbgcCmdDumpDTWorker32(PDBGCCMDHLP pCmdHlp, PCX86DESC pDesc, unsigned iEntry, bool fHyper, RTDBGAS hAs)
2975	{
2976	int rc;
2977
2978	const char *pszHyper = fHyper ? " HYPER" : "";
2979	const char *pszPresent = pDesc->Gen.u1Present ? "P " : "NP";
2980	if (pDesc->Gen.u1DescType)
2981	{
2982	static const char * const s_apszTypes[] =
2983	{
2984	"DataRO", /* 0 Read-Only */
2985	"DataRO", /* 1 Read-Only - Accessed */
2986	"DataRW", /* 2 Read/Write */
2987	"DataRW", /* 3 Read/Write - Accessed */
2988	"DownRO", /* 4 Expand-down, Read-Only */
2989	"DownRO", /* 5 Expand-down, Read-Only - Accessed */
2990	"DownRW", /* 6 Expand-down, Read/Write */
2991	"DownRW", /* 7 Expand-down, Read/Write - Accessed */
2992	"CodeEO", /* 8 Execute-Only */
2993	"CodeEO", /* 9 Execute-Only - Accessed */
2994	"CodeER", /* A Execute/Readable */
2995	"CodeER", /* B Execute/Readable - Accessed */
2996	"ConfE0", /* C Conforming, Execute-Only */
2997	"ConfE0", /* D Conforming, Execute-Only - Accessed */
2998	"ConfER", /* E Conforming, Execute/Readable */
2999	"ConfER" /* F Conforming, Execute/Readable - Accessed */
3000	};
3001	const char *pszAccessed = pDesc->Gen.u4Type & RT_BIT(0) ? "A " : "NA";
3002	const char *pszGranularity = pDesc->Gen.u1Granularity ? "G" : " ";
3003	const char *pszBig = pDesc->Gen.u1DefBig ? "BIG" : " ";
3004	uint32_t u32Base = pDesc->Gen.u16BaseLow
3005	\| ((uint32_t)pDesc->Gen.u8BaseHigh1 << 16)
3006	\| ((uint32_t)pDesc->Gen.u8BaseHigh2 << 24);
3007	uint32_t cbLimit = pDesc->Gen.u16LimitLow \| (pDesc->Gen.u4LimitHigh << 16);
3008	if (pDesc->Gen.u1Granularity)
3009	cbLimit <<= PAGE_SHIFT;
3010
3011	rc = DBGCCmdHlpPrintf(pCmdHlp, "%04x %s Bas=%08x Lim=%08x DPL=%d %s %s %s %s AVL=%d L=%d%s\n",
3012	iEntry, s_apszTypes[pDesc->Gen.u4Type], u32Base, cbLimit,
3013	pDesc->Gen.u2Dpl, pszPresent, pszAccessed, pszGranularity, pszBig,
3014	pDesc->Gen.u1Available, pDesc->Gen.u1Long, pszHyper);
3015	}
3016	else
3017	{
3018	static const char * const s_apszTypes[] =
3019	{
3020	"Ill-0 ", /* 0 0000 Reserved (Illegal) */
3021	"Tss16A", /* 1 0001 Available 16-bit TSS */
3022	"LDT ", /* 2 0010 LDT */
3023	"Tss16B", /* 3 0011 Busy 16-bit TSS */
3024	"Call16", /* 4 0100 16-bit Call Gate */
3025	"TaskG ", /* 5 0101 Task Gate */
3026	"Int16 ", /* 6 0110 16-bit Interrupt Gate */
3027	"Trap16", /* 7 0111 16-bit Trap Gate */
3028	"Ill-8 ", /* 8 1000 Reserved (Illegal) */
3029	"Tss32A", /* 9 1001 Available 32-bit TSS */
3030	"Ill-A ", /* A 1010 Reserved (Illegal) */
3031	"Tss32B", /* B 1011 Busy 32-bit TSS */
3032	"Call32", /* C 1100 32-bit Call Gate */
3033	"Ill-D ", /* D 1101 Reserved (Illegal) */
3034	"Int32 ", /* E 1110 32-bit Interrupt Gate */
3035	"Trap32" /* F 1111 32-bit Trap Gate */
3036	};
3037	switch (pDesc->Gen.u4Type)
3038	{
3039	/* raw */
3040	case X86_SEL_TYPE_SYS_UNDEFINED:
3041	case X86_SEL_TYPE_SYS_UNDEFINED2:
3042	case X86_SEL_TYPE_SYS_UNDEFINED4:
3043	case X86_SEL_TYPE_SYS_UNDEFINED3:
3044	rc = DBGCCmdHlpPrintf(pCmdHlp, "%04x %s %.8Rhxs DPL=%d %s%s\n",
3045	iEntry, s_apszTypes[pDesc->Gen.u4Type], pDesc,
3046	pDesc->Gen.u2Dpl, pszPresent, pszHyper);
3047	break;
3048
3049	case X86_SEL_TYPE_SYS_286_TSS_AVAIL:
3050	case X86_SEL_TYPE_SYS_386_TSS_AVAIL:
3051	case X86_SEL_TYPE_SYS_286_TSS_BUSY:
3052	case X86_SEL_TYPE_SYS_386_TSS_BUSY:
3053	case X86_SEL_TYPE_SYS_LDT:
3054	{
3055	const char *pszGranularity = pDesc->Gen.u1Granularity ? "G" : " ";
3056	const char *pszBusy = pDesc->Gen.u4Type & RT_BIT(1) ? "B " : "NB";
3057	const char *pszBig = pDesc->Gen.u1DefBig ? "BIG" : " ";
3058	uint32_t u32Base = pDesc->Gen.u16BaseLow
3059	\| ((uint32_t)pDesc->Gen.u8BaseHigh1 << 16)
3060	\| ((uint32_t)pDesc->Gen.u8BaseHigh2 << 24);
3061	uint32_t cbLimit = pDesc->Gen.u16LimitLow \| (pDesc->Gen.u4LimitHigh << 16);
3062	if (pDesc->Gen.u1Granularity)
3063	cbLimit <<= PAGE_SHIFT;
3064
3065	rc = DBGCCmdHlpPrintf(pCmdHlp, "%04x %s Bas=%08x Lim=%08x DPL=%d %s %s %s %s AVL=%d R=%d%s\n",
3066	iEntry, s_apszTypes[pDesc->Gen.u4Type], u32Base, cbLimit,
3067	pDesc->Gen.u2Dpl, pszPresent, pszBusy, pszGranularity, pszBig,
3068	pDesc->Gen.u1Available, pDesc->Gen.u1Long \| (pDesc->Gen.u1DefBig << 1),
3069	pszHyper);
3070	break;
3071	}
3072
3073	case X86_SEL_TYPE_SYS_TASK_GATE:
3074	{
3075	rc = DBGCCmdHlpPrintf(pCmdHlp, "%04x %s TSS=%04x DPL=%d %s%s\n",
3076	iEntry, s_apszTypes[pDesc->Gen.u4Type], pDesc->au16[1],
3077	pDesc->Gen.u2Dpl, pszPresent, pszHyper);
3078	break;
3079	}
3080
3081	case X86_SEL_TYPE_SYS_286_CALL_GATE:
3082	case X86_SEL_TYPE_SYS_386_CALL_GATE:
3083	{
3084	unsigned cParams = pDesc->au8[4] & 0x1f;
3085	const char *pszCountOf = pDesc->Gen.u4Type & RT_BIT(3) ? "DC" : "WC";
3086	RTSEL sel = pDesc->au16[1];
3087	uint32_t off = pDesc->au16[0] \| ((uint32_t)pDesc->au16[3] << 16);
3088	char *pszSymbol = dbgcCmdHlpFarAddrToSymbol(pCmdHlp, hAs, sel, off, " (", ")");
3089	rc = DBGCCmdHlpPrintf(pCmdHlp, "%04x %s Sel:Off=%04x:%08x DPL=%d %s %s=%d%s%s\n",
3090	iEntry, s_apszTypes[pDesc->Gen.u4Type], sel, off,
3091	pDesc->Gen.u2Dpl, pszPresent, pszCountOf, cParams, pszHyper, pszSymbol ? pszSymbol : "");
3092	RTStrFree(pszSymbol);
3093	break;
3094	}
3095
3096	case X86_SEL_TYPE_SYS_286_INT_GATE:
3097	case X86_SEL_TYPE_SYS_386_INT_GATE:
3098	case X86_SEL_TYPE_SYS_286_TRAP_GATE:
3099	case X86_SEL_TYPE_SYS_386_TRAP_GATE:
3100	{
3101	RTSEL sel = pDesc->au16[1];
3102	uint32_t off = pDesc->au16[0] \| ((uint32_t)pDesc->au16[3] << 16);
3103	char *pszSymbol = dbgcCmdHlpFarAddrToSymbol(pCmdHlp, hAs, sel, off, " (", ")");
3104	rc = DBGCCmdHlpPrintf(pCmdHlp, "%04x %s Sel:Off=%04x:%08x DPL=%d %s%s%s\n",
3105	iEntry, s_apszTypes[pDesc->Gen.u4Type], sel, off,
3106	pDesc->Gen.u2Dpl, pszPresent, pszHyper, pszSymbol ? pszSymbol : "");
3107	RTStrFree(pszSymbol);
3108	break;
3109	}
3110
3111	/* impossible, just it's necessary to keep gcc happy. */
3112	default:
3113	return VINF_SUCCESS;
3114	}
3115	}
3116	return rc;
3117	}
3118
3119
3120	/**
3121	* @callback_method_impl{FNDBGCCMD, The 'dg'\, 'dga'\, 'dl' and 'dla' commands.}
3122	*/
3123	static DECLCALLBACK(int) dbgcCmdDumpDT(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
3124	{
3125	/*
3126	* Validate input.
3127	*/
3128	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
3129
3130	/*
3131	* Get the CPU mode, check which command variation this is
3132	* and fix a default parameter if needed.
3133	*/
3134	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
3135	PVMCPU pVCpu = VMMR3GetCpuByIdU(pUVM, pDbgc->idCpu);
3136	CPUMMODE enmMode = CPUMGetGuestMode(pVCpu);
3137	bool fGdt = pCmd->pszCmd[1] == 'g';
3138	bool fAll = pCmd->pszCmd[2] == 'a';
3139	RTSEL SelTable = fGdt ? 0 : X86_SEL_LDT;
3140
3141	DBGCVAR Var;
3142	if (!cArgs)
3143	{
3144	cArgs = 1;
3145	paArgs = &Var;
3146	Var.enmType = DBGCVAR_TYPE_NUMBER;
3147	Var.u.u64Number = fGdt ? 0 : 4;
3148	Var.enmRangeType = DBGCVAR_RANGE_ELEMENTS;
3149	Var.u64Range = 1024;
3150	}
3151
3152	/*
3153	* Process the arguments.
3154	*/
3155	for (unsigned i = 0; i < cArgs; i++)
3156	{
3157	/*
3158	* Retrieve the selector value from the argument.
3159	* The parser may confuse pointers and numbers if more than one
3160	* argument is given, that that into account.
3161	*/
3162	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, i, paArgs[i].enmType == DBGCVAR_TYPE_NUMBER \|\| DBGCVAR_ISPOINTER(paArgs[i].enmType));
3163	uint64_t u64;
3164	unsigned cSels = 1;
3165	switch (paArgs[i].enmType)
3166	{
3167	case DBGCVAR_TYPE_NUMBER:
3168	u64 = paArgs[i].u.u64Number;
3169	if (paArgs[i].enmRangeType != DBGCVAR_RANGE_NONE)
3170	cSels = RT_MIN(paArgs[i].u64Range, 1024);
3171	break;
3172	case DBGCVAR_TYPE_GC_FAR: u64 = paArgs[i].u.GCFar.sel; break;
3173	case DBGCVAR_TYPE_GC_FLAT: u64 = paArgs[i].u.GCFlat; break;
3174	case DBGCVAR_TYPE_GC_PHYS: u64 = paArgs[i].u.GCPhys; break;
3175	case DBGCVAR_TYPE_HC_FLAT: u64 = (uintptr_t)paArgs[i].u.pvHCFlat; break;
3176	case DBGCVAR_TYPE_HC_PHYS: u64 = paArgs[i].u.HCPhys; break;
3177	default: u64 = _64K; break;
3178	}
3179	if (u64 < _64K)
3180	{
3181	unsigned Sel = (RTSEL)u64;
3182
3183	/*
3184	* Dump the specified range.
3185	*/
3186	bool fSingle = cSels == 1;
3187	while ( cSels-- > 0
3188	&& Sel < _64K)
3189	{
3190	DBGFSELINFO SelInfo;
3191	int rc = DBGFR3SelQueryInfo(pUVM, pDbgc->idCpu, Sel \| SelTable, DBGFSELQI_FLAGS_DT_GUEST, &SelInfo);
3192	if (RT_SUCCESS(rc))
3193	{
3194	if (SelInfo.fFlags & DBGFSELINFO_FLAGS_REAL_MODE)
3195	rc = DBGCCmdHlpPrintf(pCmdHlp, "%04x RealM Bas=%04x Lim=%04x\n",
3196	Sel, (unsigned)SelInfo.GCPtrBase, (unsigned)SelInfo.cbLimit);
3197	else if ( fAll
3198	\|\| fSingle
3199	\|\| SelInfo.u.Raw.Gen.u1Present)
3200	{
3201	if (enmMode == CPUMMODE_PROTECTED)
3202	rc = dbgcCmdDumpDTWorker32(pCmdHlp, &SelInfo.u.Raw, Sel,
3203	!!(SelInfo.fFlags & DBGFSELINFO_FLAGS_HYPER), DBGF_AS_GLOBAL);
3204	else
3205	{
3206	bool fDblSkip = false;
3207	rc = dbgcCmdDumpDTWorker64(pCmdHlp, &SelInfo.u.Raw64, Sel,
3208	!!(SelInfo.fFlags & DBGFSELINFO_FLAGS_HYPER), DBGF_AS_GLOBAL, &fDblSkip);
3209	if (fDblSkip)
3210	Sel += 4;
3211	}
3212	}
3213	}
3214	else
3215	{
3216	rc = DBGCCmdHlpPrintf(pCmdHlp, "%04x %Rrc\n", Sel, rc);
3217	if (!fAll)
3218	return rc;
3219	}
3220	if (RT_FAILURE(rc))
3221	return rc;
3222
3223	/* next */
3224	Sel += 8;
3225	}
3226	}
3227	else
3228	DBGCCmdHlpPrintf(pCmdHlp, "error: %llx is out of bounds\n", u64);
3229	}
3230
3231	return VINF_SUCCESS;
3232	}
3233
3234
3235	/**
3236	* @callback_method_impl{FNDBGCCMD, The 'di' and 'dia' commands.}
3237	*/
3238	static DECLCALLBACK(int) dbgcCmdDumpIDT(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
3239	{
3240	/*
3241	* Validate input.
3242	*/
3243	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
3244
3245	/*
3246	* Establish some stuff like the current IDTR and CPU mode,
3247	* and fix a default parameter.
3248	*/
3249	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
3250	CPUMMODE enmMode = DBGCCmdHlpGetCpuMode(pCmdHlp);
3251	uint16_t cbLimit = 0;
3252	uint64_t GCFlat = 0;
3253	int rc = DBGFR3RegCpuQueryXdtr(pDbgc->pUVM, pDbgc->idCpu, DBGFREG_IDTR, &GCFlat, &cbLimit);
3254	if (RT_FAILURE(rc))
3255	return DBGCCmdHlpFailRc(pCmdHlp, pCmd, rc, "DBGFR3RegCpuQueryXdtr/DBGFREG_IDTR");
3256	unsigned cbEntry;
3257	switch (enmMode)
3258	{
3259	case CPUMMODE_REAL: cbEntry = sizeof(RTFAR16); break;
3260	case CPUMMODE_PROTECTED: cbEntry = sizeof(X86DESC); break;
3261	case CPUMMODE_LONG: cbEntry = sizeof(X86DESC64); break;
3262	default:
3263	return DBGCCmdHlpPrintf(pCmdHlp, "error: Invalid CPU mode %d.\n", enmMode);
3264	}
3265
3266	bool fAll = pCmd->pszCmd[2] == 'a';
3267	DBGCVAR Var;
3268	if (!cArgs)
3269	{
3270	cArgs = 1;
3271	paArgs = &Var;
3272	Var.enmType = DBGCVAR_TYPE_NUMBER;
3273	Var.u.u64Number = 0;
3274	Var.enmRangeType = DBGCVAR_RANGE_ELEMENTS;
3275	Var.u64Range = 256;
3276	}
3277
3278	/*
3279	* Process the arguments.
3280	*/
3281	for (unsigned i = 0; i < cArgs; i++)
3282	{
3283	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, i, paArgs[i].enmType == DBGCVAR_TYPE_NUMBER);
3284	if (paArgs[i].u.u64Number < 256)
3285	{
3286	RTGCUINTPTR iInt = (RTGCUINTPTR)paArgs[i].u.u64Number;
3287	unsigned cInts = paArgs[i].enmRangeType != DBGCVAR_RANGE_NONE
3288	? paArgs[i].u64Range
3289	: 1;
3290	bool fSingle = cInts == 1;
3291	while ( cInts-- > 0
3292	&& iInt < 256)
3293	{
3294	/*
3295	* Try read it.
3296	*/
3297	union
3298	{
3299	RTFAR16 Real;
3300	X86DESC Prot;
3301	X86DESC64 Long;
3302	} u;
3303	if (iInt * cbEntry + (cbEntry - 1) > cbLimit)
3304	{
3305	DBGCCmdHlpPrintf(pCmdHlp, "%04x not within the IDT\n", (unsigned)iInt);
3306	if (!fAll && !fSingle)
3307	return VINF_SUCCESS;
3308	}
3309	DBGCVAR AddrVar;
3310	AddrVar.enmType = DBGCVAR_TYPE_GC_FLAT;
3311	AddrVar.u.GCFlat = GCFlat + iInt * cbEntry;
3312	AddrVar.enmRangeType = DBGCVAR_RANGE_NONE;
3313	rc = pCmdHlp->pfnMemRead(pCmdHlp, &u, cbEntry, &AddrVar, NULL);
3314	if (RT_FAILURE(rc))
3315	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Reading IDT entry %#04x.\n", (unsigned)iInt);
3316
3317	/*
3318	* Display it.
3319	*/
3320	switch (enmMode)
3321	{
3322	case CPUMMODE_REAL:
3323	{
3324	char *pszSymbol = dbgcCmdHlpFarAddrToSymbol(pCmdHlp, DBGF_AS_GLOBAL, u.Real.sel, u.Real.off, " (", ")");
3325	rc = DBGCCmdHlpPrintf(pCmdHlp, "%04x %RTfp16%s\n", (unsigned)iInt, u.Real, pszSymbol ? pszSymbol : "");
3326	RTStrFree(pszSymbol);
3327	break;
3328	}
3329	case CPUMMODE_PROTECTED:
3330	if (fAll \|\| fSingle \|\| u.Prot.Gen.u1Present)
3331	rc = dbgcCmdDumpDTWorker32(pCmdHlp, &u.Prot, iInt, false, DBGF_AS_GLOBAL);
3332	break;
3333	case CPUMMODE_LONG:
3334	if (fAll \|\| fSingle \|\| u.Long.Gen.u1Present)
3335	rc = dbgcCmdDumpDTWorker64(pCmdHlp, &u.Long, iInt, false, DBGF_AS_GLOBAL, NULL);
3336	break;
3337	default: break; /* to shut up gcc */
3338	}
3339	if (RT_FAILURE(rc))
3340	return rc;
3341
3342	/* next */
3343	iInt++;
3344	}
3345	}
3346	else
3347	DBGCCmdHlpPrintf(pCmdHlp, "error: %llx is out of bounds (max 256)\n", paArgs[i].u.u64Number);
3348	}
3349
3350	return VINF_SUCCESS;
3351	}
3352
3353
3354	/**
3355	* @callback_method_impl{FNDBGCCMD,
3356	* The 'da'\, 'dq'\, 'dqs'\, 'dd'\, 'dds'\, 'dw'\, 'db'\, 'dp'\, 'dps'\,
3357	* and 'du' commands.}
3358	*/
3359	static DECLCALLBACK(int) dbgcCmdDumpMem(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
3360	{
3361	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
3362
3363	/*
3364	* Validate input.
3365	*/
3366	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, cArgs <= 1);
3367	if (cArgs == 1)
3368	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, DBGCVAR_ISPOINTER(paArgs[0].enmType));
3369	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
3370
3371	#define DBGC_DUMP_MEM_F_ASCII RT_BIT_32(31)
3372	#define DBGC_DUMP_MEM_F_UNICODE RT_BIT_32(30)
3373	#define DBGC_DUMP_MEM_F_FAR RT_BIT_32(29)
3374	#define DBGC_DUMP_MEM_F_SYMBOLS RT_BIT_32(28)
3375	#define DBGC_DUMP_MEM_F_SIZE UINT32_C(0x0000ffff)
3376
3377	/*
3378	* Figure out the element size.
3379	*/
3380	unsigned cbElement;
3381	bool fAscii = false;
3382	bool fUnicode = false;
3383	bool fFar = false;
3384	bool fSymbols = pCmd->pszCmd[1] && pCmd->pszCmd[2] == 's';
3385	switch (pCmd->pszCmd[1])
3386	{
3387	default:
3388	case 'b': cbElement = 1; break;
3389	case 'w': cbElement = 2; break;
3390	case 'd': cbElement = 4; break;
3391	case 'q': cbElement = 8; break;
3392	case 'a':
3393	cbElement = 1;
3394	fAscii = true;
3395	break;
3396	case 'F':
3397	cbElement = 4;
3398	fFar = true;
3399	break;
3400	case 'p':
3401	cbElement = DBGFR3CpuIsIn64BitCode(pUVM, pDbgc->idCpu) ? 8 : 4;
3402	break;
3403	case 'u':
3404	cbElement = 2;
3405	fUnicode = true;
3406	break;
3407	case '\0':
3408	fAscii = RT_BOOL(pDbgc->cbDumpElement & DBGC_DUMP_MEM_F_ASCII);
3409	fSymbols = RT_BOOL(pDbgc->cbDumpElement & DBGC_DUMP_MEM_F_SYMBOLS);
3410	fUnicode = RT_BOOL(pDbgc->cbDumpElement & DBGC_DUMP_MEM_F_UNICODE);
3411	fFar = RT_BOOL(pDbgc->cbDumpElement & DBGC_DUMP_MEM_F_FAR);
3412	cbElement = pDbgc->cbDumpElement & DBGC_DUMP_MEM_F_SIZE;
3413	if (!cbElement)
3414	cbElement = 1;
3415	break;
3416	}
3417	uint32_t const cbDumpElement = cbElement
3418	\| (fSymbols ? DBGC_DUMP_MEM_F_SYMBOLS : 0)
3419	\| (fFar ? DBGC_DUMP_MEM_F_FAR : 0)
3420	\| (fUnicode ? DBGC_DUMP_MEM_F_UNICODE : 0)
3421	\| (fAscii ? DBGC_DUMP_MEM_F_ASCII : 0);
3422	pDbgc->cbDumpElement = cbDumpElement;
3423
3424	/*
3425	* Find address.
3426	*/
3427	if (!cArgs)
3428	pDbgc->DumpPos.enmRangeType = DBGCVAR_RANGE_NONE;
3429	else
3430	pDbgc->DumpPos = paArgs[0];
3431
3432	/*
3433	* Range.
3434	*/
3435	switch (pDbgc->DumpPos.enmRangeType)
3436	{
3437	case DBGCVAR_RANGE_NONE:
3438	pDbgc->DumpPos.enmRangeType = DBGCVAR_RANGE_BYTES;
3439	pDbgc->DumpPos.u64Range = 0x60;
3440	break;
3441
3442	case DBGCVAR_RANGE_ELEMENTS:
3443	if (pDbgc->DumpPos.u64Range > 2048)
3444	return DBGCCmdHlpPrintf(pCmdHlp, "error: Too many elements requested. Max is 2048 elements.\n");
3445	pDbgc->DumpPos.enmRangeType = DBGCVAR_RANGE_BYTES;
3446	pDbgc->DumpPos.u64Range = (cbElement ? cbElement : 1) * pDbgc->DumpPos.u64Range;
3447	break;
3448
3449	case DBGCVAR_RANGE_BYTES:
3450	if (pDbgc->DumpPos.u64Range > 65536)
3451	return DBGCCmdHlpPrintf(pCmdHlp, "error: The requested range is too big. Max is 64KB.\n");
3452	break;
3453
3454	default:
3455	return DBGCCmdHlpPrintf(pCmdHlp, "internal error: Unknown range type %d.\n", pDbgc->DumpPos.enmRangeType);
3456	}
3457
3458	pDbgc->pLastPos = &pDbgc->DumpPos;
3459
3460	/*
3461	* Do the dumping.
3462	*/
3463	int cbLeft = (int)pDbgc->DumpPos.u64Range;
3464	uint8_t u16Prev = '\0';
3465	for (;;)
3466	{
3467	/*
3468	* Read memory.
3469	*/
3470	char achBuffer[16];
3471	size_t cbReq = RT_MIN((int)sizeof(achBuffer), cbLeft);
3472	size_t cb = RT_MIN((int)sizeof(achBuffer), cbLeft);
3473	int rc = pCmdHlp->pfnMemRead(pCmdHlp, &achBuffer, cbReq, &pDbgc->DumpPos, &cb);
3474	if (RT_FAILURE(rc))
3475	{
3476	if (u16Prev && u16Prev != '\n')
3477	DBGCCmdHlpPrintf(pCmdHlp, "\n");
3478	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Reading memory at %DV.\n", &pDbgc->DumpPos);
3479	}
3480
3481	/*
3482	* Display it.
3483	*/
3484	memset(&achBuffer[cb], 0, sizeof(achBuffer) - cb);
3485	if (!fAscii && !fUnicode)
3486	{
3487	DBGCCmdHlpPrintf(pCmdHlp, "%DV:", &pDbgc->DumpPos);
3488	unsigned i;
3489	for (i = 0; i < cb; i += cbElement)
3490	{
3491	const char *pszSpace = " ";
3492	if (cbElement <= 2 && i == 8)
3493	pszSpace = "-";
3494	switch (cbElement)
3495	{
3496	case 1:
3497	DBGCCmdHlpPrintf(pCmdHlp, "%s%02x", pszSpace, (uint8_t )&achBuffer[i]);
3498	break;
3499	case 2:
3500	DBGCCmdHlpPrintf(pCmdHlp, "%s%04x", pszSpace, (uint16_t )&achBuffer[i]);
3501	break;
3502	case 4:
3503	if (!fFar)
3504	DBGCCmdHlpPrintf(pCmdHlp, "%s%08x", pszSpace, (uint32_t )&achBuffer[i]);
3505	else
3506	DBGCCmdHlpPrintf(pCmdHlp, "%s%04x:%04x:",
3507	pszSpace, (uint16_t )&achBuffer[i + 2], (uint16_t )&achBuffer[i]);
3508	break;
3509	case 8:
3510	DBGCCmdHlpPrintf(pCmdHlp, "%s%016llx", pszSpace, (uint64_t )&achBuffer[i]);
3511	break;
3512	}
3513
3514	if (fSymbols)
3515	{
3516	/* Try lookup symbol for the above address. */
3517	DBGFADDRESS Addr;
3518	rc = VINF_SUCCESS;
3519	if (cbElement == 8)
3520	DBGFR3AddrFromFlat(pDbgc->pUVM, &Addr, (uint64_t )&achBuffer[i]);
3521	else if (!fFar)
3522	DBGFR3AddrFromFlat(pDbgc->pUVM, &Addr, (uint32_t )&achBuffer[i]);
3523	else
3524	rc = DBGFR3AddrFromSelOff(pDbgc->pUVM, pDbgc->idCpu, &Addr,
3525	(uint16_t )&achBuffer[i + 2], (uint16_t )&achBuffer[i]);
3526	if (RT_SUCCESS(rc))
3527	{
3528	RTINTPTR offDisp;
3529	RTDBGSYMBOL Symbol;
3530	rc = DBGFR3AsSymbolByAddr(pUVM, pDbgc->hDbgAs, &Addr,
3531	RTDBGSYMADDR_FLAGS_LESS_OR_EQUAL \| RTDBGSYMADDR_FLAGS_SKIP_ABS_IN_DEFERRED,
3532	&offDisp, &Symbol, NULL);
3533	if (RT_SUCCESS(rc))
3534	{
3535	if (!offDisp)
3536	rc = DBGCCmdHlpPrintf(pCmdHlp, " %s", Symbol.szName);
3537	else if (offDisp > 0)
3538	rc = DBGCCmdHlpPrintf(pCmdHlp, " %s + %RGv", Symbol.szName, offDisp);
3539	else
3540	rc = DBGCCmdHlpPrintf(pCmdHlp, " %s - %RGv", Symbol.szName, -offDisp);
3541	if (Symbol.cb > 0)
3542	rc = DBGCCmdHlpPrintf(pCmdHlp, " (LB %RGv)", Symbol.cb);
3543	}
3544	}
3545
3546	/* Next line prefix. */
3547	unsigned iNext = i + cbElement;
3548	if (iNext < cb)
3549	{
3550	DBGCVAR TmpPos = pDbgc->DumpPos;
3551	DBGCCmdHlpEval(pCmdHlp, &TmpPos, "(%Dv) + %x", &pDbgc->DumpPos, iNext);
3552	DBGCCmdHlpPrintf(pCmdHlp, "\n%DV:", &pDbgc->DumpPos);
3553	}
3554	}
3555	}
3556
3557	/* Chars column. */
3558	if (cbElement == 1)
3559	{
3560	while (i++ < sizeof(achBuffer))
3561	DBGCCmdHlpPrintf(pCmdHlp, " ");
3562	DBGCCmdHlpPrintf(pCmdHlp, " ");
3563	for (i = 0; i < cb; i += cbElement)
3564	{
3565	uint8_t u8 = (uint8_t )&achBuffer[i];
3566	if (RT_C_IS_PRINT(u8) && u8 < 127 && u8 >= 32)
3567	DBGCCmdHlpPrintf(pCmdHlp, "%c", u8);
3568	else
3569	DBGCCmdHlpPrintf(pCmdHlp, ".");
3570	}
3571	}
3572	rc = DBGCCmdHlpPrintf(pCmdHlp, "\n");
3573	}
3574	else
3575	{
3576	/*
3577	* We print up to the first zero and stop there.
3578	* Only printables + '\t' and '\n' are printed.
3579	*/
3580	if (!u16Prev)
3581	DBGCCmdHlpPrintf(pCmdHlp, "%DV:\n", &pDbgc->DumpPos);
3582	uint16_t u16 = '\0';
3583	unsigned i;
3584	for (i = 0; i < cb; i += cbElement)
3585	{
3586	u16Prev = u16;
3587	if (cbElement == 1)
3588	u16 = (uint8_t )&achBuffer[i];
3589	else
3590	u16 = (uint16_t )&achBuffer[i];
3591	if ( u16 < 127
3592	&& ( (RT_C_IS_PRINT(u16) && u16 >= 32)
3593	\|\| u16 == '\t'
3594	\|\| u16 == '\n'))
3595	DBGCCmdHlpPrintf(pCmdHlp, "%c", (int)u16);
3596	else if (!u16)
3597	break;
3598	else
3599	DBGCCmdHlpPrintf(pCmdHlp, "\\x%0x", cbElement 2, u16);
3600	}
3601	if (u16 == '\0')
3602	cb = cbLeft = i + 1;
3603	if (cbLeft - cb <= 0 && u16Prev != '\n')
3604	DBGCCmdHlpPrintf(pCmdHlp, "\n");
3605	}
3606
3607	/*
3608	* Advance
3609	*/
3610	cbLeft -= (int)cb;
3611	rc = DBGCCmdHlpEval(pCmdHlp, &pDbgc->DumpPos, "(%Dv) + %x", &pDbgc->DumpPos, cb);
3612	if (RT_FAILURE(rc))
3613	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Expression: (%Dv) + %x\n", &pDbgc->DumpPos, cb);
3614	if (cbLeft <= 0)
3615	break;
3616	}
3617
3618	NOREF(pCmd);
3619	return VINF_SUCCESS;
3620	}
3621
3622
3623	/**
3624	* Best guess at which paging mode currently applies to the guest
3625	* paging structures.
3626	*
3627	* This have to come up with a decent answer even when the guest
3628	* is in non-paged protected mode or real mode.
3629	*
3630	* @returns cr3.
3631	* @param pDbgc The DBGC instance.
3632	* @param pfPAE Where to store the page address extension indicator.
3633	* @param pfLME Where to store the long mode enabled indicator.
3634	* @param pfPSE Where to store the page size extension indicator.
3635	* @param pfPGE Where to store the page global enabled indicator.
3636	* @param pfNXE Where to store the no-execution enabled indicator.
3637	*/
3638	static RTGCPHYS dbgcGetGuestPageMode(PDBGC pDbgc, bool pfPAE, bool pfLME, bool pfPSE, bool pfPGE, bool *pfNXE)
3639	{
3640	PVMCPU pVCpu = VMMR3GetCpuByIdU(pDbgc->pUVM, pDbgc->idCpu);
3641	RTGCUINTREG cr4 = CPUMGetGuestCR4(pVCpu);
3642	*pfPSE = !!(cr4 & X86_CR4_PSE);
3643	*pfPGE = !!(cr4 & X86_CR4_PGE);
3644	if (cr4 & X86_CR4_PAE)
3645	{
3646	*pfPSE = true;
3647	*pfPAE = true;
3648	}
3649	else
3650	*pfPAE = false;
3651
3652	*pfLME = CPUMGetGuestMode(pVCpu) == CPUMMODE_LONG;
3653	pfNXE = false; / GUEST64 GUESTNX */
3654	return CPUMGetGuestCR3(pVCpu);
3655	}
3656
3657
3658	/**
3659	* Determine the shadow paging mode.
3660	*
3661	* @returns cr3.
3662	* @param pDbgc The DBGC instance.
3663	* @param pfPAE Where to store the page address extension indicator.
3664	* @param pfLME Where to store the long mode enabled indicator.
3665	* @param pfPSE Where to store the page size extension indicator.
3666	* @param pfPGE Where to store the page global enabled indicator.
3667	* @param pfNXE Where to store the no-execution enabled indicator.
3668	*/
3669	static RTHCPHYS dbgcGetShadowPageMode(PDBGC pDbgc, bool pfPAE, bool pfLME, bool pfPSE, bool pfPGE, bool *pfNXE)
3670	{
3671	PVMCPU pVCpu = VMMR3GetCpuByIdU(pDbgc->pUVM, pDbgc->idCpu);
3672
3673	*pfPSE = true;
3674	*pfPGE = false;
3675	switch (PGMGetShadowMode(pVCpu))
3676	{
3677	default:
3678	case PGMMODE_32_BIT:
3679	pfPAE = pfLME = *pfNXE = false;
3680	break;
3681	case PGMMODE_PAE:
3682	pfLME = pfNXE = false;
3683	*pfPAE = true;
3684	break;
3685	case PGMMODE_PAE_NX:
3686	*pfLME = false;
3687	pfPAE = pfNXE = true;
3688	break;
3689	case PGMMODE_AMD64:
3690	*pfNXE = false;
3691	pfPAE = pfLME = true;
3692	break;
3693	case PGMMODE_AMD64_NX:
3694	pfPAE = pfLME = *pfNXE = true;
3695	break;
3696	}
3697	return PGMGetHyperCR3(pVCpu);
3698	}
3699
3700
3701	/**
3702	* @callback_method_impl{FNDBGCCMD,
3703	* The 'dpd'\, 'dpda'\, 'dpdb'\, 'dpdg' and 'dpdh' commands.}
3704	*/
3705	static DECLCALLBACK(int) dbgcCmdDumpPageDir(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
3706	{
3707	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
3708
3709	/*
3710	* Validate input.
3711	*/
3712	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, cArgs <= 1);
3713	if (cArgs == 1 && pCmd->pszCmd[3] == 'a')
3714	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, DBGCVAR_ISPOINTER(paArgs[0].enmType));
3715	if (cArgs == 1 && pCmd->pszCmd[3] != 'a')
3716	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, paArgs[0].enmType == DBGCVAR_TYPE_NUMBER
3717	\|\| DBGCVAR_ISPOINTER(paArgs[0].enmType));
3718	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
3719
3720	/*
3721	* Guest or shadow page directories? Get the paging parameters.
3722	*/
3723	bool fGuest = pCmd->pszCmd[3] != 'h';
3724	if (!pCmd->pszCmd[3] \|\| pCmd->pszCmd[3] == 'a')
3725	fGuest = paArgs[0].enmType == DBGCVAR_TYPE_NUMBER ? true : DBGCVAR_ISGCPOINTER(paArgs[0].enmType);
3726
3727	bool fPAE, fLME, fPSE, fPGE, fNXE;
3728	uint64_t cr3 = fGuest
3729	? dbgcGetGuestPageMode(pDbgc, &fPAE, &fLME, &fPSE, &fPGE, &fNXE)
3730	: dbgcGetShadowPageMode(pDbgc, &fPAE, &fLME, &fPSE, &fPGE, &fNXE);
3731	const unsigned cbEntry = fPAE ? sizeof(X86PTEPAE) : sizeof(X86PTE);
3732
3733	/*
3734	* Setup default argument if none was specified.
3735	* Fix address / index confusion.
3736	*/
3737	DBGCVAR VarDefault;
3738	if (!cArgs)
3739	{
3740	if (pCmd->pszCmd[3] == 'a')
3741	{
3742	if (fLME \|\| fPAE)
3743	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");
3744	if (fGuest)
3745	DBGCVAR_INIT_GC_PHYS(&VarDefault, cr3);
3746	else
3747	DBGCVAR_INIT_HC_PHYS(&VarDefault, cr3);
3748	}
3749	else
3750	DBGCVAR_INIT_GC_FLAT(&VarDefault, 0);
3751	paArgs = &VarDefault;
3752	cArgs = 1;
3753	}
3754	else if (paArgs[0].enmType == DBGCVAR_TYPE_NUMBER)
3755	{
3756	/* If it's a number (not an address), it's an index, so convert it to an address. */
3757	Assert(pCmd->pszCmd[3] != 'a');
3758	VarDefault = paArgs[0];
3759	if (fPAE)
3760	return DBGCCmdHlpPrintf(pCmdHlp, "PDE indexing is only implemented for 32-bit paging.\n");
3761	if (VarDefault.u.u64Number >= PAGE_SIZE / cbEntry)
3762	return DBGCCmdHlpPrintf(pCmdHlp, "PDE index is out of range [0..%d].\n", PAGE_SIZE / cbEntry - 1);
3763	VarDefault.u.u64Number <<= X86_PD_SHIFT;
3764	VarDefault.enmType = DBGCVAR_TYPE_GC_FLAT;
3765	paArgs = &VarDefault;
3766	}
3767
3768	/*
3769	* Locate the PDE to start displaying at.
3770	*
3771	* The 'dpda' command takes the address of a PDE, while the others are guest
3772	* virtual address which PDEs should be displayed. So, 'dpda' is rather simple
3773	* while the others require us to do all the tedious walking thru the paging
3774	* hierarchy to find the intended PDE.
3775	*/
3776	unsigned iEntry = ~0U; /* The page directory index. ~0U for 'dpta'. */
3777	DBGCVAR VarGCPtr = { NULL, }; /* The GC address corresponding to the current PDE (iEntry != ~0U). */
3778	DBGCVAR VarPDEAddr; /* The address of the current PDE. */
3779	unsigned cEntries; /* The number of entries to display. */
3780	unsigned cEntriesMax; /* The max number of entries to display. */
3781	int rc;
3782	if (pCmd->pszCmd[3] == 'a')
3783	{
3784	VarPDEAddr = paArgs[0];
3785	switch (VarPDEAddr.enmRangeType)
3786	{
3787	case DBGCVAR_RANGE_BYTES: cEntries = VarPDEAddr.u64Range / cbEntry; break;
3788	case DBGCVAR_RANGE_ELEMENTS: cEntries = VarPDEAddr.u64Range; break;
3789	default: cEntries = 10; break;
3790	}
3791	cEntriesMax = PAGE_SIZE / cbEntry;
3792	}
3793	else
3794	{
3795	/*
3796	* Determine the range.
3797	*/
3798	switch (paArgs[0].enmRangeType)
3799	{
3800	case DBGCVAR_RANGE_BYTES: cEntries = paArgs[0].u64Range / PAGE_SIZE; break;
3801	case DBGCVAR_RANGE_ELEMENTS: cEntries = paArgs[0].u64Range; break;
3802	default: cEntries = 10; break;
3803	}
3804
3805	/*
3806	* Normalize the input address, it must be a flat GC address.
3807	*/
3808	rc = DBGCCmdHlpEval(pCmdHlp, &VarGCPtr, "%%(%Dv)", &paArgs[0]);
3809	if (RT_FAILURE(rc))
3810	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "%%(%Dv)", &paArgs[0]);
3811	if (VarGCPtr.enmType == DBGCVAR_TYPE_HC_FLAT)
3812	{
3813	VarGCPtr.u.GCFlat = (uintptr_t)VarGCPtr.u.pvHCFlat;
3814	VarGCPtr.enmType = DBGCVAR_TYPE_GC_FLAT;
3815	}
3816	if (fPAE)
3817	VarGCPtr.u.GCFlat &= ~(((RTGCPTR)1 << X86_PD_PAE_SHIFT) - 1);
3818	else
3819	VarGCPtr.u.GCFlat &= ~(((RTGCPTR)1 << X86_PD_SHIFT) - 1);
3820
3821	/*
3822	* Do the paging walk until we get to the page directory.
3823	*/
3824	DBGCVAR VarCur;
3825	if (fGuest)
3826	DBGCVAR_INIT_GC_PHYS(&VarCur, cr3);
3827	else
3828	DBGCVAR_INIT_HC_PHYS(&VarCur, cr3);
3829	if (fLME)
3830	{
3831	/* Page Map Level 4 Lookup. */
3832	/* Check if it's a valid address first? */
3833	VarCur.u.u64Number &= X86_PTE_PAE_PG_MASK;
3834	VarCur.u.u64Number += (((uint64_t)VarGCPtr.u.GCFlat >> X86_PML4_SHIFT) & X86_PML4_MASK) * sizeof(X86PML4E);
3835	X86PML4E Pml4e;
3836	rc = pCmdHlp->pfnMemRead(pCmdHlp, &Pml4e, sizeof(Pml4e), &VarCur, NULL);
3837	if (RT_FAILURE(rc))
3838	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "Reading PML4E memory at %DV.\n", &VarCur);
3839	if (!Pml4e.n.u1Present)
3840	return DBGCCmdHlpPrintf(pCmdHlp, "Page directory pointer table is not present for %Dv.\n", &VarGCPtr);
3841
3842	VarCur.u.u64Number = Pml4e.u & X86_PML4E_PG_MASK;
3843	Assert(fPAE);
3844	}
3845	if (fPAE)
3846	{
3847	/* Page directory pointer table. */
3848	X86PDPE Pdpe;
3849	VarCur.u.u64Number += ((VarGCPtr.u.GCFlat >> X86_PDPT_SHIFT) & X86_PDPT_MASK_PAE) * sizeof(Pdpe);
3850	rc = pCmdHlp->pfnMemRead(pCmdHlp, &Pdpe, sizeof(Pdpe), &VarCur, NULL);
3851	if (RT_FAILURE(rc))
3852	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "Reading PDPE memory at %DV.\n", &VarCur);
3853	if (!Pdpe.n.u1Present)
3854	return DBGCCmdHlpPrintf(pCmdHlp, "Page directory is not present for %Dv.\n", &VarGCPtr);
3855
3856	iEntry = (VarGCPtr.u.GCFlat >> X86_PD_PAE_SHIFT) & X86_PD_PAE_MASK;
3857	VarPDEAddr = VarCur;
3858	VarPDEAddr.u.u64Number = Pdpe.u & X86_PDPE_PG_MASK;
3859	VarPDEAddr.u.u64Number += iEntry * sizeof(X86PDEPAE);
3860	}
3861	else
3862	{
3863	/* 32-bit legacy - CR3 == page directory. */
3864	iEntry = (VarGCPtr.u.GCFlat >> X86_PD_SHIFT) & X86_PD_MASK;
3865	VarPDEAddr = VarCur;
3866	VarPDEAddr.u.u64Number += iEntry * sizeof(X86PDE);
3867	}
3868	cEntriesMax = (PAGE_SIZE - iEntry) / cbEntry;
3869	}
3870
3871	/* adjust cEntries */
3872	cEntries = RT_MAX(1, cEntries);
3873	cEntries = RT_MIN(cEntries, cEntriesMax);
3874
3875	/*
3876	* The display loop.
3877	*/
3878	DBGCCmdHlpPrintf(pCmdHlp, iEntry != ~0U ? "%DV (index %#x):\n" : "%DV:\n",
3879	&VarPDEAddr, iEntry);
3880	do
3881	{
3882	/*
3883	* Read.
3884	*/
3885	X86PDEPAE Pde;
3886	Pde.u = 0;
3887	rc = pCmdHlp->pfnMemRead(pCmdHlp, &Pde, cbEntry, &VarPDEAddr, NULL);
3888	if (RT_FAILURE(rc))
3889	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Reading PDE memory at %DV.\n", &VarPDEAddr);
3890
3891	/*
3892	* Display.
3893	*/
3894	if (iEntry != ~0U)
3895	{
3896	DBGCCmdHlpPrintf(pCmdHlp, "%03x %DV: ", iEntry, &VarGCPtr);
3897	iEntry++;
3898	}
3899	if (fPSE && Pde.b.u1Size)
3900	DBGCCmdHlpPrintf(pCmdHlp,
3901	fPAE
3902	? "%016llx big phys=%016llx %s %s %s %s %s avl=%02x %s %s %s %s %s"
3903	: "%08llx big phys=%08llx %s %s %s %s %s avl=%02x %s %s %s %s %s",
3904	Pde.u,
3905	Pde.u & X86_PDE_PAE_PG_MASK,
3906	Pde.b.u1Present ? "p " : "np",
3907	Pde.b.u1Write ? "w" : "r",
3908	Pde.b.u1User ? "u" : "s",
3909	Pde.b.u1Accessed ? "a " : "na",
3910	Pde.b.u1Dirty ? "d " : "nd",
3911	Pde.b.u3Available,
3912	Pde.b.u1Global ? (fPGE ? "g" : "G") : " ",
3913	Pde.b.u1WriteThru ? "pwt" : " ",
3914	Pde.b.u1CacheDisable ? "pcd" : " ",
3915	Pde.b.u1PAT ? "pat" : "",
3916	Pde.b.u1NoExecute ? (fNXE ? "nx" : "NX") : " ");
3917	else
3918	DBGCCmdHlpPrintf(pCmdHlp,
3919	fPAE
3920	? "%016llx 4kb phys=%016llx %s %s %s %s %s avl=%02x %s %s %s %s"
3921	: "%08llx 4kb phys=%08llx %s %s %s %s %s avl=%02x %s %s %s %s",
3922	Pde.u,
3923	Pde.u & X86_PDE_PAE_PG_MASK,
3924	Pde.n.u1Present ? "p " : "np",
3925	Pde.n.u1Write ? "w" : "r",
3926	Pde.n.u1User ? "u" : "s",
3927	Pde.n.u1Accessed ? "a " : "na",
3928	Pde.u & RT_BIT(6) ? "6 " : " ",
3929	Pde.n.u3Available,
3930	Pde.u & RT_BIT(8) ? "8" : " ",
3931	Pde.n.u1WriteThru ? "pwt" : " ",
3932	Pde.n.u1CacheDisable ? "pcd" : " ",
3933	Pde.u & RT_BIT(7) ? "7" : "",
3934	Pde.n.u1NoExecute ? (fNXE ? "nx" : "NX") : " ");
3935	if (Pde.u & UINT64_C(0x7fff000000000000))
3936	DBGCCmdHlpPrintf(pCmdHlp, " weird=%RX64", (Pde.u & UINT64_C(0x7fff000000000000)));
3937	rc = DBGCCmdHlpPrintf(pCmdHlp, "\n");
3938	if (RT_FAILURE(rc))
3939	return rc;
3940
3941	/*
3942	* Advance.
3943	*/
3944	VarPDEAddr.u.u64Number += cbEntry;
3945	if (iEntry != ~0U)
3946	VarGCPtr.u.GCFlat += fPAE ? RT_BIT_32(X86_PD_PAE_SHIFT) : RT_BIT_32(X86_PD_SHIFT);
3947	} while (cEntries-- > 0);
3948
3949	return VINF_SUCCESS;
3950	}
3951
3952
3953	/**
3954	* @callback_method_impl{FNDBGCCMD, The 'dpdb' command.}
3955	*/
3956	static DECLCALLBACK(int) dbgcCmdDumpPageDirBoth(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
3957	{
3958	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
3959	int rc1 = pCmdHlp->pfnExec(pCmdHlp, "dpdg %DV", &paArgs[0]);
3960	int rc2 = pCmdHlp->pfnExec(pCmdHlp, "dpdh %DV", &paArgs[0]);
3961	if (RT_FAILURE(rc1))
3962	return rc1;
3963	NOREF(pCmd); NOREF(paArgs); NOREF(cArgs);
3964	return rc2;
3965	}
3966
3967
3968	/**
3969	* @callback_method_impl{FNDBGCCMD, The 'dph*' commands and main part of 'm'.}
3970	*/
3971	static DECLCALLBACK(int) dbgcCmdDumpPageHierarchy(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
3972	{
3973	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
3974	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
3975
3976	/*
3977	* Figure the context and base flags.
3978	*/
3979	uint32_t fFlags = DBGFPGDMP_FLAGS_PAGE_INFO \| DBGFPGDMP_FLAGS_PRINT_CR3;
3980	if (pCmd->pszCmd[0] == 'm')
3981	fFlags \|= DBGFPGDMP_FLAGS_GUEST \| DBGFPGDMP_FLAGS_SHADOW;
3982	else if (pCmd->pszCmd[3] == '\0')
3983	fFlags \|= DBGFPGDMP_FLAGS_GUEST;
3984	else if (pCmd->pszCmd[3] == 'g')
3985	fFlags \|= DBGFPGDMP_FLAGS_GUEST;
3986	else if (pCmd->pszCmd[3] == 'h')
3987	fFlags \|= DBGFPGDMP_FLAGS_SHADOW;
3988	else
3989	AssertFailed();
3990
3991	if (pDbgc->cPagingHierarchyDumps == 0)
3992	fFlags \|= DBGFPGDMP_FLAGS_HEADER;
3993	pDbgc->cPagingHierarchyDumps = (pDbgc->cPagingHierarchyDumps + 1) % 42;
3994
3995	/*
3996	* Get the range.
3997	*/
3998	PCDBGCVAR pRange = cArgs > 0 ? &paArgs[0] : pDbgc->pLastPos;
3999	RTGCPTR GCPtrFirst = NIL_RTGCPTR;
4000	int rc = DBGCCmdHlpVarToFlatAddr(pCmdHlp, pRange, &GCPtrFirst);
4001	if (RT_FAILURE(rc))
4002	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Failed to convert %DV to a flat address: %Rrc", pRange, rc);
4003
4004	uint64_t cbRange;
4005	rc = DBGCCmdHlpVarGetRange(pCmdHlp, pRange, PAGE_SIZE, PAGE_SIZE * 8, &cbRange);
4006	if (RT_FAILURE(rc))
4007	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Failed to obtain the range of %DV: %Rrc", pRange, rc);
4008
4009	RTGCPTR GCPtrLast = RTGCPTR_MAX - GCPtrFirst;
4010	if (cbRange >= GCPtrLast)
4011	GCPtrLast = RTGCPTR_MAX;
4012	else if (!cbRange)
4013	GCPtrLast = GCPtrFirst;
4014	else
4015	GCPtrLast = GCPtrFirst + cbRange - 1;
4016
4017	/*
4018	* Do we have a CR3?
4019	*/
4020	uint64_t cr3 = 0;
4021	if (cArgs > 1)
4022	{
4023	if ((fFlags & (DBGFPGDMP_FLAGS_GUEST \| DBGFPGDMP_FLAGS_SHADOW)) == (DBGFPGDMP_FLAGS_GUEST \| DBGFPGDMP_FLAGS_SHADOW))
4024	return DBGCCmdHlpFail(pCmdHlp, pCmd, "No CR3 or mode arguments when dumping both context, please.");
4025	if (paArgs[1].enmType != DBGCVAR_TYPE_NUMBER)
4026	return DBGCCmdHlpFail(pCmdHlp, pCmd, "The CR3 argument is not a number: %DV", &paArgs[1]);
4027	cr3 = paArgs[1].u.u64Number;
4028	}
4029	else
4030	fFlags \|= DBGFPGDMP_FLAGS_CURRENT_CR3;
4031
4032	/*
4033	* Do we have a mode?
4034	*/
4035	if (cArgs > 2)
4036	{
4037	if (paArgs[2].enmType != DBGCVAR_TYPE_STRING)
4038	return DBGCCmdHlpFail(pCmdHlp, pCmd, "The mode argument is not a string: %DV", &paArgs[2]);
4039	static const struct MODETOFLAGS
4040	{
4041	const char *pszName;
4042	uint32_t fFlags;
4043	} s_aModeToFlags[] =
4044	{
4045	{ "ept", DBGFPGDMP_FLAGS_EPT },
4046	{ "legacy", 0 },
4047	{ "legacy-np", DBGFPGDMP_FLAGS_NP },
4048	{ "pse", DBGFPGDMP_FLAGS_PSE },
4049	{ "pse-np", DBGFPGDMP_FLAGS_PSE \| DBGFPGDMP_FLAGS_NP },
4050	{ "pae", DBGFPGDMP_FLAGS_PSE \| DBGFPGDMP_FLAGS_PAE },
4051	{ "pae-np", DBGFPGDMP_FLAGS_PSE \| DBGFPGDMP_FLAGS_PAE \| DBGFPGDMP_FLAGS_NP },
4052	{ "pae-nx", DBGFPGDMP_FLAGS_PSE \| DBGFPGDMP_FLAGS_PAE \| DBGFPGDMP_FLAGS_NXE },
4053	{ "pae-nx-np", DBGFPGDMP_FLAGS_PSE \| DBGFPGDMP_FLAGS_PAE \| DBGFPGDMP_FLAGS_NXE \| DBGFPGDMP_FLAGS_NP },
4054	{ "long", DBGFPGDMP_FLAGS_PSE \| DBGFPGDMP_FLAGS_PAE \| DBGFPGDMP_FLAGS_LME },
4055	{ "long-np", DBGFPGDMP_FLAGS_PSE \| DBGFPGDMP_FLAGS_PAE \| DBGFPGDMP_FLAGS_LME \| DBGFPGDMP_FLAGS_NP },
4056	{ "long-nx", DBGFPGDMP_FLAGS_PSE \| DBGFPGDMP_FLAGS_PAE \| DBGFPGDMP_FLAGS_LME \| DBGFPGDMP_FLAGS_NXE },
4057	{ "long-nx-np", DBGFPGDMP_FLAGS_PSE \| DBGFPGDMP_FLAGS_PAE \| DBGFPGDMP_FLAGS_LME \| DBGFPGDMP_FLAGS_NXE \| DBGFPGDMP_FLAGS_NP }
4058	};
4059	int i = RT_ELEMENTS(s_aModeToFlags);
4060	while (i-- > 0)
4061	if (!strcmp(s_aModeToFlags[i].pszName, paArgs[2].u.pszString))
4062	{
4063	fFlags \|= s_aModeToFlags[i].fFlags;
4064	break;
4065	}
4066	if (i < 0)
4067	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Unknown mode: \"%s\"", paArgs[2].u.pszString);
4068	}
4069	else
4070	fFlags \|= DBGFPGDMP_FLAGS_CURRENT_MODE;
4071
4072	/*
4073	* Call the worker.
4074	*/
4075	rc = DBGFR3PagingDumpEx(pUVM, pDbgc->idCpu, fFlags, cr3, GCPtrFirst, GCPtrLast, 99 /cMaxDepth/,
4076	DBGCCmdHlpGetDbgfOutputHlp(pCmdHlp));
4077	if (RT_FAILURE(rc))
4078	return DBGCCmdHlpFail(pCmdHlp, pCmd, "DBGFR3PagingDumpEx: %Rrc\n", rc);
4079	return VINF_SUCCESS;
4080	}
4081
4082
4083
4084	/**
4085	* @callback_method_impl{FNDBGCCMD, The 'dpg*' commands.}
4086	*/
4087	static DECLCALLBACK(int) dbgcCmdDumpPageTable(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
4088	{
4089	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
4090
4091	/*
4092	* Validate input.
4093	*/
4094	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, cArgs == 1);
4095	if (pCmd->pszCmd[3] == 'a')
4096	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, DBGCVAR_ISPOINTER(paArgs[0].enmType));
4097	else
4098	DBGC_CMDHLP_ASSERT_PARSER_RET(pCmdHlp, pCmd, 0, paArgs[0].enmType == DBGCVAR_TYPE_NUMBER
4099	\|\| DBGCVAR_ISPOINTER(paArgs[0].enmType));
4100	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
4101
4102	/*
4103	* Guest or shadow page tables? Get the paging parameters.
4104	*/
4105	bool fGuest = pCmd->pszCmd[3] != 'h';
4106	if (!pCmd->pszCmd[3] \|\| pCmd->pszCmd[3] == 'a')
4107	fGuest = paArgs[0].enmType == DBGCVAR_TYPE_NUMBER ? true : DBGCVAR_ISGCPOINTER(paArgs[0].enmType);
4108
4109	bool fPAE, fLME, fPSE, fPGE, fNXE;
4110	uint64_t cr3 = fGuest
4111	? dbgcGetGuestPageMode(pDbgc, &fPAE, &fLME, &fPSE, &fPGE, &fNXE)
4112	: dbgcGetShadowPageMode(pDbgc, &fPAE, &fLME, &fPSE, &fPGE, &fNXE);
4113	const unsigned cbEntry = fPAE ? sizeof