tstDisasm-2.cpp@ 85546

Last change on this file since 85546 was 82968, checked in by vboxsync, 5 years ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 22.4 KB

Line
1	/* $Id: tstDisasm-2.cpp 82968 2020-02-04 10:35:17Z vboxsync $ */
2	/** @file
3	* Testcase - Generic Disassembler Tool.
4	*/
5
6	/*
7	* Copyright (C) 2008-2020 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#include <VBox/dis.h>
23	#include <VBox/err.h>
24	#include <iprt/alloc.h>
25	#include <iprt/assert.h>
26	#include <iprt/initterm.h>
27	#include <iprt/getopt.h>
28	#include <iprt/file.h>
29	#include <iprt/path.h>
30	#include <iprt/stream.h>
31	#include <iprt/string.h>
32	#include <iprt/ctype.h>
33
34
35	/*********************************************************************************************************************************
36	* Structures and Typedefs *
37	*********************************************************************************************************************************/
38	typedef enum { kAsmStyle_Default, kAsmStyle_yasm, kAsmStyle_masm, kAsmStyle_gas, kAsmStyle_invalid } ASMSTYLE;
39	typedef enum { kUndefOp_Fail, kUndefOp_All, kUndefOp_DefineByte, kUndefOp_End } UNDEFOPHANDLING;
40
41	typedef struct MYDISSTATE
42	{
43	DISSTATE Dis;
44	uint64_t uAddress; /*< The current instruction address. /
45	uint8_t pbInstr; /< The current instruction (pointer). /
46	uint32_t cbInstr; /*< The size of the current instruction. /
47	bool fUndefOp; /*< Whether the current instruction is really an undefined opcode./
48	UNDEFOPHANDLING enmUndefOp; /*< How to treat undefined opcodes. /
49	int rc; /*< Set if we hit EOF. /
50	size_t cbLeft; /*< The number of bytes left. (read) /
51	uint8_t pbNext; /< The next byte. (read) /
52	uint64_t uNextAddr; /*< The address of the next byte. (read) /
53	char szLine[256]; /*< The disassembler text output. /
54	} MYDISSTATE;
55	typedef MYDISSTATE *PMYDISSTATE;
56
57
58
59	/**
60	* Default style.
61	*
62	* @param pState The disassembler state.
63	*/
64	static void MyDisasDefaultFormatter(PMYDISSTATE pState)
65	{
66	RTPrintf("%s", pState->szLine);
67	}
68
69
70	/**
71	* Yasm style.
72	*
73	* @param pState The disassembler state.
74	*/
75	static void MyDisasYasmFormatter(PMYDISSTATE pState)
76	{
77	char szTmp[256];
78	#if 0
79	/* a very quick hack. */
80	strcpy(szTmp, RTStrStripL(strchr(pState->szLine, ':') + 1));
81
82	char *psz = strrchr(szTmp, '[');
83	*psz = '\0';
84	RTStrStripR(szTmp);
85
86	psz = strstr(szTmp, " ptr ");
87	if (psz)
88	memset(psz, ' ', 5);
89
90	char *pszEnd = strchr(szTmp, '\0');
91	while (pszEnd - &szTmp[0] < 71)
92	*pszEnd++ = ' ';
93	*pszEnd = '\0';
94
95	#else
96	size_t cch = DISFormatYasmEx(&pState->Dis, szTmp, sizeof(szTmp),
97	DIS_FMT_FLAGS_STRICT \| DIS_FMT_FLAGS_ADDR_RIGHT \| DIS_FMT_FLAGS_ADDR_COMMENT
98	\| DIS_FMT_FLAGS_BYTES_RIGHT \| DIS_FMT_FLAGS_BYTES_COMMENT \| DIS_FMT_FLAGS_BYTES_SPACED,
99	NULL, NULL);
100	Assert(cch < sizeof(szTmp));
101	while (cch < 71)
102	szTmp[cch++] = ' ';
103	szTmp[cch] = '\0';
104	#endif
105
106	RTPrintf(" %s ; %s", szTmp, pState->szLine);
107	}
108
109
110	/**
111	* Masm style.
112	*
113	* @param pState The disassembler state.
114	*/
115	static void MyDisasMasmFormatter(PMYDISSTATE pState)
116	{
117	RTPrintf("masm not implemented: %s", pState->szLine);
118	}
119
120
121	/**
122	* This is a temporary workaround for catching a few illegal opcodes
123	* that the disassembler is currently letting thru, just enough to make
124	* the assemblers happy.
125	*
126	* We're too close to a release to dare mess with these things now as
127	* they may consequences for performance and let alone introduce bugs.
128	*
129	* @returns true if it's valid. false if it isn't.
130	*
131	* @param pDis The disassembler output.
132	*/
133	static bool MyDisasIsValidInstruction(DISSTATE const *pDis)
134	{
135	switch (pDis->pCurInstr->uOpcode)
136	{
137	/* These doesn't take memory operands. */
138	case OP_MOV_CR:
139	case OP_MOV_DR:
140	case OP_MOV_TR:
141	if (pDis->ModRM.Bits.Mod != 3)
142	return false;
143	break;
144
145	/* The 0x8f /0 variant of this instruction doesn't get its /r value verified. */
146	case OP_POP:
147	if ( pDis->bOpCode == 0x8f
148	&& pDis->ModRM.Bits.Reg != 0)
149	return false;
150	break;
151
152	/* The 0xc6 /0 and 0xc7 /0 variants of this instruction don't get their /r values verified. */
153	case OP_MOV:
154	if ( ( pDis->bOpCode == 0xc6
155	\|\| pDis->bOpCode == 0xc7)
156	&& pDis->ModRM.Bits.Reg != 0)
157	return false;
158	break;
159
160	default:
161	break;
162	}
163
164	return true;
165	}
166
167
168	/**
169	* @interface_method_impl{FNDISREADBYTES}
170	*/
171	static DECLCALLBACK(int) MyDisasInstrRead(PDISSTATE pDis, uint8_t offInstr, uint8_t cbMinRead, uint8_t cbMaxRead)
172	{
173	RT_NOREF1(cbMaxRead);
174	PMYDISSTATE pState = (PMYDISSTATE)pDis;
175	RTUINTPTR uSrcAddr = pState->Dis.uInstrAddr + offInstr;
176	if (RT_LIKELY( pState->uNextAddr == uSrcAddr
177	&& pState->cbLeft >= cbMinRead))
178	{
179	/*
180	* Straight forward reading.
181	*/
182	//size_t cbToRead = cbMaxRead;
183	size_t cbToRead = cbMinRead;
184	memcpy(&pState->Dis.abInstr[offInstr], pState->pbNext, cbToRead);
185	pState->Dis.cbCachedInstr = offInstr + (uint8_t)cbToRead;
186	pState->pbNext += cbToRead;
187	pState->cbLeft -= cbToRead;
188	pState->uNextAddr += cbToRead;
189	return VINF_SUCCESS;
190	}
191
192	if (pState->uNextAddr == uSrcAddr)
193	{
194	/*
195	* Reading too much.
196	*/
197	if (pState->cbLeft > 0)
198	{
199	memcpy(&pState->Dis.abInstr[offInstr], pState->pbNext, pState->cbLeft);
200	offInstr += (uint8_t)pState->cbLeft;
201	cbMinRead -= (uint8_t)pState->cbLeft;
202	pState->pbNext += pState->cbLeft;
203	pState->uNextAddr += pState->cbLeft;
204	pState->cbLeft = 0;
205	}
206	memset(&pState->Dis.abInstr[offInstr], 0xcc, cbMinRead);
207	pState->rc = VERR_EOF;
208	}
209	else
210	{
211	/*
212	* Non-sequential read, that's an error.
213	*/
214	RTStrmPrintf(g_pStdErr, "Reading before current instruction!\n");
215	memset(&pState->Dis.abInstr[offInstr], 0x90, cbMinRead);
216	pState->rc = VERR_INTERNAL_ERROR;
217	}
218	pState->Dis.cbCachedInstr = offInstr + cbMinRead;
219	return pState->rc;
220	}
221
222
223	/**
224	* Disassembles a block of memory.
225	*
226	* @returns VBox status code.
227	* @param argv0 Program name (for errors and warnings).
228	* @param enmCpuMode The cpu mode to disassemble in.
229	* @param uAddress The address we're starting to disassemble at.
230	* @param uHighlightAddr The address of the instruction that should be
231	* highlighted. Pass UINT64_MAX to keep quiet.
232	* @param pbFile Where to start disassemble.
233	* @param cbFile How much to disassemble.
234	* @param enmStyle The assembly output style.
235	* @param fListing Whether to print in a listing like mode.
236	* @param enmUndefOp How to deal with undefined opcodes.
237	*/
238	static int MyDisasmBlock(const char *argv0, DISCPUMODE enmCpuMode, uint64_t uAddress,
239	uint64_t uHighlightAddr, uint8_t *pbFile, size_t cbFile,
240	ASMSTYLE enmStyle, bool fListing, UNDEFOPHANDLING enmUndefOp)
241	{
242	RT_NOREF1(fListing);
243
244	/*
245	* Initialize the CPU context.
246	*/
247	MYDISSTATE State;
248	State.uAddress = uAddress;
249	State.pbInstr = pbFile;
250	State.cbInstr = 0;
251	State.enmUndefOp = enmUndefOp;
252	State.rc = VINF_SUCCESS;
253	State.cbLeft = cbFile;
254	State.pbNext = pbFile;
255	State.uNextAddr = uAddress;
256
257	void (*pfnFormatter)(PMYDISSTATE pState);
258	switch (enmStyle)
259	{
260	case kAsmStyle_Default:
261	pfnFormatter = MyDisasDefaultFormatter;
262	break;
263
264	case kAsmStyle_yasm:
265	RTPrintf(" BITS %d\n", enmCpuMode == DISCPUMODE_16BIT ? 16 : enmCpuMode == DISCPUMODE_32BIT ? 32 : 64);
266	pfnFormatter = MyDisasYasmFormatter;
267	break;
268
269	case kAsmStyle_masm:
270	pfnFormatter = MyDisasMasmFormatter;
271	break;
272
273	default:
274	AssertFailedReturn(VERR_INTERNAL_ERROR);
275	}
276
277	/*
278	* The loop.
279	*/
280	int rcRet = VINF_SUCCESS;
281	while (State.cbLeft > 0)
282	{
283	/*
284	* Disassemble it.
285	*/
286	State.cbInstr = 0;
287	State.cbLeft += State.pbNext - State.pbInstr;
288	State.uNextAddr = State.uAddress;
289	State.pbNext = State.pbInstr;
290
291	int rc = DISInstrToStrWithReader(State.uAddress, enmCpuMode, MyDisasInstrRead, &State,
292	&State.Dis, &State.cbInstr, State.szLine, sizeof(State.szLine));
293	if ( RT_SUCCESS(rc)
294	\|\| ( ( rc == VERR_DIS_INVALID_OPCODE
295	\|\| rc == VERR_DIS_GEN_FAILURE)
296	&& State.enmUndefOp == kUndefOp_DefineByte))
297	{
298	State.fUndefOp = rc == VERR_DIS_INVALID_OPCODE
299	\|\| rc == VERR_DIS_GEN_FAILURE
300	\|\| State.Dis.pCurInstr->uOpcode == OP_INVALID
301	\|\| State.Dis.pCurInstr->uOpcode == OP_ILLUD2
302	\|\| ( State.enmUndefOp == kUndefOp_DefineByte
303	&& !MyDisasIsValidInstruction(&State.Dis));
304	if (State.fUndefOp && State.enmUndefOp == kUndefOp_DefineByte)
305	{
306	if (!State.cbInstr)
307	{
308	State.Dis.abInstr[0] = 0;
309	State.Dis.pfnReadBytes(&State.Dis, 0, 1, 1);
310	State.cbInstr = 1;
311	}
312	RTPrintf(" db");
313	for (unsigned off = 0; off < State.cbInstr; off++)
314	RTPrintf(off ? ", %03xh" : " %03xh", State.Dis.abInstr[off]);
315	RTPrintf(" ; %s\n", State.szLine);
316	}
317	else if (!State.fUndefOp && State.enmUndefOp == kUndefOp_All)
318	{
319	RTPrintf("%s: error at %#RX64: unexpected valid instruction (op=%d)\n", argv0, State.uAddress, State.Dis.pCurInstr->uOpcode);
320	pfnFormatter(&State);
321	rcRet = VERR_GENERAL_FAILURE;
322	}
323	else if (State.fUndefOp && State.enmUndefOp == kUndefOp_Fail)
324	{
325	RTPrintf("%s: error at %#RX64: undefined opcode (op=%d)\n", argv0, State.uAddress, State.Dis.pCurInstr->uOpcode);
326	pfnFormatter(&State);
327	rcRet = VERR_GENERAL_FAILURE;
328	}
329	else
330	{
331	/* Use db for odd encodings that we can't make the assembler use. */
332	if ( State.enmUndefOp == kUndefOp_DefineByte
333	&& DISFormatYasmIsOddEncoding(&State.Dis))
334	{
335	RTPrintf(" db");
336	for (unsigned off = 0; off < State.cbInstr; off++)
337	RTPrintf(off ? ", %03xh" : " %03xh", State.Dis.abInstr[off]);
338	RTPrintf(" ; ");
339	}
340
341	pfnFormatter(&State);
342	}
343	}
344	else
345	{
346	State.cbInstr = State.pbNext - State.pbInstr;
347	if (!State.cbLeft)
348	RTPrintf("%s: error at %#RX64: read beyond the end (%Rrc)\n", argv0, State.uAddress, rc);
349	else if (State.cbInstr)
350	RTPrintf("%s: error at %#RX64: %Rrc cbInstr=%d\n", argv0, State.uAddress, rc, State.cbInstr);
351	else
352	{
353	RTPrintf("%s: error at %#RX64: %Rrc cbInstr=%d!\n", argv0, State.uAddress, rc, State.cbInstr);
354	if (rcRet == VINF_SUCCESS)
355	rcRet = rc;
356	break;
357	}
358	}
359
360	/* Highlight this instruction? */
361	if (uHighlightAddr - State.uAddress < State.cbInstr)
362	RTPrintf("; ^^^^^^^^^^^^^^^^^^^^^\n");
363
364	/* Check that the size-only mode returns the smae size on success. */
365	if (RT_SUCCESS(rc))
366	{
367	uint32_t cbInstrOnly = 32;
368	uint8_t abInstr[sizeof(State.Dis.abInstr)];
369	memcpy(abInstr, State.Dis.abInstr, sizeof(State.Dis.abInstr));
370	int rcOnly = DISInstrWithPrefetchedBytes(State.uAddress, enmCpuMode, 0 /fFilter - none /,
371	abInstr, State.Dis.cbCachedInstr, MyDisasInstrRead, &State,
372	&State.Dis, &cbInstrOnly);
373	if ( rcOnly != rc
374	\|\| cbInstrOnly != State.cbInstr)
375	{
376	RTPrintf("; Instruction size only check failed rc=%Rrc cbInstrOnly=%#x exepcted %Rrc and %#x\n",
377	rcOnly, cbInstrOnly, rc, State.cbInstr);
378	rcRet = VERR_GENERAL_FAILURE;
379	break;
380	}
381	}
382
383	/* next */
384	State.uAddress += State.cbInstr;
385	State.pbInstr += State.cbInstr;
386	}
387
388	return rcRet;
389	}
390
391	/**
392	* Converts a hex char to a number.
393	*
394	* @returns 0..15 on success, -1 on failure.
395	* @param ch The character.
396	*/
397	static int HexDigitToNum(char ch)
398	{
399	switch (ch)
400	{
401	case '0': return 0;
402	case '1': return 1;
403	case '2': return 2;
404	case '3': return 3;
405	case '4': return 4;
406	case '5': return 5;
407	case '6': return 6;
408	case '7': return 7;
409	case '8': return 8;
410	case '9': return 9;
411	case 'A':
412	case 'a': return 0xa;
413	case 'B':
414	case 'b': return 0xb;
415	case 'C':
416	case 'c': return 0xc;
417	case 'D':
418	case 'd': return 0xd;
419	case 'E':
420	case 'e': return 0xe;
421	case 'F':
422	case 'f': return 0xf;
423	default:
424	RTPrintf("error: Invalid hex digit '%c'\n", ch);
425	return -1;
426	}
427	}
428
429	/**
430	* Prints usage info.
431	*
432	* @returns 1.
433	* @param argv0 The program name.
434	*/
435	static int Usage(const char *argv0)
436	{
437	RTStrmPrintf(g_pStdErr,
438	"usage: %s [options] <file1> [file2..fileN]\n"
439	" or: %s [options] <-x\|--hex-bytes> <hex byte> [more hex..]\n"
440	" or: %s <--help\|-h>\n"
441	"\n"
442	"Options:\n"
443	" --address\|-a <address>\n"
444	" The base address. Default: 0\n"
445	" --max-bytes\|-b <bytes>\n"
446	" The maximum number of bytes to disassemble. Default: 1GB\n"
447	" --cpumode\|-c <16\|32\|64>\n"
448	" The cpu mode. Default: 32\n"
449	" --listing\|-l, --no-listing\|-L\n"
450	" Enables or disables listing mode. Default: --no-listing\n"
451	" --offset\|-o <offset>\n"
452	" The file offset at which to start disassembling. Default: 0\n"
453	" --style\|-s <default\|yasm\|masm>\n"
454	" The assembly output style. Default: default\n"
455	" --undef-op\|-u <fail\|all\|db>\n"
456	" How to treat undefined opcodes. Default: fail\n"
457	, argv0, argv0, argv0);
458	return 1;
459	}
460
461
462	int main(int argc, char **argv)
463	{
464	RTR3InitExe(argc, &argv, 0);
465	const char * const argv0 = RTPathFilename(argv[0]);
466
467	/* options */
468	uint64_t uAddress = 0;
469	uint64_t uHighlightAddr = UINT64_MAX;
470	ASMSTYLE enmStyle = kAsmStyle_Default;
471	UNDEFOPHANDLING enmUndefOp = kUndefOp_Fail;
472	bool fListing = true;
473	DISCPUMODE enmCpuMode = DISCPUMODE_32BIT;
474	RTFOFF off = 0;
475	RTFOFF cbMax = _1G;
476	bool fHexBytes = false;
477
478	/*
479	* Parse arguments.
480	*/
481	static const RTGETOPTDEF g_aOptions[] =
482	{
483	{ "--address", 'a', RTGETOPT_REQ_UINT64 },
484	{ "--cpumode", 'c', RTGETOPT_REQ_UINT32 },
485	{ "--bytes", 'b', RTGETOPT_REQ_INT64 },
486	{ "--listing", 'l', RTGETOPT_REQ_NOTHING },
487	{ "--no-listing", 'L', RTGETOPT_REQ_NOTHING },
488	{ "--offset", 'o', RTGETOPT_REQ_INT64 },
489	{ "--style", 's', RTGETOPT_REQ_STRING },
490	{ "--undef-op", 'u', RTGETOPT_REQ_STRING },
491	{ "--hex-bytes", 'x', RTGETOPT_REQ_NOTHING },
492	};
493
494	int ch;
495	RTGETOPTUNION ValueUnion;
496	RTGETOPTSTATE GetState;
497	RTGetOptInit(&GetState, argc, argv, g_aOptions, RT_ELEMENTS(g_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
498	while ( (ch = RTGetOpt(&GetState, &ValueUnion))
499	&& ch != VINF_GETOPT_NOT_OPTION)
500	{
501	switch (ch)
502	{
503	case 'a':
504	uAddress = ValueUnion.u64;
505	break;
506
507	case 'b':
508	cbMax = ValueUnion.i64;
509	break;
510
511	case 'c':
512	if (ValueUnion.u32 == 16)
513	enmCpuMode = DISCPUMODE_16BIT;
514	else if (ValueUnion.u32 == 32)
515	enmCpuMode = DISCPUMODE_32BIT;
516	else if (ValueUnion.u32 == 64)
517	enmCpuMode = DISCPUMODE_64BIT;
518	else
519	{
520	RTStrmPrintf(g_pStdErr, "%s: Invalid CPU mode value %RU32\n", argv0, ValueUnion.u32);
521	return 1;
522	}
523	break;
524
525	case 'h':
526	return Usage(argv0);
527
528	case 'l':
529	fListing = true;
530	break;
531
532	case 'L':
533	fListing = false;
534	break;
535
536	case 'o':
537	off = ValueUnion.i64;
538	break;
539
540	case 's':
541	if (!strcmp(ValueUnion.psz, "default"))
542	enmStyle = kAsmStyle_Default;
543	else if (!strcmp(ValueUnion.psz, "yasm"))
544	enmStyle = kAsmStyle_yasm;
545	else if (!strcmp(ValueUnion.psz, "masm"))
546	{
547	enmStyle = kAsmStyle_masm;
548	RTStrmPrintf(g_pStdErr, "%s: masm style isn't implemented yet\n", argv0);
549	return 1;
550	}
551	else
552	{
553	RTStrmPrintf(g_pStdErr, "%s: unknown assembly style: %s\n", argv0, ValueUnion.psz);
554	return 1;
555	}
556	break;
557
558	case 'u':
559	if (!strcmp(ValueUnion.psz, "fail"))
560	enmUndefOp = kUndefOp_Fail;
561	else if (!strcmp(ValueUnion.psz, "all"))
562	enmUndefOp = kUndefOp_All;
563	else if (!strcmp(ValueUnion.psz, "db"))
564	enmUndefOp = kUndefOp_DefineByte;
565	else
566	{
567	RTStrmPrintf(g_pStdErr, "%s: unknown undefined opcode handling method: %s\n", argv0, ValueUnion.psz);
568	return 1;
569	}
570	break;
571
572	case 'x':
573	fHexBytes = true;
574	break;
575
576	case 'V':
577	RTPrintf("$Revision: 82968 $\n");
578	return 0;
579
580	default:
581	return RTGetOptPrintError(ch, &ValueUnion);
582	}
583	}
584	int iArg = GetState.iNext - 1; /** @todo Not pretty, add RTGetOptInit flag for this. */
585	if (iArg >= argc)
586	return Usage(argv0);
587
588	int rc = VINF_SUCCESS;
589	if (fHexBytes)
590	{
591	/*
592	* Convert the remaining arguments from a hex byte string into
593	* a buffer that we disassemble.
594	*/
595	size_t cb = 0;
596	uint8_t *pb = NULL;
597	for ( ; iArg < argc; iArg++)
598	{
599	char ch2;
600	const char *psz = argv[iArg];
601	while (*psz)
602	{
603	/** @todo this stuff belongs in IPRT, same stuff as mac address reading. Could be reused for IPv6 with a different item size.*/
604	/* skip white space, and for the benefit of linux panics '<' and '>'. */
605	while (RT_C_IS_SPACE(ch2 = *psz) \|\| ch2 == '<' \|\| ch2 == '>' \|\| ch2 == ',' \|\| ch2 == ';')
606	{
607	if (ch2 == '<')
608	uHighlightAddr = uAddress + cb;
609	psz++;
610	}
611
612	if (ch2 == '0' && (psz[1] == 'x' \|\| psz[1] == 'X'))
613	{
614	psz += 2;
615	ch2 = *psz;
616	}
617
618	if (!ch2)
619	break;
620
621	/* one digit followed by a space or EOS, or two digits. */
622	int iNum = HexDigitToNum(*psz++);
623	if (iNum == -1)
624	return 1;
625	if (!RT_C_IS_SPACE(ch2 = *psz) && ch2 != '\0' && ch2 != '>' && ch2 != ',' && ch2 != ';')
626	{
627	int iDigit = HexDigitToNum(*psz++);
628	if (iDigit == -1)
629	return 1;
630	iNum = iNum * 16 + iDigit;
631	}
632
633	/* add the byte */
634	if (!(cb % 4 /64/))
635	{
636	pb = (uint8_t *)RTMemRealloc(pb, cb + 64);
637	if (!pb)
638	{
639	RTPrintf("%s: error: RTMemRealloc failed\n", argv[0]);
640	return 1;
641	}
642	}
643	pb[cb++] = (uint8_t)iNum;
644	}
645	}
646
647	/*
648	* Disassemble it.
649	*/
650	rc = MyDisasmBlock(argv0, enmCpuMode, uAddress, uHighlightAddr, pb, cb, enmStyle, fListing, enmUndefOp);
651	}
652	else
653	{
654	/*
655	* Process the files.
656	*/
657	for ( ; iArg < argc; iArg++)
658	{
659	/*
660	* Read the file into memory.
661	*/
662	void *pvFile;
663	size_t cbFile;
664	rc = RTFileReadAllEx(argv[iArg], off, cbMax, RTFILE_RDALL_O_DENY_NONE, &pvFile, &cbFile);
665	if (RT_FAILURE(rc))
666	{
667	RTStrmPrintf(g_pStdErr, "%s: %s: %Rrc\n", argv0, argv[iArg], rc);
668	break;
669	}
670
671	/*
672	* Disassemble it.
673	*/
674	rc = MyDisasmBlock(argv0, enmCpuMode, uAddress, uHighlightAddr, (uint8_t *)pvFile, cbFile, enmStyle, fListing, enmUndefOp);
675	RTFileReadAllFree(pvFile, cbFile);
676	if (RT_FAILURE(rc))
677	break;
678	}
679	}
680
681	return RT_SUCCESS(rc) ? 0 : 1;
682	}
683

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

source: vbox/trunk/src/VBox/Disassembler/testcase/tstDisasm-2.cpp@ 85546

Download in other formats: