tstDisasm-2.cpp@ 50079

Last change on this file since 50079 was 48948, checked in by vboxsync, 11 years ago
Disassembler: Whitespace and svn:keyword cleanups by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 22.0 KB

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

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

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

Download in other formats: