Disasm.cpp

Last change on this file was 106061, checked in by vboxsync, 3 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: 24.4 KB

Line
1	/* $Id: Disasm.cpp 106061 2024-09-16 14:03:52Z vboxsync $ */
2	/** @file
3	* VBox disassembler - Disassemble and optionally format.
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_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->aParams[0].uValue = UINT64_C(0xb1b1b1b1b1b1b1b1);
311	pDis->aParams[1].uValue = UINT64_C(0xb2b2b2b2b2b2b2b2);
312	pDis->aParams[2].uValue = UINT64_C(0xb3b3b3b3b3b3b3b3);
313	pDis->aParams[3].uValue = UINT64_C(0xb4b4b4b4b4b4b4b4);
314	#endif
315
316	pDis->rc = VINF_SUCCESS;
317	pDis->uInstrAddr = uInstrAddr;
318	pDis->pfnReadBytes = pfnReadBytes ? pfnReadBytes : disReadBytesDefault;
319	pDis->pvUser = pvUser;
320	pDis->uCpuMode = (uint8_t)enmCpuMode;
321
322	switch (enmCpuMode)
323	{
324	case DISCPUMODE_16BIT:
325	case DISCPUMODE_32BIT:
326	case DISCPUMODE_64BIT:
327	#if defined(VBOX_DIS_WITH_X86_AMD64)
328	return disInitializeStateX86(pDis, enmCpuMode, fFilter);
329	#else
330	return NULL;
331	#endif
332	case DISCPUMODE_ARMV8_A64:
333	case DISCPUMODE_ARMV8_A32:
334	case DISCPUMODE_ARMV8_T32:
335	#if defined(VBOX_DIS_WITH_ARMV8)
336	return disInitializeStateArmV8(pDis, enmCpuMode, fFilter);
337	#else
338	return NULL;
339	#endif
340	default:
341	break;
342	}
343
344	AssertReleaseFailed(); /* Should never get here. */
345	return NULL;
346	}
347
348
349	/**
350	* Disassembles on instruction, details in @a pDis and length in @a pcbInstr.
351	*
352	* @returns VBox status code.
353	* @param uInstrAddr Address of the instruction to decode. What this means
354	* is left to the pfnReadBytes function.
355	* @param enmCpuMode The CPU mode. DISCPUMODE_32BIT, DISCPUMODE_16BIT, or DISCPUMODE_64BIT.
356	* @param pfnReadBytes Callback for reading instruction bytes.
357	* @param fFilter Instruction type filter.
358	* @param pvUser User argument for the instruction reader. (Ends up in pvUser.)
359	* @param pDis Pointer to disassembler state (output).
360	* @param pcbInstr Where to store the size of the instruction. (This
361	* is also stored in PDISSTATE::cbInstr.) Optional.
362	*/
363	DISDECL(int) DISInstrEx(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, uint32_t fFilter,
364	PFNDISREADBYTES pfnReadBytes, void *pvUser,
365	PDISSTATE pDis, uint32_t *pcbInstr)
366	{
367
368	PCDISOPCODE paOneByteMap = disInitializeState(pDis, uInstrAddr, enmCpuMode, fFilter, pfnReadBytes, pvUser);
369	disPrefetchBytes(pDis);
370
371	switch (enmCpuMode)
372	{
373	case DISCPUMODE_16BIT:
374	case DISCPUMODE_32BIT:
375	case DISCPUMODE_64BIT:
376	#if defined(VBOX_DIS_WITH_X86_AMD64)
377	return disInstrWorkerX86(pDis, paOneByteMap, pcbInstr);
378	#else
379	return VERR_NOT_SUPPORTED;
380	#endif
381	case DISCPUMODE_ARMV8_A64:
382	case DISCPUMODE_ARMV8_A32:
383	case DISCPUMODE_ARMV8_T32:
384	#if defined(VBOX_DIS_WITH_ARMV8)
385	return disInstrWorkerArmV8(pDis, paOneByteMap, pcbInstr);
386	#else
387	return VERR_NOT_SUPPORTED;
388	#endif
389	default:
390	break;
391	}
392
393	AssertReleaseFailed(); /* Should never get here. */
394	return VERR_INTERNAL_ERROR;
395	}
396
397
398	/**
399	* Disassembles on instruction partially or fully from prefetched bytes, details
400	* in @a pDis and length in @a pcbInstr.
401	*
402	* @returns VBox status code.
403	* @param uInstrAddr Address of the instruction to decode. What this means
404	* is left to the pfnReadBytes function.
405	* @param enmCpuMode The CPU mode. DISCPUMODE_32BIT, DISCPUMODE_16BIT, or DISCPUMODE_64BIT.
406	* @param pvPrefetched Pointer to the prefetched bytes.
407	* @param cbPrefetched The number of valid bytes pointed to by @a
408	* pbPrefetched.
409	* @param pfnReadBytes Callback for reading instruction bytes.
410	* @param fFilter Instruction type filter.
411	* @param pvUser User argument for the instruction reader. (Ends up in pvUser.)
412	* @param pDis Pointer to disassembler state (output).
413	* @param pcbInstr Where to store the size of the instruction. (This
414	* is also stored in PDISSTATE::cbInstr.) Optional.
415	*/
416	DISDECL(int) DISInstrWithPrefetchedBytes(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, uint32_t fFilter,
417	void const *pvPrefetched, size_t cbPretched,
418	PFNDISREADBYTES pfnReadBytes, void *pvUser,
419	PDISSTATE pDis, uint32_t *pcbInstr)
420	{
421	PCDISOPCODE paOneByteMap = disInitializeState(pDis, uInstrAddr, enmCpuMode, fFilter, pfnReadBytes, pvUser);
422
423	if (!cbPretched)
424	disPrefetchBytes(pDis);
425	else
426	{
427	if (cbPretched >= sizeof(pDis->Instr.ab))
428	{
429	memcpy(pDis->Instr.ab, pvPrefetched, sizeof(pDis->Instr.ab));
430	pDis->cbCachedInstr = (uint8_t)sizeof(pDis->Instr.ab);
431	}
432	else
433	{
434	memcpy(pDis->Instr.ab, pvPrefetched, cbPretched);
435	pDis->cbCachedInstr = (uint8_t)cbPretched;
436	}
437	}
438
439	switch (enmCpuMode)
440	{
441	case DISCPUMODE_16BIT:
442	case DISCPUMODE_32BIT:
443	case DISCPUMODE_64BIT:
444	#if defined(VBOX_DIS_WITH_X86_AMD64)
445	return disInstrWorkerX86(pDis, paOneByteMap, pcbInstr);
446	#else
447	return VERR_NOT_SUPPORTED;
448	#endif
449	case DISCPUMODE_ARMV8_A64:
450	case DISCPUMODE_ARMV8_A32:
451	case DISCPUMODE_ARMV8_T32:
452	#if defined(VBOX_DIS_WITH_ARMV8)
453	return disInstrWorkerArmV8(pDis, paOneByteMap, pcbInstr);
454	#else
455	return VERR_NOT_SUPPORTED;
456	#endif
457	default:
458	break;
459	}
460
461	AssertReleaseFailed(); /* Should never get here. */
462	return VERR_INTERNAL_ERROR;
463	}
464
465
466	/**
467	* Parses one guest instruction.
468	*
469	* The result is found in pDis and pcbInstr.
470	*
471	* @returns VBox status code.
472	* @param uInstrAddr Address of the instruction to decode. What this means
473	* is left to the pfnReadBytes function.
474	* @param enmCpuMode The CPU mode. DISCPUMODE_32BIT, DISCPUMODE_16BIT, or DISCPUMODE_64BIT.
475	* @param pfnReadBytes Callback for reading instruction bytes.
476	* @param pvUser User argument for the instruction reader. (Ends up in pvUser.)
477	* @param pDis Pointer to disassembler state (output).
478	* @param pcbInstr Where to store the size of the instruction.
479	* NULL is allowed. This is also stored in
480	* PDISSTATE::cbInstr.
481	*/
482	DISDECL(int) DISInstrWithReader(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, PFNDISREADBYTES pfnReadBytes, void *pvUser,
483	PDISSTATE pDis, uint32_t *pcbInstr)
484	{
485	return DISInstrEx(uInstrAddr, enmCpuMode, DISOPTYPE_ALL, pfnReadBytes, pvUser, pDis, pcbInstr);
486	}
487
488
489	/**
490	* Parses one guest instruction.
491	*
492	* The result is found in pDis and pcbInstr.
493	*
494	* @returns VBox status code.
495	* @param pvInstr Address of the instruction to decode. This is a
496	* real address in the current context that can be
497	* accessed without faulting. (Consider
498	* DISInstrWithReader if this isn't the case.)
499	* @param enmCpuMode The CPU mode. DISCPUMODE_32BIT, DISCPUMODE_16BIT, or DISCPUMODE_64BIT.
500	* @param pfnReadBytes Callback for reading instruction bytes.
501	* @param pvUser User argument for the instruction reader. (Ends up in pvUser.)
502	* @param pDis Pointer to disassembler state (output).
503	* @param pcbInstr Where to store the size of the instruction.
504	* NULL is allowed. This is also stored in
505	* PDISSTATE::cbInstr.
506	*/
507	DISDECL(int) DISInstr(const void pvInstr, DISCPUMODE enmCpuMode, PDISSTATE pDis, uint32_t pcbInstr)
508	{
509	return DISInstrEx((uintptr_t)pvInstr, enmCpuMode, DISOPTYPE_ALL, NULL /pfnReadBytes/, NULL /pvUser/, pDis, pcbInstr);
510	}
511
512
513	#ifndef DIS_CORE_ONLY
514	/**
515	* Disassembles one instruction
516	*
517	* @returns VBox error code
518	* @param pvInstr Pointer to the instruction to disassemble.
519	* @param enmCpuMode The CPU state.
520	* @param pDis The disassembler state (output).
521	* @param pcbInstr Where to store the size of the instruction. NULL is
522	* allowed.
523	* @param pszOutput Storage for disassembled instruction
524	* @param cbOutput Size of the output buffer.
525	*
526	* @todo Define output callback.
527	*/
528	DISDECL(int) DISInstrToStr(void const pvInstr, DISCPUMODE enmCpuMode, PDISSTATE pDis, uint32_t pcbInstr,
529	char *pszOutput, size_t cbOutput)
530	{
531	return DISInstrToStrEx((uintptr_t)pvInstr, enmCpuMode, NULL, NULL, DISOPTYPE_ALL,
532	pDis, pcbInstr, pszOutput, cbOutput);
533	}
534
535
536	/**
537	* Disassembles one instruction with a byte fetcher caller.
538	*
539	* @returns VBox error code
540	* @param uInstrAddr Pointer to the structure to disassemble.
541	* @param enmCpuMode The CPU mode.
542	* @param pfnCallback The byte fetcher callback.
543	* @param pvUser The user argument (found in
544	* DISSTATE::pvUser).
545	* @param pDis The disassembler state (output).
546	* @param pcbInstr Where to store the size of the instruction. NULL is
547	* allowed.
548	* @param pszOutput Storage for disassembled instruction.
549	* @param cbOutput Size of the output buffer.
550	*
551	* @todo Define output callback.
552	*/
553	DISDECL(int) DISInstrToStrWithReader(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, PFNDISREADBYTES pfnReadBytes, void *pvUser,
554	PDISSTATE pDis, uint32_t pcbInstr, char pszOutput, size_t cbOutput)
555
556	{
557	return DISInstrToStrEx(uInstrAddr, enmCpuMode, pfnReadBytes, pvUser, DISOPTYPE_ALL,
558	pDis, pcbInstr, pszOutput, cbOutput);
559	}
560
561
562	/**
563	* Disassembles one instruction; only fully disassembly an instruction if it matches the filter criteria
564	*
565	* @returns VBox error code
566	* @param uInstrAddr Pointer to the structure to disassemble.
567	* @param enmCpuMode The CPU mode.
568	* @param pfnCallback The byte fetcher callback.
569	* @param uFilter Instruction filter.
570	* @param pDis Where to return the disassembled instruction info.
571	* @param pcbInstr Where to store the size of the instruction. NULL is
572	* allowed.
573	* @param pszOutput Storage for disassembled instruction.
574	* @param cbOutput Size of the output buffer.
575	*
576	* @todo Define output callback.
577	*/
578	DISDECL(int) DISInstrToStrEx(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode,
579	PFNDISREADBYTES pfnReadBytes, void *pvUser, uint32_t uFilter,
580	PDISSTATE pDis, uint32_t pcbInstr, char pszOutput, size_t cbOutput)
581	{
582	/* Don't filter if formatting is desired. */
583	if (uFilter != DISOPTYPE_ALL && pszOutput && cbOutput)
584	uFilter = DISOPTYPE_ALL;
585
586	int rc = DISInstrEx(uInstrAddr, enmCpuMode, uFilter, pfnReadBytes, pvUser, pDis, pcbInstr);
587	if (RT_SUCCESS(rc) && pszOutput && cbOutput)
588	{
589	size_t cch = 0;
590
591	switch (enmCpuMode)
592	{
593	case DISCPUMODE_16BIT:
594	case DISCPUMODE_32BIT:
595	case DISCPUMODE_64BIT:
596	#if defined(VBOX_DIS_WITH_X86_AMD64)
597	cch = DISFormatYasmEx(pDis, pszOutput, cbOutput,
598	DIS_FMT_FLAGS_BYTES_LEFT \| DIS_FMT_FLAGS_BYTES_BRACKETS \| DIS_FMT_FLAGS_BYTES_SPACED
599	\| DIS_FMT_FLAGS_RELATIVE_BRANCH \| DIS_FMT_FLAGS_ADDR_LEFT,
600	NULL /pfnGetSymbol/, NULL /pvUser/);
601	#else
602	AssertReleaseFailed(); /* Shouldn't ever get here (DISInstrEx() returning VERR_NOT_SUPPORTED). */
603	#endif
604	break;
605	case DISCPUMODE_ARMV8_A64:
606	case DISCPUMODE_ARMV8_A32:
607	case DISCPUMODE_ARMV8_T32:
608	#if defined(VBOX_DIS_WITH_ARMV8)
609	cch = DISFormatArmV8Ex(pDis, pszOutput, cbOutput,
610	DIS_FMT_FLAGS_BYTES_LEFT \| DIS_FMT_FLAGS_BYTES_BRACKETS \| DIS_FMT_FLAGS_BYTES_SPACED
611	\| DIS_FMT_FLAGS_RELATIVE_BRANCH \| DIS_FMT_FLAGS_ADDR_LEFT,
612	NULL /pfnGetSymbol/, NULL /pvUser/);
613	#else
614	AssertReleaseFailed(); /* Shouldn't ever get here (DISInstrEx() returning VERR_NOT_SUPPORTED). */
615	#endif
616	break;
617	default:
618	break;
619	}
620
621	if (cch + 2 <= cbOutput)
622	{
623	pszOutput[cch++] = '\n';
624	pszOutput[cch] = '\0';
625	}
626	}
627	return rc;
628	}
629	#endif /* DIS_CORE_ONLY */
630

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

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

Download in other formats: