DBGCOps.cpp@ 106724

Last change on this file since 106724 was 106061, checked in by vboxsync, 2 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 49.6 KB

Line
1	/* $Id: DBGCOps.cpp 106061 2024-09-16 14:03:52Z vboxsync $ */
2	/** @file
3	* DBGC - Debugger Console, Operators.
4	*/
5
6	/*
7	* Copyright (C) 2006-2024 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#define LOG_GROUP LOG_GROUP_DBGC
33	#include <VBox/dbg.h>
34	#include <VBox/vmm/dbgf.h>
35	#include <VBox/param.h>
36	#include <VBox/err.h>
37	#include <VBox/log.h>
38
39	#include <iprt/assert.h>
40	#include <iprt/mem.h>
41	#include <iprt/string.h>
42
43	#include "DBGCInternal.h"
44
45
46	/*********************************************************************************************************************************
47	* Internal Functions *
48	*********************************************************************************************************************************/
49	static DECLCALLBACK(int) dbgcOpMinus(PDBGC pDbgc, PCDBGCVAR pArg, DBGCVARCAT enmCat, PDBGCVAR pResult);
50	static DECLCALLBACK(int) dbgcOpPluss(PDBGC pDbgc, PCDBGCVAR pArg, DBGCVARCAT enmCat, PDBGCVAR pResult);
51	static DECLCALLBACK(int) dbgcOpBooleanNot(PDBGC pDbgc, PCDBGCVAR pArg, DBGCVARCAT enmCat, PDBGCVAR pResult);
52	static DECLCALLBACK(int) dbgcOpBitwiseNot(PDBGC pDbgc, PCDBGCVAR pArg, DBGCVARCAT enmCat, PDBGCVAR pResult);
53	static DECLCALLBACK(int) dbgcOpVar(PDBGC pDbgc, PCDBGCVAR pArg, DBGCVARCAT enmCat, PDBGCVAR pResult);
54
55	static DECLCALLBACK(int) dbgcOpAddrFar(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
56	static DECLCALLBACK(int) dbgcOpMult(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
57	static DECLCALLBACK(int) dbgcOpDiv(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
58	static DECLCALLBACK(int) dbgcOpMod(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
59	static DECLCALLBACK(int) dbgcOpAdd(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
60	static DECLCALLBACK(int) dbgcOpSub(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
61	static DECLCALLBACK(int) dbgcOpBitwiseShiftLeft(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
62	static DECLCALLBACK(int) dbgcOpBitwiseShiftRight(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
63	static DECLCALLBACK(int) dbgcOpBitwiseAnd(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
64	static DECLCALLBACK(int) dbgcOpBitwiseXor(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
65	static DECLCALLBACK(int) dbgcOpBitwiseOr(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
66	static DECLCALLBACK(int) dbgcOpBooleanAnd(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
67	static DECLCALLBACK(int) dbgcOpBooleanOr(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
68	static DECLCALLBACK(int) dbgcOpRangeLength(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
69	static DECLCALLBACK(int) dbgcOpRangeLengthBytes(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
70	static DECLCALLBACK(int) dbgcOpRangeTo(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
71
72
73	/*********************************************************************************************************************************
74	* Defined Constants And Macros *
75	*********************************************************************************************************************************/
76	/**
77	* Generic implementation of a binary operator.
78	*
79	* @returns VINF_SUCCESS on success.
80	* @returns VBox evaluation / parsing error code on failure.
81	* The caller does the bitching.
82	* @param pDbgc Debugger console instance data.
83	* @param pArg1 The first argument.
84	* @param pArg2 The 2nd argument.
85	* @param pResult Where to store the result.
86	* @param Operator The C operator.
87	* @param fIsDiv Set if it's division and we need to check for zero on the
88	* right hand side.
89	*/
90	#define DBGC_GEN_ARIT_BINARY_OP(pDbgc, pArg1, pArg2, pResult, Operator, fIsDiv) \
91	do \
92	{ \
93	if ((pArg1)->enmType == DBGCVAR_TYPE_STRING) \
94	return VERR_DBGC_PARSE_INVALID_OPERATION; \
95	\
96	/* Get the 64-bit right side value. */ \
97	uint64_t u64Right; \
98	int rc = dbgcOpHelperGetNumber((pDbgc), (pArg2), &u64Right); \
99	if ((fIsDiv) && RT_SUCCESS(rc) && !u64Right) /* div/0 kludge */ \
100	DBGCVAR_INIT_NUMBER((pResult), UINT64_MAX); \
101	else if (RT_SUCCESS(rc)) \
102	{ \
103	/* Apply it to the left hand side. */ \
104	if ((pArg1)->enmType == DBGCVAR_TYPE_SYMBOL) \
105	{ \
106	rc = dbgcSymbolGet((pDbgc), (pArg1)->u.pszString, DBGCVAR_TYPE_ANY, (pResult)); \
107	if (RT_FAILURE(rc)) \
108	return rc; \
109	} \
110	else \
111	(pResult) = (pArg1); \
112	switch ((pResult)->enmType) \
113	{ \
114	case DBGCVAR_TYPE_GC_FLAT: \
115	(pResult)->u.GCFlat = (pResult)->u.GCFlat Operator u64Right; \
116	break; \
117	case DBGCVAR_TYPE_GC_FAR: \
118	(pResult)->u.GCFar.off = (pResult)->u.GCFar.off Operator u64Right; \
119	break; \
120	case DBGCVAR_TYPE_GC_PHYS: \
121	(pResult)->u.GCPhys = (pResult)->u.GCPhys Operator u64Right; \
122	break; \
123	case DBGCVAR_TYPE_HC_FLAT: \
124	(pResult)->u.pvHCFlat = (void *)((uintptr_t)(pResult)->u.pvHCFlat Operator u64Right); \
125	break; \
126	case DBGCVAR_TYPE_HC_PHYS: \
127	(pResult)->u.HCPhys = (pResult)->u.HCPhys Operator u64Right; \
128	break; \
129	case DBGCVAR_TYPE_NUMBER: \
130	(pResult)->u.u64Number = (pResult)->u.u64Number Operator u64Right; \
131	break; \
132	default: \
133	return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE; \
134	} \
135	} \
136	return rc; \
137	} while (0)
138
139
140	/**
141	* Switch the factors/whatever so we preserve pointers.
142	* Far pointers are considered more important that physical and flat pointers.
143	*
144	* @param pArg1 The left side argument. Input & output.
145	* @param pArg2 The right side argument. Input & output.
146	*/
147	#define DBGC_GEN_ARIT_POINTER_TO_THE_LEFT(pArg1, pArg2) \
148	do \
149	{ \
150	if ( DBGCVAR_ISPOINTER((pArg2)->enmType) \
151	&& ( !DBGCVAR_ISPOINTER((pArg1)->enmType) \
152	\|\| ( DBGCVAR_IS_FAR_PTR((pArg2)->enmType) \
153	&& !DBGCVAR_IS_FAR_PTR((pArg1)->enmType)))) \
154	{ \
155	PCDBGCVAR pTmp = (pArg1); \
156	(pArg2) = (pArg1); \
157	(pArg1) = pTmp; \
158	} \
159	} while (0)
160
161
162	/*********************************************************************************************************************************
163	* Global Variables *
164	*********************************************************************************************************************************/
165	/** Operators. */
166	const DBGCOP g_aDbgcOps[] =
167	{
168	/* szName is initialized as a 4 char array because of M$C elsewise optimizing it away in /Ox mode (the 'const char' vs 'char' problem). */
169	/* szName, cchName, fBinary, iPrecedence, pfnHandlerUnary, pfnHandlerBitwise */
170	{ {'-'}, 1, false, 1, dbgcOpMinus, NULL, DBGCVAR_CAT_ANY, DBGCVAR_CAT_ANY, "Unary minus." },
171	{ {'+'}, 1, false, 1, dbgcOpPluss, NULL, DBGCVAR_CAT_ANY, DBGCVAR_CAT_ANY, "Unary plus." },
172	{ {'!'}, 1, false, 1, dbgcOpBooleanNot, NULL, DBGCVAR_CAT_ANY, DBGCVAR_CAT_ANY, "Boolean not." },
173	{ {'~'}, 1, false, 1, dbgcOpBitwiseNot, NULL, DBGCVAR_CAT_ANY, DBGCVAR_CAT_ANY, "Bitwise complement." },
174	{ {':'}, 1, true, 2, NULL, dbgcOpAddrFar, DBGCVAR_CAT_ANY, DBGCVAR_CAT_ANY, "Far pointer." },
175	{ {'%'}, 1, false, 3, dbgcOpAddrFlat, NULL, DBGCVAR_CAT_ANY, DBGCVAR_CAT_ANY, "Flat address." },
176	{ {'%','%'}, 2, false, 3, dbgcOpAddrPhys, NULL, DBGCVAR_CAT_ANY, DBGCVAR_CAT_ANY, "Physical address." },
177	{ {'#'}, 1, false, 3, dbgcOpAddrHost, NULL, DBGCVAR_CAT_ANY, DBGCVAR_CAT_ANY, "Flat host address." },
178	{ {'#','%','%'}, 3, false, 3, dbgcOpAddrHostPhys, NULL, DBGCVAR_CAT_ANY, DBGCVAR_CAT_ANY, "Physical host address." },
179	{ {'$'}, 1, false, 3, dbgcOpVar, NULL, DBGCVAR_CAT_SYMBOL, DBGCVAR_CAT_ANY, "Reference a variable." },
180	{ {'@'}, 1, false, 3, dbgcOpRegister, NULL, DBGCVAR_CAT_SYMBOL, DBGCVAR_CAT_ANY, "Reference a register." },
181	{ {'*'}, 1, true, 10, NULL, dbgcOpMult, DBGCVAR_CAT_ANY, DBGCVAR_CAT_ANY, "Multiplication." },
182	{ {'/'}, 1, true, 11, NULL, dbgcOpDiv, DBGCVAR_CAT_ANY, DBGCVAR_CAT_ANY, "Division." },
183	{ {'m','o','d'}, 3, true, 12, NULL, dbgcOpMod, DBGCVAR_CAT_ANY, DBGCVAR_CAT_ANY, "Modulus." },
184	{ {'+'}, 1, true, 13, NULL, dbgcOpAdd, DBGCVAR_CAT_ANY, DBGCVAR_CAT_ANY, "Addition." },
185	{ {'-'}, 1, true, 14, NULL, dbgcOpSub, DBGCVAR_CAT_ANY, DBGCVAR_CAT_ANY, "Subtraction." },
186	{ {'<','<'}, 2, true, 15, NULL, dbgcOpBitwiseShiftLeft, DBGCVAR_CAT_ANY, DBGCVAR_CAT_ANY, "Bitwise left shift." },
187	{ {'>','>'}, 2, true, 16, NULL, dbgcOpBitwiseShiftRight, DBGCVAR_CAT_ANY, DBGCVAR_CAT_ANY, "Bitwise right shift." },
188	{ {'&'}, 1, true, 17, NULL, dbgcOpBitwiseAnd, DBGCVAR_CAT_ANY, DBGCVAR_CAT_ANY, "Bitwise and." },
189	{ {'^'}, 1, true, 18, NULL, dbgcOpBitwiseXor, DBGCVAR_CAT_ANY, DBGCVAR_CAT_ANY, "Bitwise exclusiv or." },
190	{ {'\|'}, 1, true, 19, NULL, dbgcOpBitwiseOr, DBGCVAR_CAT_ANY, DBGCVAR_CAT_ANY, "Bitwise inclusive or." },
191	{ {'&','&'}, 2, true, 20, NULL, dbgcOpBooleanAnd, DBGCVAR_CAT_ANY, DBGCVAR_CAT_ANY, "Boolean and." },
192	{ {'\|','\|'}, 2, true, 21, NULL, dbgcOpBooleanOr, DBGCVAR_CAT_ANY, DBGCVAR_CAT_ANY, "Boolean or." },
193	{ {'L'}, 1, true, 22, NULL, dbgcOpRangeLength, DBGCVAR_CAT_ANY, DBGCVAR_CAT_ANY, "Range elements." },
194	{ {'L','B'}, 2, true, 23, NULL, dbgcOpRangeLengthBytes, DBGCVAR_CAT_ANY, DBGCVAR_CAT_ANY, "Range bytes." },
195	{ {'T'}, 1, true, 24, NULL, dbgcOpRangeTo, DBGCVAR_CAT_ANY, DBGCVAR_CAT_ANY, "Range to." }
196	};
197
198	/** Number of operators in the operator array. */
199	const uint32_t g_cDbgcOps = RT_ELEMENTS(g_aDbgcOps);
200
201
202	/**
203	* Converts an argument to a number value.
204	*
205	* @returns VBox status code.
206	* @param pDbgc The DBGC instance.
207	* @param pArg The argument to convert.
208	* @param pu64Ret Where to return the value.
209	*/
210	static int dbgcOpHelperGetNumber(PDBGC pDbgc, PCDBGCVAR pArg, uint64_t *pu64Ret)
211	{
212	DBGCVAR Var = *pArg;
213	switch (Var.enmType)
214	{
215	case DBGCVAR_TYPE_GC_FLAT:
216	*pu64Ret = Var.u.GCFlat;
217	break;
218	case DBGCVAR_TYPE_GC_FAR:
219	*pu64Ret = Var.u.GCFar.off;
220	break;
221	case DBGCVAR_TYPE_GC_PHYS:
222	*pu64Ret = Var.u.GCPhys;
223	break;
224	case DBGCVAR_TYPE_HC_FLAT:
225	*pu64Ret = (uintptr_t)Var.u.pvHCFlat;
226	break;
227	case DBGCVAR_TYPE_HC_PHYS:
228	*pu64Ret = Var.u.HCPhys;
229	break;
230	case DBGCVAR_TYPE_NUMBER:
231	*pu64Ret = Var.u.u64Number;
232	break;
233	case DBGCVAR_TYPE_SYMBOL:
234	{
235	int rc = dbgcSymbolGet(pDbgc, Var.u.pszString, DBGCVAR_TYPE_NUMBER, &Var);
236	if (RT_FAILURE(rc))
237	return rc;
238	}
239	RT_FALL_THRU();
240	case DBGCVAR_TYPE_STRING:
241	default:
242	return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
243	}
244	return VINF_SUCCESS;
245	}
246
247
248	/**
249	* @callback_method_impl{FNDBGCOPUNARY, Negate (unary).}
250	*/
251	static DECLCALLBACK(int) dbgcOpMinus(PDBGC pDbgc, PCDBGCVAR pArg, DBGCVARCAT enmCat, PDBGCVAR pResult)
252	{
253	RT_NOREF1(enmCat);
254	LogFlow(("dbgcOpMinus\n"));
255	pResult = pArg;
256	switch (pArg->enmType)
257	{
258	case DBGCVAR_TYPE_GC_FLAT:
259	pResult->u.GCFlat = -(RTGCINTPTR)pResult->u.GCFlat;
260	break;
261	case DBGCVAR_TYPE_GC_FAR:
262	pResult->u.GCFar.off = -(int32_t)pResult->u.GCFar.off;
263	break;
264	case DBGCVAR_TYPE_GC_PHYS:
265	pResult->u.GCPhys = (RTGCPHYS) -(int64_t)pResult->u.GCPhys;
266	break;
267	case DBGCVAR_TYPE_HC_FLAT:
268	pResult->u.pvHCFlat = (void *) -(intptr_t)pResult->u.pvHCFlat;
269	break;
270	case DBGCVAR_TYPE_HC_PHYS:
271	pResult->u.HCPhys = (RTHCPHYS) -(int64_t)pResult->u.HCPhys;
272	break;
273	case DBGCVAR_TYPE_NUMBER:
274	pResult->u.u64Number = -(int64_t)pResult->u.u64Number;
275	break;
276
277	case DBGCVAR_TYPE_STRING:
278	case DBGCVAR_TYPE_SYMBOL:
279	default:
280	return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
281	}
282	NOREF(pDbgc);
283	return VINF_SUCCESS;
284	}
285
286
287	/**
288	* @callback_method_impl{FNDBGCOPUNARY, Plus (unary).}
289	*/
290	static DECLCALLBACK(int) dbgcOpPluss(PDBGC pDbgc, PCDBGCVAR pArg, DBGCVARCAT enmCat, PDBGCVAR pResult)
291	{
292	RT_NOREF1(enmCat);
293	LogFlow(("dbgcOpPluss\n"));
294	pResult = pArg;
295	switch (pArg->enmType)
296	{
297	case DBGCVAR_TYPE_GC_FLAT:
298	case DBGCVAR_TYPE_GC_FAR:
299	case DBGCVAR_TYPE_GC_PHYS:
300	case DBGCVAR_TYPE_HC_FLAT:
301	case DBGCVAR_TYPE_HC_PHYS:
302	case DBGCVAR_TYPE_NUMBER:
303	break;
304
305	case DBGCVAR_TYPE_STRING:
306	case DBGCVAR_TYPE_SYMBOL:
307	default:
308	return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
309	}
310	NOREF(pDbgc);
311	return VINF_SUCCESS;
312	}
313
314
315	/**
316	* @callback_method_impl{FNDBGCOPUNARY, Boolean not (unary).}
317	*/
318	static DECLCALLBACK(int) dbgcOpBooleanNot(PDBGC pDbgc, PCDBGCVAR pArg, DBGCVARCAT enmCat, PDBGCVAR pResult)
319	{
320	RT_NOREF1(enmCat);
321	LogFlow(("dbgcOpBooleanNot\n"));
322	pResult = pArg;
323	switch (pArg->enmType)
324	{
325	case DBGCVAR_TYPE_GC_FLAT:
326	pResult->u.u64Number = !pResult->u.GCFlat;
327	break;
328	case DBGCVAR_TYPE_GC_FAR:
329	pResult->u.u64Number = !pResult->u.GCFar.off && pResult->u.GCFar.sel <= 3;
330	break;
331	case DBGCVAR_TYPE_GC_PHYS:
332	pResult->u.u64Number = !pResult->u.GCPhys;
333	break;
334	case DBGCVAR_TYPE_HC_FLAT:
335	pResult->u.u64Number = !pResult->u.pvHCFlat;
336	break;
337	case DBGCVAR_TYPE_HC_PHYS:
338	pResult->u.u64Number = !pResult->u.HCPhys;
339	break;
340	case DBGCVAR_TYPE_NUMBER:
341	pResult->u.u64Number = !pResult->u.u64Number;
342	break;
343	case DBGCVAR_TYPE_STRING:
344	case DBGCVAR_TYPE_SYMBOL:
345	pResult->u.u64Number = !pResult->u64Range;
346	break;
347
348	case DBGCVAR_TYPE_UNKNOWN:
349	default:
350	return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
351	}
352	pResult->enmType = DBGCVAR_TYPE_NUMBER;
353	NOREF(pDbgc);
354	return VINF_SUCCESS;
355	}
356
357
358	/**
359	* @callback_method_impl{FNDBGCOPUNARY, Bitwise not (unary).}
360	*/
361	static DECLCALLBACK(int) dbgcOpBitwiseNot(PDBGC pDbgc, PCDBGCVAR pArg, DBGCVARCAT enmCat, PDBGCVAR pResult)
362	{
363	RT_NOREF1(enmCat);
364	LogFlow(("dbgcOpBitwiseNot\n"));
365	pResult = pArg;
366	switch (pArg->enmType)
367	{
368	case DBGCVAR_TYPE_GC_FLAT:
369	pResult->u.GCFlat = ~pResult->u.GCFlat;
370	break;
371	case DBGCVAR_TYPE_GC_FAR:
372	pResult->u.GCFar.off = ~pResult->u.GCFar.off;
373	break;
374	case DBGCVAR_TYPE_GC_PHYS:
375	pResult->u.GCPhys = ~pResult->u.GCPhys;
376	break;
377	case DBGCVAR_TYPE_HC_FLAT:
378	pResult->u.pvHCFlat = (void *)~(uintptr_t)pResult->u.pvHCFlat;
379	break;
380	case DBGCVAR_TYPE_HC_PHYS:
381	pResult->u.HCPhys = ~pResult->u.HCPhys;
382	break;
383	case DBGCVAR_TYPE_NUMBER:
384	pResult->u.u64Number = ~pResult->u.u64Number;
385	break;
386
387	case DBGCVAR_TYPE_STRING:
388	case DBGCVAR_TYPE_SYMBOL:
389	default:
390	return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
391	}
392	NOREF(pDbgc);
393	return VINF_SUCCESS;
394	}
395
396
397	/**
398	* @callback_method_impl{FNDBGCOPUNARY, Reference variable (unary).}
399	*/
400	static DECLCALLBACK(int) dbgcOpVar(PDBGC pDbgc, PCDBGCVAR pArg, DBGCVARCAT enmCat, PDBGCVAR pResult)
401	{
402	RT_NOREF1(enmCat);
403	LogFlow(("dbgcOpVar: %s\n", pArg->u.pszString));
404	AssertReturn(pArg->enmType == DBGCVAR_TYPE_SYMBOL, VERR_DBGC_PARSE_BUG);
405
406	/*
407	* Lookup the variable.
408	*/
409	const char *pszVar = pArg->u.pszString;
410	for (unsigned iVar = 0; iVar < pDbgc->cVars; iVar++)
411	{
412	if (!strcmp(pszVar, pDbgc->papVars[iVar]->szName))
413	{
414	*pResult = pDbgc->papVars[iVar]->Var;
415	return VINF_SUCCESS;
416	}
417	}
418
419	return VERR_DBGC_PARSE_VARIABLE_NOT_FOUND;
420	}
421
422
423	/**
424	* @callback_method_impl{FNDBGCOPUNARY, Reference register (unary).}
425	*/
426	DECLCALLBACK(int) dbgcOpRegister(PDBGC pDbgc, PCDBGCVAR pArg, DBGCVARCAT enmCat, PDBGCVAR pResult)
427	{
428	LogFlow(("dbgcOpRegister: %s\n", pArg->u.pszString));
429	AssertReturn(pArg->enmType == DBGCVAR_TYPE_SYMBOL, VERR_DBGC_PARSE_BUG);
430
431	/* Detect references to hypervisor registers. */
432	const char *pszReg = pArg->u.pszString;
433	VMCPUID idCpu = pDbgc->idCpu;
434	if (pszReg[0] == '.')
435	{
436	pszReg++;
437	idCpu \|= DBGFREG_HYPER_VMCPUID;
438	}
439
440	/*
441	* If the desired result is a symbol, pass the argument along unmodified.
442	* This is a great help for "r @eax" and such, since it will be translated to "r eax".
443	*/
444	if (enmCat == DBGCVAR_CAT_SYMBOL)
445	{
446	int rc = DBGFR3RegNmValidate(pDbgc->pUVM, idCpu, pszReg);
447	if (RT_SUCCESS(rc))
448	DBGCVAR_INIT_STRING(pResult, pArg->u.pszString);
449	return rc;
450	}
451
452	/*
453	* Get the register.
454	*/
455	DBGFREGVALTYPE enmType;
456	DBGFREGVAL Value;
457	int rc = DBGFR3RegNmQuery(pDbgc->pUVM, idCpu, pszReg, &Value, &enmType);
458	if (RT_SUCCESS(rc))
459	{
460	switch (enmType)
461	{
462	case DBGFREGVALTYPE_U8:
463	DBGCVAR_INIT_NUMBER(pResult, Value.u8);
464	return VINF_SUCCESS;
465
466	case DBGFREGVALTYPE_U16:
467	DBGCVAR_INIT_NUMBER(pResult, Value.u16);
468	return VINF_SUCCESS;
469
470	case DBGFREGVALTYPE_U32:
471	DBGCVAR_INIT_NUMBER(pResult, Value.u32);
472	return VINF_SUCCESS;
473
474	case DBGFREGVALTYPE_U64:
475	DBGCVAR_INIT_NUMBER(pResult, Value.u64);
476	return VINF_SUCCESS;
477
478	case DBGFREGVALTYPE_U128:
479	DBGCVAR_INIT_NUMBER(pResult, Value.u128.s.Lo);
480	return VINF_SUCCESS;
481
482	case DBGFREGVALTYPE_U256:
483	DBGCVAR_INIT_NUMBER(pResult, Value.u256.QWords.qw0);
484	return VINF_SUCCESS;
485
486	case DBGFREGVALTYPE_U512:
487	DBGCVAR_INIT_NUMBER(pResult, Value.u512.QWords.qw0);
488	return VINF_SUCCESS;
489
490	case DBGFREGVALTYPE_R80:
491	#ifdef RT_COMPILER_WITH_80BIT_LONG_DOUBLE
492	DBGCVAR_INIT_NUMBER(pResult, (uint64_t)Value.r80Ex.lrd);
493	#else
494	DBGCVAR_INIT_NUMBER(pResult, (uint64_t)Value.r80Ex.sj64.uFraction);
495	#endif
496	return VINF_SUCCESS;
497
498	case DBGFREGVALTYPE_DTR:
499	DBGCVAR_INIT_NUMBER(pResult, Value.dtr.u64Base);
500	return VINF_SUCCESS;
501
502	case DBGFREGVALTYPE_INVALID:
503	case DBGFREGVALTYPE_END:
504	case DBGFREGVALTYPE_32BIT_HACK:
505	break;
506	}
507	rc = VERR_INTERNAL_ERROR_5;
508	}
509	return rc;
510	}
511
512
513	/**
514	* @callback_method_impl{FNDBGCOPUNARY, Flat address (unary).}
515	*/
516	DECLCALLBACK(int) dbgcOpAddrFlat(PDBGC pDbgc, PCDBGCVAR pArg, DBGCVARCAT enmCat, PDBGCVAR pResult)
517	{
518	RT_NOREF1(enmCat);
519	LogFlow(("dbgcOpAddrFlat\n"));
520	DBGCVARTYPE enmType = DBGCVAR_ISHCPOINTER(pArg->enmType) ? DBGCVAR_TYPE_HC_FLAT : DBGCVAR_TYPE_GC_FLAT;
521	return DBGCCmdHlpConvert(&pDbgc->CmdHlp, pArg, enmType, true /fConvSyms/, pResult);
522	}
523
524
525	/**
526	* @callback_method_impl{FNDBGCOPUNARY, Physical address (unary).}
527	*/
528	DECLCALLBACK(int) dbgcOpAddrPhys(PDBGC pDbgc, PCDBGCVAR pArg, DBGCVARCAT enmCat, PDBGCVAR pResult)
529	{
530	RT_NOREF1(enmCat);
531	LogFlow(("dbgcOpAddrPhys\n"));
532	DBGCVARTYPE enmType = DBGCVAR_ISHCPOINTER(pArg->enmType) ? DBGCVAR_TYPE_HC_PHYS : DBGCVAR_TYPE_GC_PHYS;
533	return DBGCCmdHlpConvert(&pDbgc->CmdHlp, pArg, enmType, true /fConvSyms/, pResult);
534	}
535
536
537	/**
538	* @callback_method_impl{FNDBGCOPUNARY, Physical host address (unary).}
539	*/
540	DECLCALLBACK(int) dbgcOpAddrHostPhys(PDBGC pDbgc, PCDBGCVAR pArg, DBGCVARCAT enmCat, PDBGCVAR pResult)
541	{
542	RT_NOREF1(enmCat);
543	LogFlow(("dbgcOpAddrPhys\n"));
544	return DBGCCmdHlpConvert(&pDbgc->CmdHlp, pArg, DBGCVAR_TYPE_HC_PHYS, true /fConvSyms/, pResult);
545	}
546
547
548	/**
549	* @callback_method_impl{FNDBGCOPUNARY, Host address (unary).}
550	*/
551	DECLCALLBACK(int) dbgcOpAddrHost(PDBGC pDbgc, PCDBGCVAR pArg, DBGCVARCAT enmCat, PDBGCVAR pResult)
552	{
553	RT_NOREF1(enmCat);
554	LogFlow(("dbgcOpAddrHost\n"));
555	return DBGCCmdHlpConvert(&pDbgc->CmdHlp, pArg, DBGCVAR_TYPE_HC_FLAT, true /fConvSyms/, pResult);
556	}
557
558
559	/**
560	* @callback_method_impl{FNDBGCOPUNARY, Far address (unary).}
561	*/
562	static DECLCALLBACK(int) dbgcOpAddrFar(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
563	{
564	LogFlow(("dbgcOpAddrFar\n"));
565	int rc;
566
567	switch (pArg1->enmType)
568	{
569	case DBGCVAR_TYPE_SYMBOL:
570	rc = dbgcSymbolGet(pDbgc, pArg1->u.pszString, DBGCVAR_TYPE_NUMBER, pResult);
571	if (RT_FAILURE(rc))
572	return rc;
573	break;
574	case DBGCVAR_TYPE_NUMBER:
575	pResult = pArg1;
576	break;
577	default:
578	return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
579	}
580	pResult->u.GCFar.sel = (RTSEL)pResult->u.u64Number;
581
582	/* common code for the two types we support. */
583	switch (pArg2->enmType)
584	{
585	case DBGCVAR_TYPE_GC_FLAT:
586	pResult->u.GCFar.off = pArg2->u.GCFlat;
587	pResult->enmType = DBGCVAR_TYPE_GC_FAR;
588	break;
589
590	case DBGCVAR_TYPE_HC_FLAT:
591	pResult->u.pvHCFlat = (void *)(uintptr_t)pArg2->u.GCFlat;
592	pResult->enmType = DBGCVAR_TYPE_GC_FAR;
593	break;
594
595	case DBGCVAR_TYPE_NUMBER:
596	pResult->u.GCFar.off = (RTGCPTR)pArg2->u.u64Number;
597	pResult->enmType = DBGCVAR_TYPE_GC_FAR;
598	break;
599
600	case DBGCVAR_TYPE_SYMBOL:
601	{
602	DBGCVAR Var;
603	rc = dbgcSymbolGet(pDbgc, pArg2->u.pszString, DBGCVAR_TYPE_NUMBER, &Var);
604	if (RT_FAILURE(rc))
605	return rc;
606	pResult->u.GCFar.off = (RTGCPTR)Var.u.u64Number;
607	pResult->enmType = DBGCVAR_TYPE_GC_FAR;
608	break;
609	}
610
611	default:
612	return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
613	}
614	return VINF_SUCCESS;
615
616	}
617
618
619	/**
620	* Multiplication operator (binary).
621	*
622	* @returns VINF_SUCCESS on success.
623	* @returns VBox evaluation / parsing error code on failure.
624	* The caller does the bitching.
625	* @param pDbgc Debugger console instance data.
626	* @param pArg1 The first argument.
627	* @param pArg2 The 2nd argument.
628	* @param pResult Where to store the result.
629	*/
630	static DECLCALLBACK(int) dbgcOpMult(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
631	{
632	LogFlow(("dbgcOpMult\n"));
633	DBGC_GEN_ARIT_POINTER_TO_THE_LEFT(pArg1, pArg2);
634	DBGC_GEN_ARIT_BINARY_OP(pDbgc, pArg1, pArg2, pResult, *, false);
635	}
636
637
638	/**
639	* Division operator (binary).
640	*
641	* @returns VINF_SUCCESS on success.
642	* @returns VBox evaluation / parsing error code on failure.
643	* The caller does the bitching.
644	* @param pDbgc Debugger console instance data.
645	* @param pArg1 The first argument.
646	* @param pArg2 The 2nd argument.
647	* @param pResult Where to store the result.
648	*/
649	static DECLCALLBACK(int) dbgcOpDiv(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
650	{
651	LogFlow(("dbgcOpDiv\n"));
652	DBGC_GEN_ARIT_BINARY_OP(pDbgc, pArg1, pArg2, pResult, /, true);
653	}
654
655
656	/**
657	* Modulus operator (binary).
658	*
659	* @returns VINF_SUCCESS on success.
660	* @returns VBox evaluation / parsing error code on failure.
661	* The caller does the bitching.
662	* @param pDbgc Debugger console instance data.
663	* @param pArg1 The first argument.
664	* @param pArg2 The 2nd argument.
665	* @param pResult Where to store the result.
666	*/
667	static DECLCALLBACK(int) dbgcOpMod(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
668	{
669	LogFlow(("dbgcOpMod\n"));
670	DBGC_GEN_ARIT_BINARY_OP(pDbgc, pArg1, pArg2, pResult, %, false);
671	}
672
673
674	/**
675	* Addition operator (binary).
676	*
677	* @returns VINF_SUCCESS on success.
678	* @returns VBox evaluation / parsing error code on failure.
679	* The caller does the bitching.
680	* @param pDbgc Debugger console instance data.
681	* @param pArg1 The first argument.
682	* @param pArg2 The 2nd argument.
683	* @param pResult Where to store the result.
684	*/
685	static DECLCALLBACK(int) dbgcOpAdd(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
686	{
687	LogFlow(("dbgcOpAdd\n"));
688
689	/*
690	* An addition operation will return (when possible) the left side type in the
691	* expression. We make an omission for numbers, where we'll take the right side
692	* type instead. An expression where only the left hand side is a symbol we'll
693	* use the right hand type to try resolve it.
694	*/
695	if ( pArg1->enmType == DBGCVAR_TYPE_STRING
696	\|\| pArg2->enmType == DBGCVAR_TYPE_STRING)
697	return VERR_DBGC_PARSE_INVALID_OPERATION; /** @todo string contactenation later. */
698
699	if ( (pArg1->enmType == DBGCVAR_TYPE_NUMBER && pArg2->enmType != DBGCVAR_TYPE_SYMBOL)
700	\|\| (pArg1->enmType == DBGCVAR_TYPE_SYMBOL && pArg2->enmType != DBGCVAR_TYPE_SYMBOL))
701	{
702	PCDBGCVAR pTmp = pArg2;
703	pArg2 = pArg1;
704	pArg1 = pTmp;
705	}
706
707	DBGCVAR Sym1, Sym2;
708	if (pArg1->enmType == DBGCVAR_TYPE_SYMBOL)
709	{
710	int rc = dbgcSymbolGet(pDbgc, pArg1->u.pszString, DBGCVAR_TYPE_ANY, &Sym1);
711	if (RT_FAILURE(rc))
712	return rc;
713	pArg1 = &Sym1;
714
715	rc = dbgcSymbolGet(pDbgc, pArg2->u.pszString, DBGCVAR_TYPE_ANY, &Sym2);
716	if (RT_FAILURE(rc))
717	return rc;
718	pArg2 = &Sym2;
719	}
720
721	int rc;
722	DBGCVAR Var;
723	DBGCVAR Var2;
724	switch (pArg1->enmType)
725	{
726	/*
727	* GC Flat
728	*/
729	case DBGCVAR_TYPE_GC_FLAT:
730	switch (pArg2->enmType)
731	{
732	case DBGCVAR_TYPE_HC_FLAT:
733	case DBGCVAR_TYPE_HC_PHYS:
734	return VERR_DBGC_PARSE_INVALID_OPERATION;
735	default:
736	pResult = pArg1;
737	rc = dbgcOpAddrFlat(pDbgc, pArg2, DBGCVAR_CAT_ANY, &Var);
738	if (RT_FAILURE(rc))
739	return rc;
740	pResult->u.GCFlat += pArg2->u.GCFlat;
741	break;
742	}
743	break;
744
745	/*
746	* GC Far
747	*/
748	case DBGCVAR_TYPE_GC_FAR:
749	switch (pArg2->enmType)
750	{
751	case DBGCVAR_TYPE_HC_FLAT:
752	case DBGCVAR_TYPE_HC_PHYS:
753	return VERR_DBGC_PARSE_INVALID_OPERATION;
754	case DBGCVAR_TYPE_NUMBER:
755	pResult = pArg1;
756	pResult->u.GCFar.off += (RTGCPTR)pArg2->u.u64Number;
757	break;
758	default:
759	rc = dbgcOpAddrFlat(pDbgc, pArg1, DBGCVAR_CAT_ANY, pResult);
760	if (RT_FAILURE(rc))
761	return rc;
762	rc = dbgcOpAddrFlat(pDbgc, pArg2, DBGCVAR_CAT_ANY, &Var);
763	if (RT_FAILURE(rc))
764	return rc;
765	pResult->u.GCFlat += pArg2->u.GCFlat;
766	break;
767	}
768	break;
769
770	/*
771	* GC Phys
772	*/
773	case DBGCVAR_TYPE_GC_PHYS:
774	switch (pArg2->enmType)
775	{
776	case DBGCVAR_TYPE_HC_FLAT:
777	case DBGCVAR_TYPE_HC_PHYS:
778	return VERR_DBGC_PARSE_INVALID_OPERATION;
779	default:
780	pResult = pArg1;
781	rc = dbgcOpAddrPhys(pDbgc, pArg2, DBGCVAR_CAT_ANY, &Var);
782	if (RT_FAILURE(rc))
783	return rc;
784	if (Var.enmType != DBGCVAR_TYPE_GC_PHYS)
785	return VERR_DBGC_PARSE_INVALID_OPERATION;
786	pResult->u.GCPhys += Var.u.GCPhys;
787	break;
788	}
789	break;
790
791	/*
792	* HC Flat
793	*/
794	case DBGCVAR_TYPE_HC_FLAT:
795	pResult = pArg1;
796	rc = dbgcOpAddrHost(pDbgc, pArg2, DBGCVAR_CAT_ANY, &Var2);
797	if (RT_FAILURE(rc))
798	return rc;
799	rc = dbgcOpAddrFlat(pDbgc, &Var2, DBGCVAR_CAT_ANY, &Var);
800	if (RT_FAILURE(rc))
801	return rc;
802	pResult->u.pvHCFlat = (char *)pResult->u.pvHCFlat + (uintptr_t)Var.u.pvHCFlat;
803	break;
804
805	/*
806	* HC Phys
807	*/
808	case DBGCVAR_TYPE_HC_PHYS:
809	pResult = pArg1;
810	rc = dbgcOpAddrHostPhys(pDbgc, pArg2, DBGCVAR_CAT_ANY, &Var);
811	if (RT_FAILURE(rc))
812	return rc;
813	pResult->u.HCPhys += Var.u.HCPhys;
814	break;
815
816	/*
817	* Numbers (see start of function)
818	*/
819	case DBGCVAR_TYPE_NUMBER:
820	pResult = pArg1;
821	switch (pArg2->enmType)
822	{
823	case DBGCVAR_TYPE_SYMBOL:
824	rc = dbgcSymbolGet(pDbgc, pArg2->u.pszString, DBGCVAR_TYPE_NUMBER, &Var);
825	if (RT_FAILURE(rc))
826	return rc;
827	RT_FALL_THRU();
828	case DBGCVAR_TYPE_NUMBER:
829	pResult->u.u64Number += pArg2->u.u64Number;
830	break;
831	default:
832	return VERR_DBGC_PARSE_INVALID_OPERATION;
833	}
834	break;
835
836	default:
837	return VERR_DBGC_PARSE_INVALID_OPERATION;
838
839	}
840	return VINF_SUCCESS;
841	}
842
843
844	/**
845	* Subtraction operator (binary).
846	*
847	* @returns VINF_SUCCESS on success.
848	* @returns VBox evaluation / parsing error code on failure.
849	* The caller does the bitching.
850	* @param pDbgc Debugger console instance data.
851	* @param pArg1 The first argument.
852	* @param pArg2 The 2nd argument.
853	* @param pResult Where to store the result.
854	*/
855	static DECLCALLBACK(int) dbgcOpSub(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
856	{
857	LogFlow(("dbgcOpSub\n"));
858
859	/*
860	* An subtraction operation will return the left side type in the expression.
861	* However, if the left hand side is a number and the right hand a pointer of
862	* some kind we'll convert the left hand side to the same type as the right hand.
863	* Any symbols will be resolved, strings will be rejected.
864	*/
865	DBGCVAR Sym1, Sym2;
866	if ( pArg2->enmType == DBGCVAR_TYPE_SYMBOL
867	&& ( pArg1->enmType == DBGCVAR_TYPE_NUMBER
868	\|\| pArg1->enmType == DBGCVAR_TYPE_SYMBOL))
869	{
870	int rc = dbgcSymbolGet(pDbgc, pArg2->u.pszString, DBGCVAR_TYPE_ANY, &Sym2);
871	if (RT_FAILURE(rc))
872	return rc;
873	pArg2 = &Sym2;
874	}
875
876	if ( pArg1->enmType == DBGCVAR_TYPE_STRING
877	\|\| pArg2->enmType == DBGCVAR_TYPE_STRING)
878	return VERR_DBGC_PARSE_INVALID_OPERATION;
879
880	if (pArg1->enmType == DBGCVAR_TYPE_SYMBOL)
881	{
882	DBGCVARTYPE enmType;
883	switch (pArg2->enmType)
884	{
885	case DBGCVAR_TYPE_NUMBER:
886	enmType = DBGCVAR_TYPE_ANY;
887	break;
888	case DBGCVAR_TYPE_GC_FLAT:
889	case DBGCVAR_TYPE_GC_PHYS:
890	case DBGCVAR_TYPE_HC_FLAT:
891	case DBGCVAR_TYPE_HC_PHYS:
892	enmType = pArg2->enmType;
893	break;
894	case DBGCVAR_TYPE_GC_FAR:
895	enmType = DBGCVAR_TYPE_GC_FLAT;
896	break;
897	default: AssertFailedReturn(VERR_DBGC_IPE);
898	}
899	if (enmType != DBGCVAR_TYPE_STRING)
900	{
901	int rc = dbgcSymbolGet(pDbgc, pArg1->u.pszString, DBGCVAR_TYPE_ANY, &Sym1);
902	if (RT_FAILURE(rc))
903	return rc;
904	pArg1 = &Sym1;
905	}
906	}
907	else if (pArg1->enmType == DBGCVAR_TYPE_NUMBER)
908	{
909	PFNDBGCOPUNARY pOp = NULL;
910	switch (pArg2->enmType)
911	{
912	case DBGCVAR_TYPE_GC_FAR:
913	case DBGCVAR_TYPE_GC_FLAT:
914	pOp = dbgcOpAddrFlat;
915	break;
916	case DBGCVAR_TYPE_GC_PHYS:
917	pOp = dbgcOpAddrPhys;
918	break;
919	case DBGCVAR_TYPE_HC_FLAT:
920	pOp = dbgcOpAddrHost;
921	break;
922	case DBGCVAR_TYPE_HC_PHYS:
923	pOp = dbgcOpAddrHostPhys;
924	break;
925	case DBGCVAR_TYPE_NUMBER:
926	break;
927	default: AssertFailedReturn(VERR_DBGC_IPE);
928	}
929	if (pOp)
930	{
931	int rc = pOp(pDbgc, pArg1, DBGCVAR_CAT_ANY, &Sym1);
932	if (RT_FAILURE(rc))
933	return rc;
934	pArg1 = &Sym1;
935	}
936	}
937
938	/*
939	* Normal processing.
940	*/
941	int rc;
942	DBGCVAR Var;
943	DBGCVAR Var2;
944	switch (pArg1->enmType)
945	{
946	/*
947	* GC Flat
948	*/
949	case DBGCVAR_TYPE_GC_FLAT:
950	switch (pArg2->enmType)
951	{
952	case DBGCVAR_TYPE_HC_FLAT:
953	case DBGCVAR_TYPE_HC_PHYS:
954	return VERR_DBGC_PARSE_INVALID_OPERATION;
955	default:
956	pResult = pArg1;
957	rc = dbgcOpAddrFlat(pDbgc, pArg2, DBGCVAR_CAT_ANY, &Var);
958	if (RT_FAILURE(rc))
959	return rc;
960	pResult->u.GCFlat -= pArg2->u.GCFlat;
961	break;
962	}
963	break;
964
965	/*
966	* GC Far
967	*/
968	case DBGCVAR_TYPE_GC_FAR:
969	switch (pArg2->enmType)
970	{
971	case DBGCVAR_TYPE_HC_FLAT:
972	case DBGCVAR_TYPE_HC_PHYS:
973	return VERR_DBGC_PARSE_INVALID_OPERATION;
974	case DBGCVAR_TYPE_NUMBER:
975	pResult = pArg1;
976	pResult->u.GCFar.off -= (RTGCPTR)pArg2->u.u64Number;
977	break;
978	default:
979	rc = dbgcOpAddrFlat(pDbgc, pArg1, DBGCVAR_CAT_ANY, pResult);
980	if (RT_FAILURE(rc))
981	return rc;
982	rc = dbgcOpAddrFlat(pDbgc, pArg2, DBGCVAR_CAT_ANY, &Var);
983	if (RT_FAILURE(rc))
984	return rc;
985	pResult->u.GCFlat -= pArg2->u.GCFlat;
986	break;
987	}
988	break;
989
990	/*
991	* GC Phys
992	*/
993	case DBGCVAR_TYPE_GC_PHYS:
994	switch (pArg2->enmType)
995	{
996	case DBGCVAR_TYPE_HC_FLAT:
997	case DBGCVAR_TYPE_HC_PHYS:
998	return VERR_DBGC_PARSE_INVALID_OPERATION;
999	default:
1000	pResult = pArg1;
1001	rc = dbgcOpAddrPhys(pDbgc, pArg2, DBGCVAR_CAT_ANY, &Var);
1002	if (RT_FAILURE(rc))
1003	return rc;
1004	if (Var.enmType != DBGCVAR_TYPE_GC_PHYS)
1005	return VERR_DBGC_PARSE_INVALID_OPERATION;
1006	pResult->u.GCPhys -= Var.u.GCPhys;
1007	break;
1008	}
1009	break;
1010
1011	/*
1012	* HC Flat
1013	*/
1014	case DBGCVAR_TYPE_HC_FLAT:
1015	pResult = pArg1;
1016	rc = dbgcOpAddrHost(pDbgc, pArg2, DBGCVAR_CAT_ANY, &Var2);
1017	if (RT_FAILURE(rc))
1018	return rc;
1019	rc = dbgcOpAddrFlat(pDbgc, &Var2, DBGCVAR_CAT_ANY, &Var);
1020	if (RT_FAILURE(rc))
1021	return rc;
1022	pResult->u.pvHCFlat = (char *)pResult->u.pvHCFlat - (uintptr_t)Var.u.pvHCFlat;
1023	break;
1024
1025	/*
1026	* HC Phys
1027	*/
1028	case DBGCVAR_TYPE_HC_PHYS:
1029	pResult = pArg1;
1030	rc = dbgcOpAddrHostPhys(pDbgc, pArg2, DBGCVAR_CAT_ANY, &Var);
1031	if (RT_FAILURE(rc))
1032	return rc;
1033	pResult->u.HCPhys -= Var.u.HCPhys;
1034	break;
1035
1036	/*
1037	* Numbers (see start of function)
1038	*/
1039	case DBGCVAR_TYPE_NUMBER:
1040	pResult = pArg1;
1041	switch (pArg2->enmType)
1042	{
1043	case DBGCVAR_TYPE_SYMBOL:
1044	rc = dbgcSymbolGet(pDbgc, pArg2->u.pszString, DBGCVAR_TYPE_NUMBER, &Var);
1045	if (RT_FAILURE(rc))
1046	return rc;
1047	RT_FALL_THRU();
1048	case DBGCVAR_TYPE_NUMBER:
1049	pResult->u.u64Number -= pArg2->u.u64Number;
1050	break;
1051	default:
1052	return VERR_DBGC_PARSE_INVALID_OPERATION;
1053	}
1054	break;
1055
1056	default:
1057	return VERR_DBGC_PARSE_INVALID_OPERATION;
1058
1059	}
1060	return VINF_SUCCESS;
1061	}
1062
1063
1064	/**
1065	* Bitwise shift left operator (binary).
1066	*
1067	* @returns VINF_SUCCESS on success.
1068	* @returns VBox evaluation / parsing error code on failure.
1069	* The caller does the bitching.
1070	* @param pDbgc Debugger console instance data.
1071	* @param pArg1 The first argument.
1072	* @param pArg2 The 2nd argument.
1073	* @param pResult Where to store the result.
1074	*/
1075	static DECLCALLBACK(int) dbgcOpBitwiseShiftLeft(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
1076	{
1077	LogFlow(("dbgcOpBitwiseShiftLeft\n"));
1078	DBGC_GEN_ARIT_BINARY_OP(pDbgc, pArg1, pArg2, pResult, <<, false);
1079	}
1080
1081
1082	/**
1083	* Bitwise shift right operator (binary).
1084	*
1085	* @returns VINF_SUCCESS on success.
1086	* @returns VBox evaluation / parsing error code on failure.
1087	* The caller does the bitching.
1088	* @param pDbgc Debugger console instance data.
1089	* @param pArg1 The first argument.
1090	* @param pArg2 The 2nd argument.
1091	* @param pResult Where to store the result.
1092	*/
1093	static DECLCALLBACK(int) dbgcOpBitwiseShiftRight(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
1094	{
1095	LogFlow(("dbgcOpBitwiseShiftRight\n"));
1096	DBGC_GEN_ARIT_BINARY_OP(pDbgc, pArg1, pArg2, pResult, >>, false);
1097	}
1098
1099
1100	/**
1101	* Bitwise and operator (binary).
1102	*
1103	* @returns VINF_SUCCESS on success.
1104	* @returns VBox evaluation / parsing error code on failure.
1105	* The caller does the bitching.
1106	* @param pDbgc Debugger console instance data.
1107	* @param pArg1 The first argument.
1108	* @param pArg2 The 2nd argument.
1109	* @param pResult Where to store the result.
1110	*/
1111	static DECLCALLBACK(int) dbgcOpBitwiseAnd(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
1112	{
1113	LogFlow(("dbgcOpBitwiseAnd\n"));
1114	DBGC_GEN_ARIT_POINTER_TO_THE_LEFT(pArg1, pArg2);
1115	DBGC_GEN_ARIT_BINARY_OP(pDbgc, pArg1, pArg2, pResult, &, false);
1116	}
1117
1118
1119	/**
1120	* Bitwise exclusive or operator (binary).
1121	*
1122	* @returns VINF_SUCCESS on success.
1123	* @returns VBox evaluation / parsing error code on failure.
1124	* The caller does the bitching.
1125	* @param pDbgc Debugger console instance data.
1126	* @param pArg1 The first argument.
1127	* @param pArg2 The 2nd argument.
1128	* @param pResult Where to store the result.
1129	*/
1130	static DECLCALLBACK(int) dbgcOpBitwiseXor(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
1131	{
1132	LogFlow(("dbgcOpBitwiseXor\n"));
1133	DBGC_GEN_ARIT_POINTER_TO_THE_LEFT(pArg1, pArg2);
1134	DBGC_GEN_ARIT_BINARY_OP(pDbgc, pArg1, pArg2, pResult, ^, false);
1135	}
1136
1137
1138	/**
1139	* Bitwise inclusive or operator (binary).
1140	*
1141	* @returns VINF_SUCCESS on success.
1142	* @returns VBox evaluation / parsing error code on failure.
1143	* The caller does the bitching.
1144	* @param pDbgc Debugger console instance data.
1145	* @param pArg1 The first argument.
1146	* @param pArg2 The 2nd argument.
1147	* @param pResult Where to store the result.
1148	*/
1149	static DECLCALLBACK(int) dbgcOpBitwiseOr(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
1150	{
1151	LogFlow(("dbgcOpBitwiseOr\n"));
1152	DBGC_GEN_ARIT_POINTER_TO_THE_LEFT(pArg1, pArg2);
1153	DBGC_GEN_ARIT_BINARY_OP(pDbgc, pArg1, pArg2, pResult, \|, false);
1154	}
1155
1156
1157	/**
1158	* Boolean and operator (binary).
1159	*
1160	* @returns VINF_SUCCESS on success.
1161	* @returns VBox evaluation / parsing error code on failure.
1162	* The caller does the bitching.
1163	* @param pDbgc Debugger console instance data.
1164	* @param pArg1 The first argument.
1165	* @param pArg2 The 2nd argument.
1166	* @param pResult Where to store the result.
1167	*/
1168	static DECLCALLBACK(int) dbgcOpBooleanAnd(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
1169	{
1170	LogFlow(("dbgcOpBooleanAnd\n"));
1171	/** @todo force numeric return value? */
1172	DBGC_GEN_ARIT_BINARY_OP(pDbgc, pArg1, pArg2, pResult, &&, false);
1173	}
1174
1175
1176	/**
1177	* Boolean or operator (binary).
1178	*
1179	* @returns VINF_SUCCESS on success.
1180	* @returns VBox evaluation / parsing error code on failure.
1181	* The caller does the bitching.
1182	* @param pDbgc Debugger console instance data.
1183	* @param pArg1 The first argument.
1184	* @param pArg2 The 2nd argument.
1185	* @param pResult Where to store the result.
1186	*/
1187	static DECLCALLBACK(int) dbgcOpBooleanOr(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
1188	{
1189	LogFlow(("dbgcOpBooleanOr\n"));
1190	/** @todo force numeric return value? */
1191	DBGC_GEN_ARIT_BINARY_OP(pDbgc, pArg1, pArg2, pResult, \|\|, false);
1192	}
1193
1194
1195	/**
1196	* Range to operator (binary).
1197	*
1198	* @returns VINF_SUCCESS on success.
1199	* @returns VBox evaluation / parsing error code on failure.
1200	* The caller does the bitching.
1201	* @param pDbgc Debugger console instance data.
1202	* @param pArg1 The first argument.
1203	* @param pArg2 The 2nd argument.
1204	* @param pResult Where to store the result.
1205	*/
1206	static DECLCALLBACK(int) dbgcOpRangeLength(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
1207	{
1208	LogFlow(("dbgcOpRangeLength\n"));
1209
1210	if (pArg1->enmType == DBGCVAR_TYPE_STRING)
1211	return VERR_DBGC_PARSE_INVALID_OPERATION;
1212
1213	/*
1214	* Make result. Symbols needs to be resolved.
1215	*/
1216	if (pArg1->enmType == DBGCVAR_TYPE_SYMBOL)
1217	{
1218	int rc = dbgcSymbolGet(pDbgc, pArg1->u.pszString, DBGCVAR_TYPE_ANY, pResult);
1219	if (RT_FAILURE(rc))
1220	return rc;
1221	}
1222	else
1223	pResult = pArg1;
1224
1225	/*
1226	* Convert 2nd argument to element count.
1227	*/
1228	pResult->enmRangeType = DBGCVAR_RANGE_ELEMENTS;
1229	switch (pArg2->enmType)
1230	{
1231	case DBGCVAR_TYPE_NUMBER:
1232	pResult->u64Range = pArg2->u.u64Number;
1233	break;
1234
1235	case DBGCVAR_TYPE_SYMBOL:
1236	{
1237	int rc = dbgcSymbolGet(pDbgc, pArg2->u.pszString, DBGCVAR_TYPE_NUMBER, pResult);
1238	if (RT_FAILURE(rc))
1239	return rc;
1240	pResult->u64Range = pArg2->u.u64Number;
1241	break;
1242	}
1243
1244	case DBGCVAR_TYPE_STRING:
1245	default:
1246	return VERR_DBGC_PARSE_INVALID_OPERATION;
1247	}
1248
1249	return VINF_SUCCESS;
1250	}
1251
1252
1253	/**
1254	* Range to operator (binary).
1255	*
1256	* @returns VINF_SUCCESS on success.
1257	* @returns VBox evaluation / parsing error code on failure.
1258	* The caller does the bitching.
1259	* @param pDbgc Debugger console instance data.
1260	* @param pArg1 The first argument.
1261	* @param pArg2 The 2nd argument.
1262	* @param pResult Where to store the result.
1263	*/
1264	static DECLCALLBACK(int) dbgcOpRangeLengthBytes(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
1265	{
1266	LogFlow(("dbgcOpRangeLengthBytes\n"));
1267	int rc = dbgcOpRangeLength(pDbgc, pArg1, pArg2, pResult);
1268	if (RT_SUCCESS(rc))
1269	pResult->enmRangeType = DBGCVAR_RANGE_BYTES;
1270	return rc;
1271	}
1272
1273
1274	/**
1275	* Range to operator (binary).
1276	*
1277	* @returns VINF_SUCCESS on success.
1278	* @returns VBox evaluation / parsing error code on failure.
1279	* The caller does the bitching.
1280	* @param pDbgc Debugger console instance data.
1281	* @param pArg1 The first argument.
1282	* @param pArg2 The 2nd argument.
1283	* @param pResult Where to store the result.
1284	*/
1285	static DECLCALLBACK(int) dbgcOpRangeTo(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
1286	{
1287	LogFlow(("dbgcOpRangeTo\n"));
1288
1289	/*
1290	* Calc number of bytes between the two args.
1291	*/
1292	DBGCVAR Diff;
1293	int rc = dbgcOpSub(pDbgc, pArg2, pArg1, &Diff);
1294	if (RT_FAILURE(rc))
1295	return rc;
1296
1297	/*
1298	* Use the diff as the range of Arg1.
1299	*/
1300	pResult = pArg1;
1301	pResult->enmRangeType = DBGCVAR_RANGE_BYTES;
1302	switch (Diff.enmType)
1303	{
1304	case DBGCVAR_TYPE_GC_FLAT:
1305	pResult->u64Range = (RTGCUINTPTR)Diff.u.GCFlat;
1306	break;
1307	case DBGCVAR_TYPE_GC_PHYS:
1308	pResult->u64Range = Diff.u.GCPhys;
1309	break;
1310	case DBGCVAR_TYPE_HC_FLAT:
1311	pResult->u64Range = (uintptr_t)Diff.u.pvHCFlat;
1312	break;
1313	case DBGCVAR_TYPE_HC_PHYS:
1314	pResult->u64Range = Diff.u.HCPhys;
1315	break;
1316	case DBGCVAR_TYPE_NUMBER:
1317	pResult->u64Range = Diff.u.u64Number;
1318	break;
1319
1320	case DBGCVAR_TYPE_GC_FAR:
1321	case DBGCVAR_TYPE_STRING:
1322	case DBGCVAR_TYPE_SYMBOL:
1323	default:
1324	AssertMsgFailed(("Impossible!\n"));
1325	return VERR_DBGC_PARSE_INVALID_OPERATION;
1326	}
1327
1328	return VINF_SUCCESS;
1329	}
1330
1331
1332	/**
1333	* Searches for an operator descriptor which matches the start of
1334	* the expression given us.
1335	*
1336	* @returns Pointer to the operator on success.
1337	* @param pDbgc The debug console instance.
1338	* @param pszExpr Pointer to the expression string which might start with an operator.
1339	* @param fPreferBinary Whether to favour binary or unary operators.
1340	* Caller must assert that it's the desired type! Both types will still
1341	* be returned, this is only for resolving duplicates.
1342	* @param chPrev The previous char. Some operators requires a blank in front of it.
1343	*/
1344	PCDBGCOP dbgcOperatorLookup(PDBGC pDbgc, const char *pszExpr, bool fPreferBinary, char chPrev)
1345	{
1346	PCDBGCOP pOp = NULL;
1347	for (unsigned iOp = 0; iOp < RT_ELEMENTS(g_aDbgcOps); iOp++)
1348	{
1349	if ( g_aDbgcOps[iOp].szName[0] == pszExpr[0]
1350	&& (!g_aDbgcOps[iOp].szName[1] \|\| g_aDbgcOps[iOp].szName[1] == pszExpr[1])
1351	&& (!g_aDbgcOps[iOp].szName[2] \|\| g_aDbgcOps[iOp].szName[2] == pszExpr[2]))
1352	{
1353	/*
1354	* Check that we don't mistake it for some other operator which have more chars.
1355	*/
1356	unsigned j;
1357	for (j = iOp + 1; j < RT_ELEMENTS(g_aDbgcOps); j++)
1358	if ( g_aDbgcOps[j].cchName > g_aDbgcOps[iOp].cchName
1359	&& g_aDbgcOps[j].szName[0] == pszExpr[0]
1360	&& (!g_aDbgcOps[j].szName[1] \|\| g_aDbgcOps[j].szName[1] == pszExpr[1])
1361	&& (!g_aDbgcOps[j].szName[2] \|\| g_aDbgcOps[j].szName[2] == pszExpr[2]) )
1362	break;
1363	if (j < RT_ELEMENTS(g_aDbgcOps))
1364	continue; /* we'll catch it later. (for theoretical +,++,+++ cases.) */
1365	pOp = &g_aDbgcOps[iOp];
1366
1367	/*
1368	* Preferred type?
1369	*/
1370	if (g_aDbgcOps[iOp].fBinary == fPreferBinary)
1371	break;
1372	}
1373	}
1374
1375	if (pOp)
1376	Log2(("dbgcOperatorLookup: pOp=%p %s\n", pOp, pOp->szName));
1377	NOREF(pDbgc); NOREF(chPrev);
1378	return pOp;
1379	}
1380

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

source: vbox/trunk/src/VBox/Debugger/DBGCOps.cpp@ 106724

Download in other formats: