VirtualBox

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

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

Disassember: Continue separation of the common disassembler and x86 specific parts, bugref:10394
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 21.4 KB
Line 
1/* $Id: Disasm.cpp 99236 2023-03-30 15:30:26Z 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 */
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 return disInitializeStateX86(pDis, enmCpuMode, fFilter);
315}
316
317
318/**
319 * Disassembles on instruction, details in @a pDis and length in @a pcbInstr.
320 *
321 * @returns VBox status code.
322 * @param uInstrAddr Address of the instruction to decode. What this means
323 * is left to the pfnReadBytes function.
324 * @param enmCpuMode The CPU mode. DISCPUMODE_32BIT, DISCPUMODE_16BIT, or DISCPUMODE_64BIT.
325 * @param pfnReadBytes Callback for reading instruction bytes.
326 * @param fFilter Instruction type filter.
327 * @param pvUser User argument for the instruction reader. (Ends up in pvUser.)
328 * @param pDis Pointer to disassembler state (output).
329 * @param pcbInstr Where to store the size of the instruction. (This
330 * is also stored in PDISSTATE::cbInstr.) Optional.
331 */
332DISDECL(int) DISInstrEx(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, uint32_t fFilter,
333 PFNDISREADBYTES pfnReadBytes, void *pvUser,
334 PDISSTATE pDis, uint32_t *pcbInstr)
335{
336
337 PCDISOPCODE paOneByteMap = disInitializeState(pDis, uInstrAddr, enmCpuMode, fFilter, pfnReadBytes, pvUser);
338 disPrefetchBytes(pDis);
339 return disInstrWorkerX86(pDis, paOneByteMap, pcbInstr);
340}
341
342
343/**
344 * Disassembles on instruction partially or fully from prefetched bytes, details
345 * in @a pDis and length in @a pcbInstr.
346 *
347 * @returns VBox status code.
348 * @param uInstrAddr Address of the instruction to decode. What this means
349 * is left to the pfnReadBytes function.
350 * @param enmCpuMode The CPU mode. DISCPUMODE_32BIT, DISCPUMODE_16BIT, or DISCPUMODE_64BIT.
351 * @param pvPrefetched Pointer to the prefetched bytes.
352 * @param cbPrefetched The number of valid bytes pointed to by @a
353 * pbPrefetched.
354 * @param pfnReadBytes Callback for reading instruction bytes.
355 * @param fFilter Instruction type filter.
356 * @param pvUser User argument for the instruction reader. (Ends up in pvUser.)
357 * @param pDis Pointer to disassembler state (output).
358 * @param pcbInstr Where to store the size of the instruction. (This
359 * is also stored in PDISSTATE::cbInstr.) Optional.
360 */
361DISDECL(int) DISInstrWithPrefetchedBytes(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, uint32_t fFilter,
362 void const *pvPrefetched, size_t cbPretched,
363 PFNDISREADBYTES pfnReadBytes, void *pvUser,
364 PDISSTATE pDis, uint32_t *pcbInstr)
365{
366 PCDISOPCODE paOneByteMap = disInitializeState(pDis, uInstrAddr, enmCpuMode, fFilter, pfnReadBytes, pvUser);
367
368 if (!cbPretched)
369 disPrefetchBytes(pDis);
370 else
371 {
372 if (cbPretched >= sizeof(pDis->u.abInstr))
373 {
374 memcpy(pDis->u.abInstr, pvPrefetched, sizeof(pDis->u.abInstr));
375 pDis->cbCachedInstr = (uint8_t)sizeof(pDis->u.abInstr);
376 }
377 else
378 {
379 memcpy(pDis->u.abInstr, pvPrefetched, cbPretched);
380 pDis->cbCachedInstr = (uint8_t)cbPretched;
381 }
382 }
383
384 return disInstrWorkerX86(pDis, paOneByteMap, pcbInstr);
385}
386
387
388/**
389 * Parses one guest instruction.
390 *
391 * The result is found in pDis and pcbInstr.
392 *
393 * @returns VBox status code.
394 * @param uInstrAddr Address of the instruction to decode. What this means
395 * is left to the pfnReadBytes function.
396 * @param enmCpuMode The CPU mode. DISCPUMODE_32BIT, DISCPUMODE_16BIT, or DISCPUMODE_64BIT.
397 * @param pfnReadBytes Callback for reading instruction bytes.
398 * @param pvUser User argument for the instruction reader. (Ends up in pvUser.)
399 * @param pDis Pointer to disassembler state (output).
400 * @param pcbInstr Where to store the size of the instruction.
401 * NULL is allowed. This is also stored in
402 * PDISSTATE::cbInstr.
403 */
404DISDECL(int) DISInstrWithReader(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, PFNDISREADBYTES pfnReadBytes, void *pvUser,
405 PDISSTATE pDis, uint32_t *pcbInstr)
406{
407 return DISInstrEx(uInstrAddr, enmCpuMode, DISOPTYPE_ALL, pfnReadBytes, pvUser, pDis, pcbInstr);
408}
409
410
411/**
412 * Parses one guest instruction.
413 *
414 * The result is found in pDis and pcbInstr.
415 *
416 * @returns VBox status code.
417 * @param pvInstr Address of the instruction to decode. This is a
418 * real address in the current context that can be
419 * accessed without faulting. (Consider
420 * DISInstrWithReader if this isn't the case.)
421 * @param enmCpuMode The CPU mode. DISCPUMODE_32BIT, DISCPUMODE_16BIT, or DISCPUMODE_64BIT.
422 * @param pfnReadBytes Callback for reading instruction bytes.
423 * @param pvUser User argument for the instruction reader. (Ends up in pvUser.)
424 * @param pDis Pointer to disassembler state (output).
425 * @param pcbInstr Where to store the size of the instruction.
426 * NULL is allowed. This is also stored in
427 * PDISSTATE::cbInstr.
428 */
429DISDECL(int) DISInstr(const void *pvInstr, DISCPUMODE enmCpuMode, PDISSTATE pDis, uint32_t *pcbInstr)
430{
431 return DISInstrEx((uintptr_t)pvInstr, enmCpuMode, DISOPTYPE_ALL, NULL /*pfnReadBytes*/, NULL /*pvUser*/, pDis, pcbInstr);
432}
433
434
435#ifndef DIS_CORE_ONLY
436/**
437 * Disassembles one instruction
438 *
439 * @returns VBox error code
440 * @param pvInstr Pointer to the instruction to disassemble.
441 * @param enmCpuMode The CPU state.
442 * @param pDis The disassembler state (output).
443 * @param pcbInstr Where to store the size of the instruction. NULL is
444 * allowed.
445 * @param pszOutput Storage for disassembled instruction
446 * @param cbOutput Size of the output buffer.
447 *
448 * @todo Define output callback.
449 */
450DISDECL(int) DISInstrToStr(void const *pvInstr, DISCPUMODE enmCpuMode, PDISSTATE pDis, uint32_t *pcbInstr,
451 char *pszOutput, size_t cbOutput)
452{
453 return DISInstrToStrEx((uintptr_t)pvInstr, enmCpuMode, NULL, NULL, DISOPTYPE_ALL,
454 pDis, pcbInstr, pszOutput, cbOutput);
455}
456
457
458/**
459 * Disassembles one instruction with a byte fetcher caller.
460 *
461 * @returns VBox error code
462 * @param uInstrAddr Pointer to the structure to disassemble.
463 * @param enmCpuMode The CPU mode.
464 * @param pfnCallback The byte fetcher callback.
465 * @param pvUser The user argument (found in
466 * DISSTATE::pvUser).
467 * @param pDis The disassembler state (output).
468 * @param pcbInstr Where to store the size of the instruction. NULL is
469 * allowed.
470 * @param pszOutput Storage for disassembled instruction.
471 * @param cbOutput Size of the output buffer.
472 *
473 * @todo Define output callback.
474 */
475DISDECL(int) DISInstrToStrWithReader(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, PFNDISREADBYTES pfnReadBytes, void *pvUser,
476 PDISSTATE pDis, uint32_t *pcbInstr, char *pszOutput, size_t cbOutput)
477
478{
479 return DISInstrToStrEx(uInstrAddr, enmCpuMode, pfnReadBytes, pvUser, DISOPTYPE_ALL,
480 pDis, pcbInstr, pszOutput, cbOutput);
481}
482
483
484/**
485 * Disassembles one instruction; only fully disassembly an instruction if it matches the filter criteria
486 *
487 * @returns VBox error code
488 * @param uInstrAddr Pointer to the structure to disassemble.
489 * @param enmCpuMode The CPU mode.
490 * @param pfnCallback The byte fetcher callback.
491 * @param uFilter Instruction filter.
492 * @param pDis Where to return the disassembled instruction info.
493 * @param pcbInstr Where to store the size of the instruction. NULL is
494 * allowed.
495 * @param pszOutput Storage for disassembled instruction.
496 * @param cbOutput Size of the output buffer.
497 *
498 * @todo Define output callback.
499 */
500DISDECL(int) DISInstrToStrEx(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode,
501 PFNDISREADBYTES pfnReadBytes, void *pvUser, uint32_t uFilter,
502 PDISSTATE pDis, uint32_t *pcbInstr, char *pszOutput, size_t cbOutput)
503{
504 /* Don't filter if formatting is desired. */
505 if (uFilter != DISOPTYPE_ALL && pszOutput && cbOutput)
506 uFilter = DISOPTYPE_ALL;
507
508 int rc = DISInstrEx(uInstrAddr, enmCpuMode, uFilter, pfnReadBytes, pvUser, pDis, pcbInstr);
509 if (RT_SUCCESS(rc) && pszOutput && cbOutput)
510 {
511 size_t cch = DISFormatYasmEx(pDis, pszOutput, cbOutput,
512 DIS_FMT_FLAGS_BYTES_LEFT | DIS_FMT_FLAGS_BYTES_BRACKETS | DIS_FMT_FLAGS_BYTES_SPACED
513 | DIS_FMT_FLAGS_RELATIVE_BRANCH | DIS_FMT_FLAGS_ADDR_LEFT,
514 NULL /*pfnGetSymbol*/, NULL /*pvUser*/);
515 if (cch + 2 <= cbOutput)
516 {
517 pszOutput[cch++] = '\n';
518 pszOutput[cch] = '\0';
519 }
520 }
521 return rc;
522}
523#endif /* DIS_CORE_ONLY */
524
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