Disasm.cpp@ 102948

Last change on this file since 102948 was 101539, checked in by vboxsync, 13 months ago
DIS,VMM,DBGC,IPRT,++: Some disassembler tweaks and TB disassembly work. bugref:10371 bugref:9898
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 24.4 KB

Line
1	/* $Id: Disasm.cpp 101539 2023-10-22 02:43:09Z vboxsync $ */
2	/** @file
3	* VBox disassembler - Disassemble and optionally format.
4	*/
5
6	/*
7	* Copyright (C) 2006-2023 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_DIS
33	#include <VBox/dis.h>
34	#include <iprt/errcore.h>
35	#include <iprt/assert.h>
36	#include <iprt/string.h>
37	#include "DisasmInternal.h"
38
39
40	/*********************************************************************************************************************************
41	* Defined Constants And Macros *
42	*********************************************************************************************************************************/
43
44
45	/*********************************************************************************************************************************
46	* Internal Functions *
47	*********************************************************************************************************************************/
48
49	/**
50	* @interface_method_impl{FNDISREADBYTES, The default byte reader callber.}
51	*/
52	static DECLCALLBACK(int) disReadBytesDefault(PDISSTATE pDis, uint8_t offInstr, uint8_t cbMinRead, uint8_t cbMaxRead)
53	{
54	#if 0 /def IN_RING0 - why? /
55	RT_NOREF_PV(cbMinRead);
56	AssertMsgFailed(("disReadWord with no read callback in ring 0!!\n"));
57	RT_BZERO(&pDis->Instr.ab[offInstr], cbMaxRead);
58	pDis->cbCachedInstr = offInstr + cbMaxRead;
59	return VERR_DIS_NO_READ_CALLBACK;
60	#else
61	uint8_t const pbSrc = (uint8_t const )(uintptr_t)pDis->uInstrAddr + offInstr;
62	size_t cbLeftOnPage = (uintptr_t)pbSrc & PAGE_OFFSET_MASK;
63	uint8_t cbToRead = cbLeftOnPage >= cbMaxRead
64	? cbMaxRead
65	: cbLeftOnPage <= cbMinRead
66	? cbMinRead
67	: (uint8_t)cbLeftOnPage;
68	memcpy(&pDis->Instr.ab[offInstr], pbSrc, cbToRead);
69	pDis->cbCachedInstr = offInstr + cbToRead;
70	return VINF_SUCCESS;
71	#endif
72	}
73
74
75	/**
76	* Read more bytes into the DISSTATE::Instr.ab buffer, advance
77	* DISSTATE::cbCachedInstr.
78	*
79	* Will set DISSTATE::rc on failure, but still advance cbCachedInstr.
80	*
81	* The caller shall fend off reads beyond the DISSTATE::Instr.ab buffer.
82	*
83	* @param pDis The disassembler state.
84	* @param offInstr The offset of the read request.
85	* @param cbMin The size of the read request that needs to be
86	* satisfied.
87	*/
88	DECLHIDDEN(void) disReadMore(PDISSTATE pDis, uint8_t offInstr, uint8_t cbMin)
89	{
90	Assert(cbMin + offInstr <= sizeof(pDis->Instr.ab));
91
92	/*
93	* Adjust the incoming request to not overlap with bytes that has already
94	* been read and to make sure we don't leave unread gaps.
95	*/
96	if (offInstr < pDis->cbCachedInstr)
97	{
98	Assert(offInstr + cbMin > pDis->cbCachedInstr);
99	cbMin -= pDis->cbCachedInstr - offInstr;
100	offInstr = pDis->cbCachedInstr;
101	}
102	else if (offInstr > pDis->cbCachedInstr)
103	{
104	cbMin += offInstr - pDis->cbCachedInstr;
105	offInstr = pDis->cbCachedInstr;
106	}
107
108	/*
109	* Do the read.
110	* (No need to zero anything on failure as Instr.ab is already zeroed by the
111	* DISInstrEx API.)
112	*/
113	int rc = pDis->pfnReadBytes(pDis, offInstr, cbMin, sizeof(pDis->Instr.ab) - offInstr);
114	if (RT_SUCCESS(rc))
115	{
116	Assert(pDis->cbCachedInstr >= offInstr + cbMin);
117	Assert(pDis->cbCachedInstr <= sizeof(pDis->Instr.ab));
118	}
119	else
120	{
121	Log(("disReadMore failed with rc=%Rrc!!\n", rc));
122	pDis->rc = rc;
123	}
124	}
125
126
127	/**
128	* Function for handling a 8-bit cache miss.
129	*
130	* @returns The requested byte.
131	* @param pDis The disassembler state.
132	* @param offInstr The offset of the byte relative to the
133	* instruction.
134	*/
135	DECLHIDDEN(uint8_t) disReadByteSlow(PDISSTATE pDis, size_t offInstr)
136	{
137	if (RT_LIKELY(offInstr < DIS_MAX_INSTR_LENGTH))
138	{
139	disReadMore(pDis, (uint8_t)offInstr, 1);
140	return pDis->Instr.ab[offInstr];
141	}
142
143	Log(("disReadByte: too long instruction...\n"));
144	pDis->rc = VERR_DIS_TOO_LONG_INSTR;
145	ssize_t cbLeft = (ssize_t)(sizeof(pDis->Instr.ab) - offInstr);
146	if (cbLeft > 0)
147	return pDis->Instr.ab[offInstr];
148	return 0;
149	}
150
151
152	/**
153	* Function for handling a 16-bit cache miss.
154	*
155	* @returns The requested word.
156	* @param pDis The disassembler state.
157	* @param offInstr The offset of the word relative to the
158	* instruction.
159	*/
160	DECLHIDDEN(uint16_t) disReadWordSlow(PDISSTATE pDis, size_t offInstr)
161	{
162	if (RT_LIKELY(offInstr + 2 <= DIS_MAX_INSTR_LENGTH))
163	{
164	disReadMore(pDis, (uint8_t)offInstr, 2);
165	#ifdef DIS_HOST_UNALIGNED_ACCESS_OK
166	return (uint16_t const )&pDis->Instr.ab[offInstr];
167	#else
168	return RT_MAKE_U16(pDis->Instr.ab[offInstr], pDis->Instr.ab[offInstr + 1]);
169	#endif
170	}
171
172	Log(("disReadWord: too long instruction...\n"));
173	pDis->rc = VERR_DIS_TOO_LONG_INSTR;
174	ssize_t cbLeft = (ssize_t)(sizeof(pDis->Instr.ab) - offInstr);
175	switch (cbLeft)
176	{
177	case 1:
178	return pDis->Instr.ab[offInstr];
179	default:
180	if (cbLeft >= 2)
181	return RT_MAKE_U16(pDis->Instr.ab[offInstr], pDis->Instr.ab[offInstr + 1]);
182	return 0;
183	}
184	}
185
186
187	/**
188	* Function for handling a 32-bit cache miss.
189	*
190	* @returns The requested dword.
191	* @param pDis The disassembler state.
192	* @param offInstr The offset of the dword relative to the
193	* instruction.
194	*/
195	DECLHIDDEN(uint32_t) disReadDWordSlow(PDISSTATE pDis, size_t offInstr)
196	{
197	if (RT_LIKELY(offInstr + 4 <= DIS_MAX_INSTR_LENGTH))
198	{
199	disReadMore(pDis, (uint8_t)offInstr, 4);
200	#ifdef DIS_HOST_UNALIGNED_ACCESS_OK
201	return (uint32_t const )&pDis->Instr.ab[offInstr];
202	#else
203	return RT_MAKE_U32_FROM_U8(pDis->Instr.ab[offInstr ], pDis->Instr.ab[offInstr + 1],
204	pDis->Instr.ab[offInstr + 2], pDis->Instr.ab[offInstr + 3]);
205	#endif
206	}
207
208	Log(("disReadDWord: too long instruction...\n"));
209	pDis->rc = VERR_DIS_TOO_LONG_INSTR;
210	ssize_t cbLeft = (ssize_t)(sizeof(pDis->Instr.ab) - offInstr);
211	switch (cbLeft)
212	{
213	case 1:
214	return RT_MAKE_U32_FROM_U8(pDis->Instr.ab[offInstr], 0, 0, 0);
215	case 2:
216	return RT_MAKE_U32_FROM_U8(pDis->Instr.ab[offInstr], pDis->Instr.ab[offInstr + 1], 0, 0);
217	case 3:
218	return RT_MAKE_U32_FROM_U8(pDis->Instr.ab[offInstr], pDis->Instr.ab[offInstr + 1], pDis->Instr.ab[offInstr + 2], 0);
219	default:
220	if (cbLeft >= 4)
221	return RT_MAKE_U32_FROM_U8(pDis->Instr.ab[offInstr ], pDis->Instr.ab[offInstr + 1],
222	pDis->Instr.ab[offInstr + 2], pDis->Instr.ab[offInstr + 3]);
223	return 0;
224	}
225	}
226
227
228	/**
229	* Function for handling a 64-bit cache miss.
230	*
231	* @returns The requested qword.
232	* @param pDis The disassembler state.
233	* @param offInstr The offset of the qword relative to the
234	* instruction.
235	*/
236	DECLHIDDEN(uint64_t) disReadQWordSlow(PDISSTATE pDis, size_t offInstr)
237	{
238	if (RT_LIKELY(offInstr + 8 <= DIS_MAX_INSTR_LENGTH))
239	{
240	disReadMore(pDis, (uint8_t)offInstr, 8);
241	#ifdef DIS_HOST_UNALIGNED_ACCESS_OK
242	return (uint64_t const )&pDis->Instr.ab[offInstr];
243	#else
244	return RT_MAKE_U64_FROM_U8(pDis->Instr.ab[offInstr ], pDis->Instr.ab[offInstr + 1],
245	pDis->Instr.ab[offInstr + 2], pDis->Instr.ab[offInstr + 3],
246	pDis->Instr.ab[offInstr + 4], pDis->Instr.ab[offInstr + 5],
247	pDis->Instr.ab[offInstr + 6], pDis->Instr.ab[offInstr + 7]);
248	#endif
249	}
250
251	Log(("disReadQWord: too long instruction...\n"));
252	pDis->rc = VERR_DIS_TOO_LONG_INSTR;
253	ssize_t cbLeft = (ssize_t)(sizeof(pDis->Instr.ab) - offInstr);
254	switch (cbLeft)
255	{
256	case 1:
257	return RT_MAKE_U64_FROM_U8(pDis->Instr.ab[offInstr], 0, 0, 0, 0, 0, 0, 0);
258	case 2:
259	return RT_MAKE_U64_FROM_U8(pDis->Instr.ab[offInstr], pDis->Instr.ab[offInstr + 1], 0, 0, 0, 0, 0, 0);
260	case 3:
261	return RT_MAKE_U64_FROM_U8(pDis->Instr.ab[offInstr ], pDis->Instr.ab[offInstr + 1],
262	pDis->Instr.ab[offInstr + 2], 0, 0, 0, 0, 0);
263	case 4:
264	return RT_MAKE_U64_FROM_U8(pDis->Instr.ab[offInstr ], pDis->Instr.ab[offInstr + 1],
265	pDis->Instr.ab[offInstr + 2], pDis->Instr.ab[offInstr + 3],
266	0, 0, 0, 0);
267	case 5:
268	return RT_MAKE_U64_FROM_U8(pDis->Instr.ab[offInstr ], pDis->Instr.ab[offInstr + 1],
269	pDis->Instr.ab[offInstr + 2], pDis->Instr.ab[offInstr + 3],
270	pDis->Instr.ab[offInstr + 4], 0, 0, 0);
271	case 6:
272	return RT_MAKE_U64_FROM_U8(pDis->Instr.ab[offInstr ], pDis->Instr.ab[offInstr + 1],
273	pDis->Instr.ab[offInstr + 2], pDis->Instr.ab[offInstr + 3],
274	pDis->Instr.ab[offInstr + 4], pDis->Instr.ab[offInstr + 5],
275	0, 0);
276	case 7:
277	return RT_MAKE_U64_FROM_U8(pDis->Instr.ab[offInstr ], pDis->Instr.ab[offInstr + 1],
278	pDis->Instr.ab[offInstr + 2], pDis->Instr.ab[offInstr + 3],
279	pDis->Instr.ab[offInstr + 4], pDis->Instr.ab[offInstr + 5],
280	pDis->Instr.ab[offInstr + 6], 0);
281	default:
282	if (cbLeft >= 8)
283	return RT_MAKE_U64_FROM_U8(pDis->Instr.ab[offInstr ], pDis->Instr.ab[offInstr + 1],
284	pDis->Instr.ab[offInstr + 2], pDis->Instr.ab[offInstr + 3],
285	pDis->Instr.ab[offInstr + 4], pDis->Instr.ab[offInstr + 5],
286	pDis->Instr.ab[offInstr + 6], pDis->Instr.ab[offInstr + 7]);
287	return 0;
288	}
289	}
290
291
292	/**
293	* Inlined worker that initializes the disassembler state.
294	*
295	* @returns The primary opcode map to use.
296	* @param pDis The disassembler state.
297	* @param uInstrAddr The instruction address.
298	* @param enmCpuMode The CPU mode.
299	* @param fFilter The instruction filter settings.
300	* @param pfnReadBytes The byte reader, can be NULL.
301	* @param pvUser The user data for the reader.
302	*/
303	DECL_FORCE_INLINE(PCDISOPCODE)
304	disInitializeState(PDISSTATE pDis, RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, uint32_t fFilter,
305	PFNDISREADBYTES pfnReadBytes, void *pvUser)
306	{
307	RT_ZERO(*pDis);
308
309	#ifdef VBOX_STRICT
310	pDis->Param1.uValue = UINT64_C(0xb1b1b1b1b1b1b1b1);
311	pDis->Param2.uValue = UINT64_C(0xb2b2b2b2b2b2b2b2);
312	pDis->Param3.uValue = UINT64_C(0xb3b3b3b3b3b3b3b3);
313	#endif
314
315	pDis->rc = VINF_SUCCESS;
316	pDis->uInstrAddr = uInstrAddr;
317	pDis->pfnReadBytes = pfnReadBytes ? pfnReadBytes : disReadBytesDefault;
318	pDis->pvUser = pvUser;
319	pDis->uCpuMode = (uint8_t)enmCpuMode;
320
321	switch (enmCpuMode)
322	{
323	case DISCPUMODE_16BIT:
324	case DISCPUMODE_32BIT:
325	case DISCPUMODE_64BIT:
326	#if defined(VBOX_DIS_WITH_X86_AMD64)
327	return disInitializeStateX86(pDis, enmCpuMode, fFilter);
328	#else
329	return NULL;
330	#endif
331	case DISCPUMODE_ARMV8_A64:
332	case DISCPUMODE_ARMV8_A32:
333	case DISCPUMODE_ARMV8_T32:
334	#if defined(VBOX_DIS_WITH_ARMV8)
335	return disInitializeStateArmV8(pDis, enmCpuMode, fFilter);
336	#else
337	return NULL;
338	#endif
339	default:
340	break;
341	}
342
343	AssertReleaseFailed(); /* Should never get here. */
344	return NULL;
345	}
346
347
348	/**
349	* Disassembles on instruction, details in @a pDis and length in @a pcbInstr.
350	*
351	* @returns VBox status code.
352	* @param uInstrAddr Address of the instruction to decode. What this means
353	* is left to the pfnReadBytes function.
354	* @param enmCpuMode The CPU mode. DISCPUMODE_32BIT, DISCPUMODE_16BIT, or DISCPUMODE_64BIT.
355	* @param pfnReadBytes Callback for reading instruction bytes.
356	* @param fFilter Instruction type filter.
357	* @param pvUser User argument for the instruction reader. (Ends up in pvUser.)
358	* @param pDis Pointer to disassembler state (output).
359	* @param pcbInstr Where to store the size of the instruction. (This
360	* is also stored in PDISSTATE::cbInstr.) Optional.
361	*/
362	DISDECL(int) DISInstrEx(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, uint32_t fFilter,
363	PFNDISREADBYTES pfnReadBytes, void *pvUser,
364	PDISSTATE pDis, uint32_t *pcbInstr)
365	{
366
367	PCDISOPCODE paOneByteMap = disInitializeState(pDis, uInstrAddr, enmCpuMode, fFilter, pfnReadBytes, pvUser);
368	disPrefetchBytes(pDis);
369
370	switch (enmCpuMode)
371	{
372	case DISCPUMODE_16BIT:
373	case DISCPUMODE_32BIT:
374	case DISCPUMODE_64BIT:
375	#if defined(VBOX_DIS_WITH_X86_AMD64)
376	return disInstrWorkerX86(pDis, paOneByteMap, pcbInstr);
377	#else
378	return VERR_NOT_SUPPORTED;
379	#endif
380	case DISCPUMODE_ARMV8_A64:
381	case DISCPUMODE_ARMV8_A32:
382	case DISCPUMODE_ARMV8_T32:
383	#if defined(VBOX_DIS_WITH_ARMV8)
384	return disInstrWorkerArmV8(pDis, paOneByteMap, pcbInstr);
385	#else
386	return VERR_NOT_SUPPORTED;
387	#endif
388	default:
389	break;
390	}
391
392	AssertReleaseFailed(); /* Should never get here. */
393	return VERR_INTERNAL_ERROR;
394	}
395
396
397	/**
398	* Disassembles on instruction partially or fully from prefetched bytes, details
399	* in @a pDis and length in @a pcbInstr.
400	*
401	* @returns VBox status code.
402	* @param uInstrAddr Address of the instruction to decode. What this means
403	* is left to the pfnReadBytes function.
404	* @param enmCpuMode The CPU mode. DISCPUMODE_32BIT, DISCPUMODE_16BIT, or DISCPUMODE_64BIT.
405	* @param pvPrefetched Pointer to the prefetched bytes.
406	* @param cbPrefetched The number of valid bytes pointed to by @a
407	* pbPrefetched.
408	* @param pfnReadBytes Callback for reading instruction bytes.
409	* @param fFilter Instruction type filter.
410	* @param pvUser User argument for the instruction reader. (Ends up in pvUser.)
411	* @param pDis Pointer to disassembler state (output).
412	* @param pcbInstr Where to store the size of the instruction. (This
413	* is also stored in PDISSTATE::cbInstr.) Optional.
414	*/
415	DISDECL(int) DISInstrWithPrefetchedBytes(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, uint32_t fFilter,
416	void const *pvPrefetched, size_t cbPretched,
417	PFNDISREADBYTES pfnReadBytes, void *pvUser,
418	PDISSTATE pDis, uint32_t *pcbInstr)
419	{
420	PCDISOPCODE paOneByteMap = disInitializeState(pDis, uInstrAddr, enmCpuMode, fFilter, pfnReadBytes, pvUser);
421
422	if (!cbPretched)
423	disPrefetchBytes(pDis);
424	else
425	{
426	if (cbPretched >= sizeof(pDis->Instr.ab))
427	{
428	memcpy(pDis->Instr.ab, pvPrefetched, sizeof(pDis->Instr.ab));
429	pDis->cbCachedInstr = (uint8_t)sizeof(pDis->Instr.ab);
430	}
431	else
432	{
433	memcpy(pDis->Instr.ab, pvPrefetched, cbPretched);
434	pDis->cbCachedInstr = (uint8_t)cbPretched;
435	}
436	}
437
438	switch (enmCpuMode)
439	{
440	case DISCPUMODE_16BIT:
441	case DISCPUMODE_32BIT:
442	case DISCPUMODE_64BIT:
443	#if defined(VBOX_DIS_WITH_X86_AMD64)
444	return disInstrWorkerX86(pDis, paOneByteMap, pcbInstr);
445	#else
446	return VERR_NOT_SUPPORTED;
447	#endif
448	case DISCPUMODE_ARMV8_A64:
449	case DISCPUMODE_ARMV8_A32:
450	case DISCPUMODE_ARMV8_T32:
451	#if defined(VBOX_DIS_WITH_ARMV8)
452	return disInstrWorkerArmV8(pDis, paOneByteMap, pcbInstr);
453	#else
454	return VERR_NOT_SUPPORTED;
455	#endif
456	default:
457	break;
458	}
459
460	AssertReleaseFailed(); /* Should never get here. */
461	return VERR_INTERNAL_ERROR;
462	}
463
464
465	/**
466	* Parses one guest instruction.
467	*
468	* The result is found in pDis and pcbInstr.
469	*
470	* @returns VBox status code.
471	* @param uInstrAddr Address of the instruction to decode. What this means
472	* is left to the pfnReadBytes function.
473	* @param enmCpuMode The CPU mode. DISCPUMODE_32BIT, DISCPUMODE_16BIT, or DISCPUMODE_64BIT.
474	* @param pfnReadBytes Callback for reading instruction bytes.
475	* @param pvUser User argument for the instruction reader. (Ends up in pvUser.)
476	* @param pDis Pointer to disassembler state (output).
477	* @param pcbInstr Where to store the size of the instruction.
478	* NULL is allowed. This is also stored in
479	* PDISSTATE::cbInstr.
480	*/
481	DISDECL(int) DISInstrWithReader(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, PFNDISREADBYTES pfnReadBytes, void *pvUser,
482	PDISSTATE pDis, uint32_t *pcbInstr)
483	{
484	return DISInstrEx(uInstrAddr, enmCpuMode, DISOPTYPE_ALL, pfnReadBytes, pvUser, pDis, pcbInstr);
485	}
486
487
488	/**
489	* Parses one guest instruction.
490	*
491	* The result is found in pDis and pcbInstr.
492	*
493	* @returns VBox status code.
494	* @param pvInstr Address of the instruction to decode. This is a
495	* real address in the current context that can be
496	* accessed without faulting. (Consider
497	* DISInstrWithReader if this isn't the case.)
498	* @param enmCpuMode The CPU mode. DISCPUMODE_32BIT, DISCPUMODE_16BIT, or DISCPUMODE_64BIT.
499	* @param pfnReadBytes Callback for reading instruction bytes.
500	* @param pvUser User argument for the instruction reader. (Ends up in pvUser.)
501	* @param pDis Pointer to disassembler state (output).
502	* @param pcbInstr Where to store the size of the instruction.
503	* NULL is allowed. This is also stored in
504	* PDISSTATE::cbInstr.
505	*/
506	DISDECL(int) DISInstr(const void pvInstr, DISCPUMODE enmCpuMode, PDISSTATE pDis, uint32_t pcbInstr)
507	{
508	return DISInstrEx((uintptr_t)pvInstr, enmCpuMode, DISOPTYPE_ALL, NULL /pfnReadBytes/, NULL /pvUser/, pDis, pcbInstr);
509	}
510
511
512	#ifndef DIS_CORE_ONLY
513	/**
514	* Disassembles one instruction
515	*
516	* @returns VBox error code
517	* @param pvInstr Pointer to the instruction to disassemble.
518	* @param enmCpuMode The CPU state.
519	* @param pDis The disassembler state (output).
520	* @param pcbInstr Where to store the size of the instruction. NULL is
521	* allowed.
522	* @param pszOutput Storage for disassembled instruction
523	* @param cbOutput Size of the output buffer.
524	*
525	* @todo Define output callback.
526	*/
527	DISDECL(int) DISInstrToStr(void const pvInstr, DISCPUMODE enmCpuMode, PDISSTATE pDis, uint32_t pcbInstr,
528	char *pszOutput, size_t cbOutput)
529	{
530	return DISInstrToStrEx((uintptr_t)pvInstr, enmCpuMode, NULL, NULL, DISOPTYPE_ALL,
531	pDis, pcbInstr, pszOutput, cbOutput);
532	}
533
534
535	/**
536	* Disassembles one instruction with a byte fetcher caller.
537	*
538	* @returns VBox error code
539	* @param uInstrAddr Pointer to the structure to disassemble.
540	* @param enmCpuMode The CPU mode.
541	* @param pfnCallback The byte fetcher callback.
542	* @param pvUser The user argument (found in
543	* DISSTATE::pvUser).
544	* @param pDis The disassembler state (output).
545	* @param pcbInstr Where to store the size of the instruction. NULL is
546	* allowed.
547	* @param pszOutput Storage for disassembled instruction.
548	* @param cbOutput Size of the output buffer.
549	*
550	* @todo Define output callback.
551	*/
552	DISDECL(int) DISInstrToStrWithReader(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, PFNDISREADBYTES pfnReadBytes, void *pvUser,
553	PDISSTATE pDis, uint32_t pcbInstr, char pszOutput, size_t cbOutput)
554
555	{
556	return DISInstrToStrEx(uInstrAddr, enmCpuMode, pfnReadBytes, pvUser, DISOPTYPE_ALL,
557	pDis, pcbInstr, pszOutput, cbOutput);
558	}
559
560
561	/**
562	* Disassembles one instruction; only fully disassembly an instruction if it matches the filter criteria
563	*
564	* @returns VBox error code
565	* @param uInstrAddr Pointer to the structure to disassemble.
566	* @param enmCpuMode The CPU mode.
567	* @param pfnCallback The byte fetcher callback.
568	* @param uFilter Instruction filter.
569	* @param pDis Where to return the disassembled instruction info.
570	* @param pcbInstr Where to store the size of the instruction. NULL is
571	* allowed.
572	* @param pszOutput Storage for disassembled instruction.
573	* @param cbOutput Size of the output buffer.
574	*
575	* @todo Define output callback.
576	*/
577	DISDECL(int) DISInstrToStrEx(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode,
578	PFNDISREADBYTES pfnReadBytes, void *pvUser, uint32_t uFilter,
579	PDISSTATE pDis, uint32_t pcbInstr, char pszOutput, size_t cbOutput)
580	{
581	/* Don't filter if formatting is desired. */
582	if (uFilter != DISOPTYPE_ALL && pszOutput && cbOutput)
583	uFilter = DISOPTYPE_ALL;
584
585	int rc = DISInstrEx(uInstrAddr, enmCpuMode, uFilter, pfnReadBytes, pvUser, pDis, pcbInstr);
586	if (RT_SUCCESS(rc) && pszOutput && cbOutput)
587	{
588	size_t cch = 0;
589
590	switch (enmCpuMode)
591	{
592	case DISCPUMODE_16BIT:
593	case DISCPUMODE_32BIT:
594	case DISCPUMODE_64BIT:
595	#if defined(VBOX_DIS_WITH_X86_AMD64)
596	cch = DISFormatYasmEx(pDis, pszOutput, cbOutput,
597	DIS_FMT_FLAGS_BYTES_LEFT \| DIS_FMT_FLAGS_BYTES_BRACKETS \| DIS_FMT_FLAGS_BYTES_SPACED
598	\| DIS_FMT_FLAGS_RELATIVE_BRANCH \| DIS_FMT_FLAGS_ADDR_LEFT,
599	NULL /pfnGetSymbol/, NULL /pvUser/);
600	#else
601	AssertReleaseFailed(); /* Shouldn't ever get here (DISInstrEx() returning VERR_NOT_SUPPORTED). */
602	#endif
603	break;
604	case DISCPUMODE_ARMV8_A64:
605	case DISCPUMODE_ARMV8_A32:
606	case DISCPUMODE_ARMV8_T32:
607	#if defined(VBOX_DIS_WITH_ARMV8)
608	cch = DISFormatArmV8Ex(pDis, pszOutput, cbOutput,
609	DIS_FMT_FLAGS_BYTES_LEFT \| DIS_FMT_FLAGS_BYTES_BRACKETS \| DIS_FMT_FLAGS_BYTES_SPACED
610	\| DIS_FMT_FLAGS_RELATIVE_BRANCH \| DIS_FMT_FLAGS_ADDR_LEFT,
611	NULL /pfnGetSymbol/, NULL /pvUser/);
612	#else
613	AssertReleaseFailed(); /* Shouldn't ever get here (DISInstrEx() returning VERR_NOT_SUPPORTED). */
614	#endif
615	break;
616	default:
617	break;
618	}
619
620	if (cch + 2 <= cbOutput)
621	{
622	pszOutput[cch++] = '\n';
623	pszOutput[cch] = '\0';
624	}
625	}
626	return rc;
627	}
628	#endif /* DIS_CORE_ONLY */
629

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

source: vbox/trunk/src/VBox/Disassembler/Disasm.cpp@ 102948

Download in other formats: