VirtualBox

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

Last change on this file since 99239 was 99239, checked in by vboxsync, 2 years ago

Disassembler: Make it possible to build the disassembler library without x86/amd64 support, bugref:10394
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 21.7 KB
Line 
1/* $Id: Disasm.cpp 99239 2023-03-30 15:46:48Z 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.215389.xyz.
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 */
52static 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->u.abInstr[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->u.abInstr[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::u.abInstr 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::u.abInstr 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 */
88DECLHIDDEN(void) disReadMore(PDISSTATE pDis, uint8_t offInstr, uint8_t cbMin)
89{
90 Assert(cbMin + offInstr <= sizeof(pDis->u.abInstr));
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 u.abInstr is already zeroed by the
111 * DISInstrEx API.)
112 */
113 int rc = pDis->pfnReadBytes(pDis, offInstr, cbMin, sizeof(pDis->u.abInstr) - offInstr);
114 if (RT_SUCCESS(rc))
115 {
116 Assert(pDis->cbCachedInstr >= offInstr + cbMin);
117 Assert(pDis->cbCachedInstr <= sizeof(pDis->u.abInstr));
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 */
135DECLHIDDEN(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->u.abInstr[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->u.abInstr) - offInstr);
146 if (cbLeft > 0)
147 return pDis->u.abInstr[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 */
160DECLHIDDEN(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->u.abInstr[offInstr];
167#else
168 return RT_MAKE_U16(pDis->u.abInstr[offInstr], pDis->u.abInstr[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->u.abInstr) - offInstr);
175 switch (cbLeft)
176 {
177 case 1:
178 return pDis->u.abInstr[offInstr];
179 default:
180 if (cbLeft >= 2)
181 return RT_MAKE_U16(pDis->u.abInstr[offInstr], pDis->u.abInstr[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 */
195DECLHIDDEN(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->u.abInstr[offInstr];
202#else
203 return RT_MAKE_U32_FROM_U8(pDis->u.abInstr[offInstr ], pDis->u.abInstr[offInstr + 1],
204 pDis->u.abInstr[offInstr + 2], pDis->u.abInstr[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->u.abInstr) - offInstr);
211 switch (cbLeft)
212 {
213 case 1:
214 return RT_MAKE_U32_FROM_U8(pDis->u.abInstr[offInstr], 0, 0, 0);
215 case 2:
216 return RT_MAKE_U32_FROM_U8(pDis->u.abInstr[offInstr], pDis->u.abInstr[offInstr + 1], 0, 0);
217 case 3:
218 return RT_MAKE_U32_FROM_U8(pDis->u.abInstr[offInstr], pDis->u.abInstr[offInstr + 1], pDis->u.abInstr[offInstr + 2], 0);
219 default:
220 if (cbLeft >= 4)
221 return RT_MAKE_U32_FROM_U8(pDis->u.abInstr[offInstr ], pDis->u.abInstr[offInstr + 1],
222 pDis->u.abInstr[offInstr + 2], pDis->u.abInstr[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 */
236DECLHIDDEN(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->u.abInstr[offInstr];
243#else
244 return RT_MAKE_U64_FROM_U8(pDis->u.abInstr[offInstr ], pDis->u.abInstr[offInstr + 1],
245 pDis->u.abInstr[offInstr + 2], pDis->u.abInstr[offInstr + 3],
246 pDis->u.abInstr[offInstr + 4], pDis->u.abInstr[offInstr + 5],
247 pDis->u.abInstr[offInstr + 6], pDis->u.abInstr[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->u.abInstr) - offInstr);
254 switch (cbLeft)
255 {
256 case 1:
257 return RT_MAKE_U64_FROM_U8(pDis->u.abInstr[offInstr], 0, 0, 0, 0, 0, 0, 0);
258 case 2:
259 return RT_MAKE_U64_FROM_U8(pDis->u.abInstr[offInstr], pDis->u.abInstr[offInstr + 1], 0, 0, 0, 0, 0, 0);
260 case 3:
261 return RT_MAKE_U64_FROM_U8(pDis->u.abInstr[offInstr ], pDis->u.abInstr[offInstr + 1],
262 pDis->u.abInstr[offInstr + 2], 0, 0, 0, 0, 0);
263 case 4:
264 return RT_MAKE_U64_FROM_U8(pDis->u.abInstr[offInstr ], pDis->u.abInstr[offInstr + 1],
265 pDis->u.abInstr[offInstr + 2], pDis->u.abInstr[offInstr + 3],
266 0, 0, 0, 0);
267 case 5:
268 return RT_MAKE_U64_FROM_U8(pDis->u.abInstr[offInstr ], pDis->u.abInstr[offInstr + 1],
269 pDis->u.abInstr[offInstr + 2], pDis->u.abInstr[offInstr + 3],
270 pDis->u.abInstr[offInstr + 4], 0, 0, 0);
271 case 6:
272 return RT_MAKE_U64_FROM_U8(pDis->u.abInstr[offInstr ], pDis->u.abInstr[offInstr + 1],
273 pDis->u.abInstr[offInstr + 2], pDis->u.abInstr[offInstr + 3],
274 pDis->u.abInstr[offInstr + 4], pDis->u.abInstr[offInstr + 5],
275 0, 0);
276 case 7:
277 return RT_MAKE_U64_FROM_U8(pDis->u.abInstr[offInstr ], pDis->u.abInstr[offInstr + 1],
278 pDis->u.abInstr[offInstr + 2], pDis->u.abInstr[offInstr + 3],
279 pDis->u.abInstr[offInstr + 4], pDis->u.abInstr[offInstr + 5],
280 pDis->u.abInstr[offInstr + 6], 0);
281 default:
282 if (cbLeft >= 8)
283 return RT_MAKE_U64_FROM_U8(pDis->u.abInstr[offInstr ], pDis->u.abInstr[offInstr + 1],
284 pDis->u.abInstr[offInstr + 2], pDis->u.abInstr[offInstr + 3],
285 pDis->u.abInstr[offInstr + 4], pDis->u.abInstr[offInstr + 5],
286 pDis->u.abInstr[offInstr + 6], pDis->u.abInstr[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 */
303DECL_FORCE_INLINE(PCDISOPCODE)
304disInitializeState(PDISSTATE pDis, RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, uint32_t fFilter,
305 PFNDISREADBYTES pfnReadBytes, void *pvUser)
306{
307 RT_ZERO(*pDis);
308
309 pDis->rc = VINF_SUCCESS;
310 pDis->uInstrAddr = uInstrAddr;
311 pDis->pfnReadBytes = pfnReadBytes ? pfnReadBytes : disReadBytesDefault;
312 pDis->pvUser = pvUser;
313 pDis->uCpuMode = (uint8_t)enmCpuMode;
314#if defined(VBOX_DIS_WITH_X86_AMD64)
315 return disInitializeStateX86(pDis, enmCpuMode, fFilter);
316#else
317 return VERR_NOT_SUPPORTED;
318#endif
319}
320
321
322/**
323 * Disassembles on instruction, details in @a pDis and length in @a pcbInstr.
324 *
325 * @returns VBox status code.
326 * @param uInstrAddr Address of the instruction to decode. What this means
327 * is left to the pfnReadBytes function.
328 * @param enmCpuMode The CPU mode. DISCPUMODE_32BIT, DISCPUMODE_16BIT, or DISCPUMODE_64BIT.
329 * @param pfnReadBytes Callback for reading instruction bytes.
330 * @param fFilter Instruction type filter.
331 * @param pvUser User argument for the instruction reader. (Ends up in pvUser.)
332 * @param pDis Pointer to disassembler state (output).
333 * @param pcbInstr Where to store the size of the instruction. (This
334 * is also stored in PDISSTATE::cbInstr.) Optional.
335 */
336DISDECL(int) DISInstrEx(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, uint32_t fFilter,
337 PFNDISREADBYTES pfnReadBytes, void *pvUser,
338 PDISSTATE pDis, uint32_t *pcbInstr)
339{
340
341 PCDISOPCODE paOneByteMap = disInitializeState(pDis, uInstrAddr, enmCpuMode, fFilter, pfnReadBytes, pvUser);
342 disPrefetchBytes(pDis);
343#if defined(VBOX_DIS_WITH_X86_AMD64)
344 return disInstrWorkerX86(pDis, paOneByteMap, pcbInstr);
345#else
346 return VERR_NOT_SUPPORTED;
347#endif
348}
349
350
351/**
352 * Disassembles on instruction partially or fully from prefetched bytes, details
353 * in @a pDis and length in @a pcbInstr.
354 *
355 * @returns VBox status code.
356 * @param uInstrAddr Address of the instruction to decode. What this means
357 * is left to the pfnReadBytes function.
358 * @param enmCpuMode The CPU mode. DISCPUMODE_32BIT, DISCPUMODE_16BIT, or DISCPUMODE_64BIT.
359 * @param pvPrefetched Pointer to the prefetched bytes.
360 * @param cbPrefetched The number of valid bytes pointed to by @a
361 * pbPrefetched.
362 * @param pfnReadBytes Callback for reading instruction bytes.
363 * @param fFilter Instruction type filter.
364 * @param pvUser User argument for the instruction reader. (Ends up in pvUser.)
365 * @param pDis Pointer to disassembler state (output).
366 * @param pcbInstr Where to store the size of the instruction. (This
367 * is also stored in PDISSTATE::cbInstr.) Optional.
368 */
369DISDECL(int) DISInstrWithPrefetchedBytes(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, uint32_t fFilter,
370 void const *pvPrefetched, size_t cbPretched,
371 PFNDISREADBYTES pfnReadBytes, void *pvUser,
372 PDISSTATE pDis, uint32_t *pcbInstr)
373{
374 PCDISOPCODE paOneByteMap = disInitializeState(pDis, uInstrAddr, enmCpuMode, fFilter, pfnReadBytes, pvUser);
375
376 if (!cbPretched)
377 disPrefetchBytes(pDis);
378 else
379 {
380 if (cbPretched >= sizeof(pDis->u.abInstr))
381 {
382 memcpy(pDis->u.abInstr, pvPrefetched, sizeof(pDis->u.abInstr));
383 pDis->cbCachedInstr = (uint8_t)sizeof(pDis->u.abInstr);
384 }
385 else
386 {
387 memcpy(pDis->u.abInstr, pvPrefetched, cbPretched);
388 pDis->cbCachedInstr = (uint8_t)cbPretched;
389 }
390 }
391
392#if defined(VBOX_DIS_WITH_X86_AMD64)
393 return disInstrWorkerX86(pDis, paOneByteMap, pcbInstr);
394#else
395 return VERR_NOT_SUPPORTED;
396#endif
397}
398
399
400/**
401 * Parses one guest instruction.
402 *
403 * The result is found in pDis and pcbInstr.
404 *
405 * @returns VBox status code.
406 * @param uInstrAddr Address of the instruction to decode. What this means
407 * is left to the pfnReadBytes function.
408 * @param enmCpuMode The CPU mode. DISCPUMODE_32BIT, DISCPUMODE_16BIT, or DISCPUMODE_64BIT.
409 * @param pfnReadBytes Callback for reading instruction bytes.
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.
413 * NULL is allowed. This is also stored in
414 * PDISSTATE::cbInstr.
415 */
416DISDECL(int) DISInstrWithReader(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, PFNDISREADBYTES pfnReadBytes, void *pvUser,
417 PDISSTATE pDis, uint32_t *pcbInstr)
418{
419 return DISInstrEx(uInstrAddr, enmCpuMode, DISOPTYPE_ALL, pfnReadBytes, pvUser, pDis, pcbInstr);
420}
421
422
423/**
424 * Parses one guest instruction.
425 *
426 * The result is found in pDis and pcbInstr.
427 *
428 * @returns VBox status code.
429 * @param pvInstr Address of the instruction to decode. This is a
430 * real address in the current context that can be
431 * accessed without faulting. (Consider
432 * DISInstrWithReader if this isn't the case.)
433 * @param enmCpuMode The CPU mode. DISCPUMODE_32BIT, DISCPUMODE_16BIT, or DISCPUMODE_64BIT.
434 * @param pfnReadBytes Callback for reading instruction bytes.
435 * @param pvUser User argument for the instruction reader. (Ends up in pvUser.)
436 * @param pDis Pointer to disassembler state (output).
437 * @param pcbInstr Where to store the size of the instruction.
438 * NULL is allowed. This is also stored in
439 * PDISSTATE::cbInstr.
440 */
441DISDECL(int) DISInstr(const void *pvInstr, DISCPUMODE enmCpuMode, PDISSTATE pDis, uint32_t *pcbInstr)
442{
443 return DISInstrEx((uintptr_t)pvInstr, enmCpuMode, DISOPTYPE_ALL, NULL /*pfnReadBytes*/, NULL /*pvUser*/, pDis, pcbInstr);
444}
445
446
447#ifndef DIS_CORE_ONLY
448/**
449 * Disassembles one instruction
450 *
451 * @returns VBox error code
452 * @param pvInstr Pointer to the instruction to disassemble.
453 * @param enmCpuMode The CPU state.
454 * @param pDis The disassembler state (output).
455 * @param pcbInstr Where to store the size of the instruction. NULL is
456 * allowed.
457 * @param pszOutput Storage for disassembled instruction
458 * @param cbOutput Size of the output buffer.
459 *
460 * @todo Define output callback.
461 */
462DISDECL(int) DISInstrToStr(void const *pvInstr, DISCPUMODE enmCpuMode, PDISSTATE pDis, uint32_t *pcbInstr,
463 char *pszOutput, size_t cbOutput)
464{
465 return DISInstrToStrEx((uintptr_t)pvInstr, enmCpuMode, NULL, NULL, DISOPTYPE_ALL,
466 pDis, pcbInstr, pszOutput, cbOutput);
467}
468
469
470/**
471 * Disassembles one instruction with a byte fetcher caller.
472 *
473 * @returns VBox error code
474 * @param uInstrAddr Pointer to the structure to disassemble.
475 * @param enmCpuMode The CPU mode.
476 * @param pfnCallback The byte fetcher callback.
477 * @param pvUser The user argument (found in
478 * DISSTATE::pvUser).
479 * @param pDis The disassembler state (output).
480 * @param pcbInstr Where to store the size of the instruction. NULL is
481 * allowed.
482 * @param pszOutput Storage for disassembled instruction.
483 * @param cbOutput Size of the output buffer.
484 *
485 * @todo Define output callback.
486 */
487DISDECL(int) DISInstrToStrWithReader(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, PFNDISREADBYTES pfnReadBytes, void *pvUser,
488 PDISSTATE pDis, uint32_t *pcbInstr, char *pszOutput, size_t cbOutput)
489
490{
491 return DISInstrToStrEx(uInstrAddr, enmCpuMode, pfnReadBytes, pvUser, DISOPTYPE_ALL,
492 pDis, pcbInstr, pszOutput, cbOutput);
493}
494
495
496/**
497 * Disassembles one instruction; only fully disassembly an instruction if it matches the filter criteria
498 *
499 * @returns VBox error code
500 * @param uInstrAddr Pointer to the structure to disassemble.
501 * @param enmCpuMode The CPU mode.
502 * @param pfnCallback The byte fetcher callback.
503 * @param uFilter Instruction filter.
504 * @param pDis Where to return the disassembled instruction info.
505 * @param pcbInstr Where to store the size of the instruction. NULL is
506 * allowed.
507 * @param pszOutput Storage for disassembled instruction.
508 * @param cbOutput Size of the output buffer.
509 *
510 * @todo Define output callback.
511 */
512DISDECL(int) DISInstrToStrEx(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode,
513 PFNDISREADBYTES pfnReadBytes, void *pvUser, uint32_t uFilter,
514 PDISSTATE pDis, uint32_t *pcbInstr, char *pszOutput, size_t cbOutput)
515{
516 /* Don't filter if formatting is desired. */
517 if (uFilter != DISOPTYPE_ALL && pszOutput && cbOutput)
518 uFilter = DISOPTYPE_ALL;
519
520 int rc = DISInstrEx(uInstrAddr, enmCpuMode, uFilter, pfnReadBytes, pvUser, pDis, pcbInstr);
521 if (RT_SUCCESS(rc) && pszOutput && cbOutput)
522 {
523 size_t cch = DISFormatYasmEx(pDis, pszOutput, cbOutput,
524 DIS_FMT_FLAGS_BYTES_LEFT | DIS_FMT_FLAGS_BYTES_BRACKETS | DIS_FMT_FLAGS_BYTES_SPACED
525 | DIS_FMT_FLAGS_RELATIVE_BRANCH | DIS_FMT_FLAGS_ADDR_LEFT,
526 NULL /*pfnGetSymbol*/, NULL /*pvUser*/);
527 if (cch + 2 <= cbOutput)
528 {
529 pszOutput[cch++] = '\n';
530 pszOutput[cch] = '\0';
531 }
532 }
533 return rc;
534}
535#endif /* DIS_CORE_ONLY */
536
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette