MakeAlternativeSource.cpp@ 45045

Last change on this file since 45045 was 45045, checked in by vboxsync, 12 years ago
MakeAlternativeSource.cpp: off-by-one
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 59.2 KB

Line
1	/* $Id: MakeAlternativeSource.cpp 45045 2013-03-15 07:47:43Z vboxsync $ */
2	/** @file
3	* MakeAlternative - Generate an Alternative BIOS Source that requires less tools.
4	*/
5
6	/*
7	* Copyright (C) 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	/*******************************************************************************
20	* Header Files *
21	*******************************************************************************/
22	#include <iprt/asm.h>
23	#include <iprt/buildconfig.h>
24	#include <iprt/ctype.h>
25	#include <iprt/dbg.h>
26	#include <iprt/file.h>
27	#include <iprt/getopt.h>
28	#include <iprt/initterm.h>
29	#include <iprt/list.h>
30	#include <iprt/mem.h>
31	#include <iprt/message.h>
32	#include <iprt/string.h>
33	#include <iprt/stream.h>
34	#include <iprt/x86.h>
35
36	#include <VBox/dis.h>
37
38
39	/*******************************************************************************
40	* Structures and Typedefs *
41	*******************************************************************************/
42	/**
43	* A BIOS segment.
44	*/
45	typedef struct BIOSSEG
46	{
47	char szName[32];
48	char szClass[32];
49	char szGroup[32];
50	RTFAR16 Address;
51	uint32_t uFlatAddr;
52	uint32_t cb;
53	} BIOSSEG;
54	/** Pointer to a BIOS segment. */
55	typedef BIOSSEG *PBIOSSEG;
56
57
58	/**
59	* A BIOS object file.
60	*/
61	typedef struct BIOSOBJFILE
62	{
63	RTLISTNODE Node;
64	char *pszSource;
65	char *pszObject;
66	} BIOSOBJFILE;
67	/** A BIOS object file. */
68	typedef BIOSOBJFILE *PBIOSOBJFILE;
69
70
71	/**
72	* Pointer to a BIOS map parser handle.
73	*/
74	typedef struct BIOSMAP
75	{
76	/** The stream pointer. */
77	PRTSTREAM hStrm;
78	/** The file name. */
79	const char *pszMapFile;
80	/** Set when EOF has been reached. */
81	bool fEof;
82	/** The current line number (0 based).*/
83	uint32_t iLine;
84	/** The length of the current line. */
85	uint32_t cch;
86	/** The offset of the first non-white character on the line. */
87	uint32_t offNW;
88	/** The line buffer. */
89	char szLine[16384];
90	} BIOSMAP;
91	/** Pointer to a BIOS map parser handle. */
92	typedef BIOSMAP *PBIOSMAP;
93
94
95	/*******************************************************************************
96	* Global Variables *
97	*******************************************************************************/
98	/** The verbosity level.*/
99	static unsigned g_cVerbose = 1 /0/;
100	/** Pointer to the BIOS image. */
101	static uint8_t const *g_pbImg;
102	/** The size of the BIOS image. */
103	static size_t g_cbImg;
104
105	/** Debug module for the map file. */
106	static RTDBGMOD g_hMapMod = NIL_RTDBGMOD;
107	/** The number of BIOS segments found in the map file. */
108	static uint32_t g_cSegs = 0;
109	/** Array of BIOS segments from the map file. */
110	static BIOSSEG g_aSegs[32];
111	/** List of BIOSOBJFILE. */
112	static RTLISTANCHOR g_ObjList;
113
114	/** The output stream. */
115	static PRTSTREAM g_hStrmOutput = NULL;
116
117	/** The type of BIOS we're working on. */
118	static enum BIOSTYPE
119	{
120	kBiosType_System = 0,
121	kBiosType_Vga
122	} g_enmBiosType = kBiosType_System;
123	/** The flat ROM base address. */
124	static uint32_t g_uBiosFlatBase = 0xf0000;
125
126
127	static bool outputPrintfV(const char *pszFormat, va_list va)
128	{
129	int rc = RTStrmPrintfV(g_hStrmOutput, pszFormat, va);
130	if (RT_FAILURE(rc))
131	{
132	RTMsgError("Output error: %Rrc\n", rc);
133	return false;
134	}
135	return true;
136	}
137
138
139	static bool outputPrintf(const char *pszFormat, ...)
140	{
141	va_list va;
142	va_start(va, pszFormat);
143	bool fRc = outputPrintfV(pszFormat, va);
144	va_end(va);
145	return fRc;
146	}
147
148
149	/**
150	* Opens the output file for writing.
151	*
152	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
153	* @param pszOutput Path to the output file.
154	*/
155	static RTEXITCODE OpenOutputFile(const char *pszOutput)
156	{
157	if (!pszOutput)
158	g_hStrmOutput = g_pStdOut;
159	else
160	{
161	int rc = RTStrmOpen(pszOutput, "w", &g_hStrmOutput);
162	if (RT_FAILURE(rc))
163	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to open output file '%s': %Rrc", pszOutput, rc);
164	}
165	return RTEXITCODE_SUCCESS;
166	}
167
168
169	/**
170	* Displays a disassembly error and returns @c false.
171	*
172	* @returns @c false.
173	* @param pszFormat The error format string.
174	* @param ... Format argument.
175	*/
176	static bool disError(const char *pszFormat, ...)
177	{
178	va_list va;
179	va_start(va, pszFormat);
180	RTMsgErrorV(pszFormat, va);
181	va_end(va);
182	return false;
183	}
184
185
186	/**
187	* Output the disassembly file header.
188	*
189	* @returns @c true on success,
190	*/
191	static bool disFileHeader(void)
192	{
193	bool fRc;
194	fRc = outputPrintf("; $Id: MakeAlternativeSource.cpp 45045 2013-03-15 07:47:43Z vboxsync $ \n"
195	";; @file\n"
196	"; Auto Generated source file. Do not edit.\n"
197	";\n"
198	);
199	if (!fRc)
200	return fRc;
201
202	/*
203	* List the header of each source file, up to and including the
204	* copyright notice.
205	*/
206	PBIOSOBJFILE pObjFile;
207	RTListForEach(&g_ObjList, pObjFile, BIOSOBJFILE, Node)
208	{
209	PRTSTREAM hStrm;
210	int rc = RTStrmOpen(pObjFile->pszSource, "r", &hStrm);
211	if (RT_SUCCESS(rc))
212	{
213	fRc = outputPrintf("\n"
214	";\n"
215	"; Source file: %Rbn\n"
216	";\n"
217	, pObjFile->pszSource);
218	uint32_t iLine = 0;
219	bool fSeenCopyright = false;
220	char szLine[4096];
221	while ((rc = RTStrmGetLine(hStrm, szLine, sizeof(szLine))) == VINF_SUCCESS)
222	{
223	iLine++;
224
225	/* Check if we're done. */
226	char *psz = RTStrStrip(szLine);
227	if ( fSeenCopyright
228	&& ( (psz[0] == '*' && psz[1] == '/')
229	\|\| psz[0] == '\0') )
230	break;
231
232	/* Strip comment suffix. */
233	size_t cch = strlen(psz);
234	if (cch >= 2 && psz[cch - 1] == '/' && psz[cch - 2] == '*')
235	{
236	psz[cch - 2] = '\0';
237	RTStrStripR(psz);
238	}
239
240	/* Skip line prefix. */
241	if (psz[0] == '/' && psz[1] == '*')
242	psz += 2;
243	else if (psz[0] == '*')
244	psz += 1;
245	else
246	while (*psz == ';')
247	psz++;
248	if (RT_C_IS_SPACE(*psz))
249	psz++;
250
251	/* Skip the doxygen file tag line. */
252	if (!strcmp(psz, "* @file") \|\| !strcmp(psz, "@file"))
253	continue;
254
255	/* Detect copyright section. */
256	if ( !fSeenCopyright
257	&& ( strstr(psz, "Copyright")
258	\|\| strstr(psz, "copyright")) )
259	fSeenCopyright = true;
260
261	fRc = outputPrintf("; %s\n", psz) && fRc;
262	}
263
264	RTStrmClose(hStrm);
265	if (rc != VINF_SUCCESS)
266	return disError("Error reading '%s': rc=%Rrc iLine=%u", pObjFile->pszSource, rc, iLine);
267	}
268	}
269
270	/*
271	* Set the org.
272	*/
273	fRc = outputPrintf("\n"
274	"\n"
275	"\n"
276	) && fRc;
277	return fRc;
278	}
279
280
281	/**
282	* Checks if a byte sequence could be a string litteral.
283	*
284	* @returns @c true if it is, @c false if it isn't.
285	* @param uFlatAddr The address of the byte sequence.
286	* @param cb The length of the sequence.
287	*/
288	static bool disIsString(uint32_t uFlatAddr, uint32_t cb)
289	{
290	if (cb < 6)
291	return false;
292
293	uint8_t const *pb = &g_pbImg[uFlatAddr - g_uBiosFlatBase];
294	while (cb > 0)
295	{
296	if ( !RT_C_IS_PRINT(*pb)
297	&& *pb != '\r'
298	&& *pb != '\n'
299	&& *pb != '\t')
300	{
301	if (*pb == '\0')
302	{
303	do
304	{
305	pb++;
306	cb--;
307	} while (cb > 0 && *pb == '\0');
308	return cb == 0;
309	}
310	return false;
311	}
312	pb++;
313	cb--;
314	}
315
316	return true;
317	}
318
319
320	/**
321	* Checks if a dword could be a far 16:16 BIOS address.
322	*
323	* @returns @c true if it is, @c false if it isn't.
324	* @param uFlatAddr The address of the dword.
325	*/
326	static bool disIsFarBiosAddr(uint32_t uFlatAddr)
327	{
328	uint16_t const pu16 = (uint16_t const )&g_pbImg[uFlatAddr - g_uBiosFlatBase];
329	if (pu16[1] < 0xf000)
330	return false;
331	if (pu16[1] > 0xfff0)
332	return false;
333	uint32_t uFlatAddr2 = (uint32_t)(pu16[1] << 4) \| pu16[0];
334	if (uFlatAddr2 >= g_uBiosFlatBase + g_cbImg)
335	return false;
336	return true;
337	}
338
339
340	static bool disByteData(uint32_t uFlatAddr, uint32_t cb)
341	{
342	uint8_t const *pb = &g_pbImg[uFlatAddr - g_uBiosFlatBase];
343	size_t cbOnLine = 0;
344	while (cb-- > 0)
345	{
346	bool fRc;
347	if (cbOnLine >= 16)
348	{
349	fRc = outputPrintf("\n"
350	" db 0%02xh", *pb);
351	cbOnLine = 1;
352	}
353	else if (!cbOnLine)
354	{
355	fRc = outputPrintf(" db 0%02xh", *pb);
356	cbOnLine = 1;
357	}
358	else
359	{
360	fRc = outputPrintf(", 0%02xh", *pb);
361	cbOnLine++;
362	}
363	if (!fRc)
364	return false;
365	pb++;
366	}
367	return outputPrintf("\n");
368	}
369
370
371	static bool disWordData(uint32_t uFlatAddr, uint32_t cb)
372	{
373	if (cb & 1)
374	return disError("disWordData expects word aligned size: cb=%#x uFlatAddr=%#x", uFlatAddr, cb);
375
376	uint16_t const pu16 = (uint16_t const )&g_pbImg[uFlatAddr - g_uBiosFlatBase];
377	size_t cbOnLine = 0;
378	while (cb > 0)
379	{
380	bool fRc;
381	if (cbOnLine >= 16)
382	{
383	fRc = outputPrintf("\n"
384	" dw 0%04xh", *pu16);
385	cbOnLine = 2;
386	}
387	else if (!cbOnLine)
388	{
389	fRc = outputPrintf(" dw 0%04xh", *pu16);
390	cbOnLine = 2;
391	}
392	else
393	{
394	fRc = outputPrintf(", 0%04xh", *pu16);
395	cbOnLine += 2;
396	}
397	if (!fRc)
398	return false;
399	pu16++;
400	cb -= 2;
401	}
402	return outputPrintf("\n");
403	}
404
405
406	static bool disDWordData(uint32_t uFlatAddr, uint32_t cb)
407	{
408	if (cb & 3)
409	return disError("disWordData expects dword aligned size: cb=%#x uFlatAddr=%#x", uFlatAddr, cb);
410
411	uint32_t const pu32 = (uint32_t const )&g_pbImg[uFlatAddr - g_uBiosFlatBase];
412	size_t cbOnLine = 0;
413	while (cb > 0)
414	{
415	bool fRc;
416	if (cbOnLine >= 16)
417	{
418	fRc = outputPrintf("\n"
419	" dd 0%08xh", *pu32);
420	cbOnLine = 4;
421	}
422	else if (!cbOnLine)
423	{
424	fRc = outputPrintf(" dd 0%08xh", *pu32);
425	cbOnLine = 4;
426	}
427	else
428	{
429	fRc = outputPrintf(", 0%08xh", *pu32);
430	cbOnLine += 4;
431	}
432	if (!fRc)
433	return false;
434	pu32++;
435	cb -= 4;
436	}
437	return outputPrintf("\n");
438	}
439
440
441	static bool disStringData(uint32_t uFlatAddr, uint32_t cb)
442	{
443	uint8_t const *pb = &g_pbImg[uFlatAddr - g_uBiosFlatBase];
444	uint32_t cchOnLine = 0;
445	while (cb > 0)
446	{
447	/* Line endings and beginnings. */
448	if (cchOnLine >= 72)
449	{
450	if (!outputPrintf("\n"))
451	return false;
452	cchOnLine = 0;
453	}
454	if ( !cchOnLine
455	&& !outputPrintf(" db "))
456	return false;
457
458	/* See how many printable character we've got. */
459	uint32_t cchPrintable = 0;
460	while ( cchPrintable < cb
461	&& RT_C_IS_PRINT(pb[cchPrintable])
462	&& pb[cchPrintable] != '\'')
463	cchPrintable++;
464
465	bool fRc = true;
466	if (cchPrintable)
467	{
468	if (cchPrintable + cchOnLine > 72)
469	cchPrintable = 72 - cchOnLine;
470	if (cchOnLine)
471	{
472	fRc = outputPrintf(", '%.*s'", cchPrintable, pb);
473	cchOnLine += 4 + cchPrintable;
474	}
475	else
476	{
477	fRc = outputPrintf("'%.*s'", cchPrintable, pb);
478	cchOnLine += 2 + cchPrintable;
479	}
480	pb += cchPrintable;
481	cb -= cchPrintable;
482	}
483	else
484	{
485	if (cchOnLine)
486	{
487	fRc = outputPrintf(", 0%02xh", *pb);
488	cchOnLine += 6;
489	}
490	else
491	{
492	fRc = outputPrintf("0%02xh", *pb);
493	cchOnLine += 4;
494	}
495	pb++;
496	cb--;
497	}
498	if (!fRc)
499	return false;
500	}
501	return outputPrintf("\n");
502	}
503
504
505	/**
506	* For dumping a portion of a string table.
507	*
508	* @returns @c true on success, @c false on failure.
509	* @param uFlatAddr The start address.
510	* @param cb The size of the string table.
511	*/
512	static bool disStringsData(uint32_t uFlatAddr, uint32_t cb)
513	{
514	uint8_t const *pb = &g_pbImg[uFlatAddr - g_uBiosFlatBase];
515	uint32_t cchOnLine = 0;
516	uint8_t bPrev = 255;
517	while (cb > 0)
518	{
519	/* Line endings and beginnings. */
520	if ( cchOnLine >= 72
521	\|\| (bPrev == '\0' && *pb != '\0'))
522	{
523	if (!outputPrintf("\n"))
524	return false;
525	cchOnLine = 0;
526	}
527	if ( !cchOnLine
528	&& !outputPrintf(" db "))
529	return false;
530
531	/* See how many printable character we've got. */
532	uint32_t cchPrintable = 0;
533	while ( cchPrintable < cb
534	&& RT_C_IS_PRINT(pb[cchPrintable])
535	&& pb[cchPrintable] != '\'')
536	cchPrintable++;
537
538	bool fRc = true;
539	if (cchPrintable)
540	{
541	if (cchPrintable + cchOnLine > 72)
542	cchPrintable = 72 - cchOnLine;
543	if (cchOnLine)
544	{
545	fRc = outputPrintf(", '%.*s'", cchPrintable, pb);
546	cchOnLine += 4 + cchPrintable;
547	}
548	else
549	{
550	fRc = outputPrintf("'%.*s'", cchPrintable, pb);
551	cchOnLine += 2 + cchPrintable;
552	}
553	pb += cchPrintable;
554	cb -= cchPrintable;
555	}
556	else
557	{
558	if (cchOnLine)
559	{
560	fRc = outputPrintf(", 0%02xh", *pb);
561	cchOnLine += 6;
562	}
563	else
564	{
565	fRc = outputPrintf("0%02xh", *pb);
566	cchOnLine += 4;
567	}
568	pb++;
569	cb--;
570	}
571	if (!fRc)
572	return false;
573	bPrev = pb[-1];
574	}
575	return outputPrintf("\n");
576	}
577
578
579	/**
580	* Minds the gap between two segments.
581	*
582	* Gaps should generally be zero filled.
583	*
584	* @returns @c true on success, @c false on failure.
585	* @param uFlatAddr The address of the gap.
586	* @param cbPadding The size of the gap.
587	*/
588	static bool disCopySegmentGap(uint32_t uFlatAddr, uint32_t cbPadding)
589	{
590	if (g_cVerbose > 0)
591	outputPrintf("\n"
592	" ; Padding %#x bytes at %#x\n", cbPadding, uFlatAddr);
593	uint8_t const *pb = &g_pbImg[uFlatAddr - g_uBiosFlatBase];
594	if (!ASMMemIsAll8(pb, cbPadding, 0))
595	return outputPrintf(" times %u db 0\n", cbPadding);
596
597	return disByteData(uFlatAddr, cbPadding);
598	}
599
600
601	/**
602	* Worker for disGetNextSymbol that only does the looking up, no RTDBSYMBOL::cb
603	* calc.
604	*
605	* @param uFlatAddr The address to start searching at.
606	* @param cbMax The size of the search range.
607	* @param poff Where to return the offset between the symbol
608	* and @a uFlatAddr.
609	* @param pSym Where to return the symbol data.
610	*/
611	static void disGetNextSymbolWorker(uint32_t uFlatAddr, uint32_t cbMax, uint32_t *poff, PRTDBGSYMBOL pSym)
612	{
613	RTINTPTR off = 0;
614	int rc = RTDbgModSymbolByAddr(g_hMapMod, RTDBGSEGIDX_RVA, uFlatAddr, RTDBGSYMADDR_FLAGS_GREATER_OR_EQUAL, &off, pSym);
615	if (RT_SUCCESS(rc))
616	{
617	/* negative offset, indicates beyond. */
618	if (off <= 0)
619	{
620	*poff = (uint32_t)-off;
621	return;
622	}
623
624	outputPrintf(" ; !! RTDbgModSymbolByAddr(,,%#x,,) -> off=%RTptr cb=%RTptr uValue=%RTptr '%s'\n",
625	uFlatAddr, off, pSym->cb, pSym->Value, pSym->szName);
626	}
627	else if (rc != VERR_SYMBOL_NOT_FOUND)
628	outputPrintf(" ; !! RTDbgModSymbolByAddr(,,%#x,,) -> %Rrc\n", uFlatAddr, rc);
629
630	RTStrPrintf(pSym->szName, sizeof(pSym->szName), "_dummy_addr_%#x", uFlatAddr + cbMax);
631	pSym->Value = uFlatAddr + cbMax;
632	pSym->cb = 0;
633	pSym->offSeg = uFlatAddr + cbMax;
634	pSym->iSeg = RTDBGSEGIDX_RVA;
635	pSym->iOrdinal = 0;
636	pSym->fFlags = 0;
637	*poff = cbMax;
638	}
639
640
641	/**
642	* Gets the symbol at or after the given address.
643	*
644	* If there are no symbols in the specified range, @a pSym and @a poff will be
645	* set up to indicate a symbol at the first byte after the range.
646	*
647	* @param uFlatAddr The address to start searching at.
648	* @param cbMax The size of the search range.
649	* @param poff Where to return the offset between the symbol
650	* and @a uFlatAddr.
651	* @param pSym Where to return the symbol data.
652	*/
653	static void disGetNextSymbol(uint32_t uFlatAddr, uint32_t cbMax, uint32_t *poff, PRTDBGSYMBOL pSym)
654	{
655	disGetNextSymbolWorker(uFlatAddr, cbMax, poff, pSym);
656	if ( *poff < cbMax
657	&& pSym->cb == 0)
658	{
659	if (*poff + 1 < cbMax)
660	{
661	uint32_t off2;
662	RTDBGSYMBOL Sym2;
663	disGetNextSymbolWorker(uFlatAddr + poff + 1, cbMax - poff - 1, &off2, &Sym2);
664	pSym->cb = off2 + 1;
665	}
666	else
667	pSym->cb = 1;
668	}
669	if (pSym->cb > cbMax - *poff)
670	pSym->cb = cbMax - *poff;
671
672	if (g_cVerbose > 1)
673	outputPrintf(" ; disGetNextSymbol %#x LB %#x -> off=%#x cb=%RTptr uValue=%RTptr '%s'\n",
674	uFlatAddr, cbMax, *poff, pSym->cb, pSym->Value, pSym->szName);
675
676	}
677
678
679	/**
680	* For dealing with the const segment (string constants).
681	*
682	* @returns @c true on success, @c false on failure.
683	* @param iSeg The segment.
684	*/
685	static bool disConstSegment(uint32_t iSeg)
686	{
687	uint32_t uFlatAddr = g_aSegs[iSeg].uFlatAddr;
688	uint32_t cb = g_aSegs[iSeg].cb;
689
690	while (cb > 0)
691	{
692	uint32_t off;
693	RTDBGSYMBOL Sym;
694	disGetNextSymbol(uFlatAddr, cb, &off, &Sym);
695
696	if (off > 0)
697	{
698	if (!disStringsData(uFlatAddr, off))
699	return false;
700	cb -= off;
701	uFlatAddr += off;
702	off = 0;
703	if (!cb)
704	break;
705	}
706
707	bool fRc;
708	if (off == 0)
709	{
710	size_t cchName = strlen(Sym.szName);
711	fRc = outputPrintf("%s: %*s; %#x LB %#x\n", Sym.szName, cchName < 41 - 2 ? cchName - 41 - 2 : 0, "", uFlatAddr, Sym.cb);
712	if (!fRc)
713	return false;
714	fRc = disStringsData(uFlatAddr, Sym.cb);
715	uFlatAddr += Sym.cb;
716	cb -= Sym.cb;
717	}
718	else
719	{
720	fRc = disStringsData(uFlatAddr, Sym.cb);
721	uFlatAddr += cb;
722	cb = 0;
723	}
724	if (!fRc)
725	return false;
726	}
727
728	return true;
729	}
730
731
732
733	static bool disDataSegment(uint32_t iSeg)
734	{
735	uint32_t uFlatAddr = g_aSegs[iSeg].uFlatAddr;
736	uint32_t cb = g_aSegs[iSeg].cb;
737
738	while (cb > 0)
739	{
740	uint32_t off;
741	RTDBGSYMBOL Sym;
742	disGetNextSymbol(uFlatAddr, cb, &off, &Sym);
743
744	if (off > 0)
745	{
746	if (!disByteData(uFlatAddr, off))
747	return false;
748	cb -= off;
749	uFlatAddr += off;
750	off = 0;
751	if (!cb)
752	break;
753	}
754
755	bool fRc;
756	if (off == 0)
757	{
758	size_t cchName = strlen(Sym.szName);
759	fRc = outputPrintf("%s: %*s; %#x LB %#x\n", Sym.szName, cchName < 41 - 2 ? cchName - 41 - 2 : 0, "", uFlatAddr, Sym.cb);
760	if (!fRc)
761	return false;
762
763	if (Sym.cb == 2)
764	fRc = disWordData(uFlatAddr, 2);
765	//else if (Sym.cb == 4 && disIsFarBiosAddr(uFlatAddr))
766	// fRc = disDWordData(uFlatAddr, 4);
767	else if (Sym.cb == 4)
768	fRc = disDWordData(uFlatAddr, 4);
769	else if (disIsString(uFlatAddr, Sym.cb))
770	fRc = disStringData(uFlatAddr, Sym.cb);
771	else
772	fRc = disByteData(uFlatAddr, Sym.cb);
773
774	uFlatAddr += Sym.cb;
775	cb -= Sym.cb;
776	}
777	else
778	{
779	fRc = disByteData(uFlatAddr, cb);
780	uFlatAddr += cb;
781	cb = 0;
782	}
783	if (!fRc)
784	return false;
785	}
786
787	return true;
788	}
789
790
791	static bool disIsCodeAndAdjustSize(uint32_t uFlatAddr, PRTDBGSYMBOL pSym, PBIOSSEG pSeg)
792	{
793	switch (g_enmBiosType)
794	{
795	/*
796	* This is for the PC BIOS.
797	*/
798	case kBiosType_System:
799	if (!strcmp(pSeg->szName, "BIOSSEG"))
800	{
801	if ( !strcmp(pSym->szName, "rom_fdpt")
802	\|\| !strcmp(pSym->szName, "pmbios_gdt")
803	\|\| !strcmp(pSym->szName, "pmbios_gdt_desc")
804	\|\| !strcmp(pSym->szName, "_pmode_IDT")
805	\|\| !strcmp(pSym->szName, "_rmode_IDT")
806	\|\| !strncmp(pSym->szName, RT_STR_TUPLE("font"))
807	\|\| !strcmp(pSym->szName, "bios_string")
808	\|\| !strcmp(pSym->szName, "vector_table")
809	\|\| !strcmp(pSym->szName, "pci_routing_table_structure")
810	\|\| !strcmp(pSym->szName, "_pci_routing_table")
811	)
812	return false;
813	}
814
815	if (!strcmp(pSym->szName, "cpu_reset"))
816	pSym->cb = RT_MIN(pSym->cb, 5);
817	else if (!strcmp(pSym->szName, "pci_init_end"))
818	pSym->cb = RT_MIN(pSym->cb, 3);
819	break;
820
821	/*
822	* This is for the VGA BIOS.
823	*/
824	case kBiosType_Vga:
825	break;
826	}
827
828	return true;
829	}
830
831
832	static bool disIs16BitCode(const char *pszSymbol)
833	{
834	return true;
835	}
836
837
838	/**
839	* Deals with instructions that YASM will assemble differently than WASM/WCC.
840	*/
841	static size_t disHandleYasmDifferences(PDISCPUSTATE pCpuState, uint32_t uFlatAddr, uint32_t cbInstr,
842	char *pszBuf, size_t cbBuf, size_t cchUsed)
843	{
844	bool fDifferent = DISFormatYasmIsOddEncoding(pCpuState);
845	uint8_t const *pb = &g_pbImg[uFlatAddr - g_uBiosFlatBase];
846
847	/*
848	* Disassembler bugs.
849	*/
850	/** @todo Group 1a and 11 seems to be disassembled incorrectly when
851	* modrm.reg != 0. Those encodings should be invalid AFAICT. */
852
853	if ( ( pCpuState->bOpCode == 0x8f /* group 1a */
854	\|\| pCpuState->bOpCode == 0xc7 /* group 11 */
855	\|\| pCpuState->bOpCode == 0xc6 /* group 11 - not verified */
856	)
857	&& pCpuState->ModRM.Bits.Reg != 0)
858	fDifferent = true;
859	/*
860	* Check these out and consider adding them to DISFormatYasmIsOddEncoding.
861	*/
862	else if ( pb[0] == 0xf3
863	&& pb[1] == 0x66
864	&& pb[2] == 0x6d)
865	fDifferent = true; /* rep insd - prefix switched. */
866	else if ( pb[0] == 0xc6
867	&& pb[1] == 0xc5
868	&& pb[2] == 0xba)
869	fDifferent = true; /* mov ch, 0bah - yasm uses a short sequence: 0xb5 0xba. */
870
871	/*
872	* 32-bit retf.
873	*/
874	else if ( pb[0] == 0x66
875	&& pb[1] == 0xcb)
876	fDifferent = true;
877
878	/*
879	* Handle different stuff.
880	*/
881	if (fDifferent)
882	{
883	disByteData(uFlatAddr, cbInstr); /* lazy bird. */
884
885	if (cchUsed + 2 < cbBuf)
886	{
887	memmove(pszBuf + 2, pszBuf, cchUsed + 1); /* include terminating \0 */
888	cchUsed += 2;
889	}
890
891	pszBuf[0] = ';';
892	pszBuf[1] = ' ';
893	}
894
895	return cchUsed;
896	}
897
898
899	/**
900	* @callback_method_impl{FNDISREADBYTES}
901	*
902	* @remarks @a uSrcAddr is the flat address.
903	*/
904	static DECLCALLBACK(int) disReadOpcodeBytes(PDISCPUSTATE pDis, uint8_t offInstr, uint8_t cbMinRead, uint8_t cbMaxRead)
905	{
906	RTUINTPTR offBios = pDis->uInstrAddr + offInstr - g_uBiosFlatBase;
907	size_t cbToRead = cbMaxRead;
908	if (offBios + cbToRead > g_cbImg)
909	{
910	if (offBios >= g_cbImg)
911	cbToRead = 0;
912	else
913	cbToRead = g_cbImg - offBios;
914	}
915	memcpy(&pDis->abInstr[offInstr], &g_pbImg[offBios], cbToRead);
916	pDis->cbCachedInstr = (uint8_t)(offInstr + cbToRead);
917	return VINF_SUCCESS;
918	}
919
920
921	/**
922	* Disassembles code.
923	*
924	* @returns @c true on success, @c false on failure.
925	* @param uFlatAddr The address where the code starts.
926	* @param cb The amount of code to disassemble.
927	* @param fIs16Bit Is is 16-bit (@c true) or 32-bit (@c false).
928	*/
929	static bool disCode(uint32_t uFlatAddr, uint32_t cb, bool fIs16Bit)
930	{
931	uint8_t const *pb = &g_pbImg[uFlatAddr - g_uBiosFlatBase];
932
933	while (cb > 0)
934	{
935	/* Trailing zero padding detection. */
936	if ( *pb == '\0'
937	&& ASMMemIsAll8(pb, RT_MIN(cb, 8), 0) == NULL)
938	{
939	void *pv = ASMMemIsAll8(pb, cb, 0);
940	uint32_t cbZeros = pv ? (uint32_t)((uint8_t const *)pv - pb) : cb;
941	if (!outputPrintf(" times %#x db 0\n", cbZeros))
942	return false;
943	cb -= cbZeros;
944	pb += cbZeros;
945	uFlatAddr += cbZeros;
946	if ( cb == 2
947	&& pb[0] == 'X'
948	&& pb[1] == 'M')
949	return disStringData(uFlatAddr, cb);
950	}
951	/* Work arounds for switch tables and such (disas assertions). */
952	else if ( 0
953	#if 0
954	\|\| ( pb[0] == 0x11 /* int13_cdemu switch */
955	&& pb[1] == 0xda
956	&& pb[2] == 0x05
957	&& pb[3] == 0xff
958	&& pb[4] == 0xff
959	)
960	#endif
961	\|\| ( pb[0] == 0xb0
962	&& pb[1] == 0x58
963	&& pb[2] == 0xc8
964	&& pb[3] == 0x58
965	&& pb[4] == 0xc8
966	&& pb[5] == 0x58
967	)
968	\|\| ( pb[0] == 0x72 /* _pci16_function switch */
969	&& pb[1] == 0x8d
970	&& pb[2] == 0x8c
971	&& pb[3] == 0x8d
972	&& pb[4] == 0x9f
973	&& pb[5] == 0x8d
974	)
975	\|\| ( pb[0] == 0xd0 /* _int1a_function switch */
976	&& pb[1] == 0x67
977	&& pb[2] == 0xf7
978	&& pb[3] == 0x67
979	&& pb[4] == 0x1c
980	&& pb[5] == 0x68
981	)
982	\|\| ( pb[0] == 0x0b /* _ahci_init byte table */
983	&& pb[1] == 0x05
984	&& pb[2] == 0x04
985	&& pb[3] == 0x03
986	&& pb[4] == 0x02
987	&& pb[5] == 0x01
988	)
989	\|\| ( pb[0] == 0x98 /* bytes after apm_out_str_ */
990	&& pb[1] == 0x8a
991	&& pb[2] == 0x67
992	&& pb[3] == 0x8b)
993	\|\| 0
994	)
995	return disByteData(uFlatAddr, cb);
996	else
997	{
998	unsigned cbInstr;
999	DISCPUSTATE CpuState;
1000	int rc = DISInstrWithReader(uFlatAddr, fIs16Bit ? DISCPUMODE_16BIT : DISCPUMODE_32BIT,
1001	disReadOpcodeBytes, NULL, &CpuState, &cbInstr);
1002	if ( RT_SUCCESS(rc)
1003	&& cbInstr <= cb
1004	&& CpuState.pCurInstr
1005	&& CpuState.pCurInstr->uOpcode != OP_INVALID)
1006	{
1007	char szTmp[4096];
1008	size_t cch = DISFormatYasmEx(&CpuState, szTmp, sizeof(szTmp),
1009	DIS_FMT_FLAGS_STRICT
1010	\| DIS_FMT_FLAGS_BYTES_RIGHT \| DIS_FMT_FLAGS_BYTES_COMMENT \| DIS_FMT_FLAGS_BYTES_SPACED,
1011	NULL, NULL);
1012	cch = disHandleYasmDifferences(&CpuState, uFlatAddr, cbInstr, szTmp, sizeof(szTmp), cch);
1013	Assert(cch < sizeof(szTmp));
1014
1015	if (g_cVerbose > 1)
1016	{
1017	while (cch < 72)
1018	szTmp[cch++] = ' ';
1019	RTStrPrintf(&szTmp[cch], sizeof(szTmp) - cch, "; %#x", uFlatAddr);
1020	}
1021
1022	if (!outputPrintf(" %s\n", szTmp))
1023	return false;
1024	cb -= cbInstr;
1025	pb += cbInstr;
1026	uFlatAddr += cbInstr;
1027	}
1028	else
1029	{
1030	if (!disByteData(uFlatAddr, 1))
1031	return false;
1032	cb--;
1033	pb++;
1034	uFlatAddr++;
1035	}
1036	}
1037	}
1038	return true;
1039	}
1040
1041
1042	static bool disCodeSegment(uint32_t iSeg)
1043	{
1044	uint32_t uFlatAddr = g_aSegs[iSeg].uFlatAddr;
1045	uint32_t cb = g_aSegs[iSeg].cb;
1046
1047	while (cb > 0)
1048	{
1049	uint32_t off;
1050	RTDBGSYMBOL Sym;
1051	disGetNextSymbol(uFlatAddr, cb, &off, &Sym);
1052
1053	if (off > 0)
1054	{
1055	if (!disByteData(uFlatAddr, off))
1056	return false;
1057	cb -= off;
1058	uFlatAddr += off;
1059	off = 0;
1060	if (!cb)
1061	break;
1062	}
1063
1064	bool fRc;
1065	if (off == 0)
1066	{
1067	size_t cchName = strlen(Sym.szName);
1068	fRc = outputPrintf("%s: %*s; %#x LB %#x\n", Sym.szName, cchName < 41 - 2 ? cchName - 41 - 2 : 0, "", uFlatAddr, Sym.cb);
1069	if (!fRc)
1070	return false;
1071
1072	if (disIsCodeAndAdjustSize(uFlatAddr, &Sym, &g_aSegs[iSeg]))
1073	fRc = disCode(uFlatAddr, Sym.cb, disIs16BitCode(Sym.szName));
1074	else
1075	fRc = disByteData(uFlatAddr, Sym.cb);
1076
1077	uFlatAddr += Sym.cb;
1078	cb -= Sym.cb;
1079	}
1080	else
1081	{
1082	fRc = disByteData(uFlatAddr, cb);
1083	uFlatAddr += cb;
1084	cb = 0;
1085	}
1086	if (!fRc)
1087	return false;
1088	}
1089
1090	return true;
1091	}
1092
1093
1094	static RTEXITCODE DisassembleBiosImage(void)
1095	{
1096	if (!disFileHeader())
1097	return RTEXITCODE_FAILURE;
1098
1099	/*
1100	* Work the image segment by segment.
1101	*/
1102	bool fRc = true;
1103	uint32_t uFlatAddr = g_uBiosFlatBase;
1104	for (uint32_t iSeg = 0; iSeg < g_cSegs && fRc; iSeg++)
1105	{
1106	/* Is there a gap between the segments? */
1107	if (uFlatAddr < g_aSegs[iSeg].uFlatAddr)
1108	{
1109	fRc = disCopySegmentGap(uFlatAddr, g_aSegs[iSeg].uFlatAddr - uFlatAddr);
1110	if (!fRc)
1111	break;
1112	uFlatAddr = g_aSegs[iSeg].uFlatAddr;
1113	}
1114	else if (uFlatAddr > g_aSegs[iSeg].uFlatAddr)
1115	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Overlapping segments: %u and %u; uFlatAddr=%#x\n", iSeg - 1, iSeg, uFlatAddr);
1116
1117	/* Disassemble the segment. */
1118	fRc = outputPrintf("\n"
1119	"section %s progbits vstart=%#x align=1 ; size=%#x class=%s group=%s\n",
1120	g_aSegs[iSeg].szName, g_aSegs[iSeg].uFlatAddr - g_uBiosFlatBase,
1121	g_aSegs[iSeg].cb, g_aSegs[iSeg].szClass, g_aSegs[iSeg].szGroup);
1122	if (!fRc)
1123	return RTEXITCODE_FAILURE;
1124	if (!strcmp(g_aSegs[iSeg].szName, "CONST"))
1125	fRc = disConstSegment(iSeg);
1126	else if (!strcmp(g_aSegs[iSeg].szClass, "DATA"))
1127	fRc = disDataSegment(iSeg);
1128	else
1129	fRc = disCodeSegment(iSeg);
1130
1131	/* Advance. */
1132	uFlatAddr += g_aSegs[iSeg].cb;
1133	}
1134
1135	/* Final gap. */
1136	if (uFlatAddr < g_uBiosFlatBase + g_cbImg)
1137	fRc = disCopySegmentGap(uFlatAddr, (uint32_t)(g_uBiosFlatBase + g_cbImg - uFlatAddr));
1138	else if (uFlatAddr > g_uBiosFlatBase + g_cbImg)
1139	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Last segment spills beyond 1MB; uFlatAddr=%#x\n", uFlatAddr);
1140
1141	if (!fRc)
1142	return RTEXITCODE_FAILURE;
1143	return RTEXITCODE_SUCCESS;
1144	}
1145
1146
1147
1148	/**
1149	* Parses the symbol file for the BIOS.
1150	*
1151	* This is in ELF/DWARF format.
1152	*
1153	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
1154	* @param pszBiosSym Path to the sym file.
1155	*/
1156	static RTEXITCODE ParseSymFile(const char *pszBiosSym)
1157	{
1158	#if 1
1159	/** @todo use RTDbg* later. (Just checking for existance currently.) */
1160	PRTSTREAM hStrm;
1161	int rc = RTStrmOpen(pszBiosSym, "rb", &hStrm);
1162	if (RT_FAILURE(rc))
1163	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Error opening '%s': %Rrc", pszBiosSym, rc);
1164	RTStrmClose(hStrm);
1165	#else
1166	RTDBGMOD hDbgMod;
1167	int rc = RTDbgModCreateFromImage(&hDbgMod, pszBiosSym, "VBoxBios", 0 /fFlags/);
1168	RTMsgInfo("RTDbgModCreateFromImage -> %Rrc\n", rc);
1169	#endif
1170	return RTEXITCODE_SUCCESS;
1171	}
1172
1173
1174	/**
1175	* Display an error with the mapfile name and current line, return false.
1176	*
1177	* @returns @c false.
1178	* @param pMap The map file handle.
1179	* @param pszFormat The format string.
1180	* @param ... Format arguments.
1181	*/
1182	static bool mapError(PBIOSMAP pMap, const char *pszFormat, ...)
1183	{
1184	va_list va;
1185	va_start(va, pszFormat);
1186	RTMsgError("%s:%d: %N", pMap->pszMapFile, pMap->iLine, pszFormat, va);
1187	va_end(va);
1188	return false;
1189	}
1190
1191
1192	/**
1193	* Reads a line from the file.
1194	*
1195	* @returns @c true on success, @c false + msg on failure, @c false on eof.
1196	* @param pMap The map file handle.
1197	*/
1198	static bool mapReadLine(PBIOSMAP pMap)
1199	{
1200	int rc = RTStrmGetLine(pMap->hStrm, pMap->szLine, sizeof(pMap->szLine));
1201	if (RT_FAILURE(rc))
1202	{
1203	if (rc == VERR_EOF)
1204	{
1205	pMap->fEof = true;
1206	pMap->cch = 0;
1207	pMap->offNW = 0;
1208	pMap->szLine[0] = '\0';
1209	}
1210	else
1211	RTMsgError("%s:%d: Read error %Rrc", pMap->pszMapFile, pMap->iLine + 1, rc);
1212	return false;
1213	}
1214	pMap->iLine++;
1215	pMap->cch = (uint32_t)strlen(pMap->szLine);
1216
1217	/* Check out leading white space. */
1218	if (!RT_C_IS_SPACE(pMap->szLine[0]))
1219	pMap->offNW = 0;
1220	else
1221	{
1222	uint32_t off = 1;
1223	while (RT_C_IS_SPACE(pMap->szLine[off]))
1224	off++;
1225	pMap->offNW = off;
1226	}
1227
1228	return true;
1229	}
1230
1231
1232	/**
1233	* Checks if it is an empty line.
1234	* @returns @c true if empty, @c false if not.
1235	* @param pMap The map file handle.
1236	*/
1237	static bool mapIsEmptyLine(PBIOSMAP pMap)
1238	{
1239	Assert(pMap->offNW <= pMap->cch);
1240	return pMap->offNW == pMap->cch;
1241	}
1242
1243
1244	/**
1245	* Reads ahead in the map file until a non-empty line or EOF is encountered.
1246	*
1247	* @returns @c true on success, @c false + msg on failure, @c false on eof.
1248	* @param pMap The map file handle.
1249	*/
1250	static bool mapSkipEmptyLines(PBIOSMAP pMap)
1251	{
1252	for (;;)
1253	{
1254	if (!mapReadLine(pMap))
1255	return false;
1256	if (pMap->offNW < pMap->cch)
1257	return true;
1258	}
1259	}
1260
1261
1262	/**
1263	* Reads ahead in the map file until an empty line or EOF is encountered.
1264	*
1265	* @returns @c true on success, @c false + msg on failure, @c false on eof.
1266	* @param pMap The map file handle.
1267	*/
1268	static bool mapSkipNonEmptyLines(PBIOSMAP pMap)
1269	{
1270	for (;;)
1271	{
1272	if (!mapReadLine(pMap))
1273	return false;
1274	if (pMap->offNW == pMap->cch)
1275	return true;
1276	}
1277	}
1278
1279
1280	/**
1281	* Strips the current line.
1282	*
1283	* The string length may change.
1284	*
1285	* @returns Pointer to the first non-space character.
1286	* @param pMap The map file handle.
1287	* @param pcch Where to return the length of the unstripped
1288	* part. Optional.
1289	*/
1290	static char mapStripCurrentLine(PBIOSMAP pMap, size_t pcch)
1291	{
1292	char *psz = &pMap->szLine[pMap->offNW];
1293	char *pszEnd = &pMap->szLine[pMap->cch];
1294	while ( (uintptr_t)pszEnd > (uintptr_t)psz
1295	&& RT_C_IS_SPACE(pszEnd[-1]))
1296	{
1297	*--pszEnd = '\0';
1298	pMap->cch--;
1299	}
1300	if (pcch)
1301	*pcch = pszEnd - psz;
1302	return psz;
1303	}
1304
1305
1306	/**
1307	* Reads a line from the file and right strips it.
1308	*
1309	* @returns Pointer to szLine on success, @c NULL + msg on failure, @c NULL on
1310	* EOF.
1311	* @param pMap The map file handle.
1312	* @param pcch Where to return the length of the unstripped
1313	* part. Optional.
1314	*/
1315	static char mapReadLineStripRight(PBIOSMAP pMap, size_t pcch)
1316	{
1317	if (!mapReadLine(pMap))
1318	return NULL;
1319	mapStripCurrentLine(pMap, NULL);
1320	if (pcch)
1321	*pcch = pMap->cch;
1322	return pMap->szLine;
1323	}
1324
1325
1326	/**
1327	* mapReadLine() + mapStripCurrentLine().
1328	*
1329	* @returns Pointer to the first non-space character in the new line. NULL on
1330	* read error (bitched already) or end of file.
1331	* @param pMap The map file handle.
1332	* @param pcch Where to return the length of the unstripped
1333	* part. Optional.
1334	*/
1335	static char mapReadLineStrip(PBIOSMAP pMap, size_t pcch)
1336	{
1337	if (!mapReadLine(pMap))
1338	return NULL;
1339	return mapStripCurrentLine(pMap, pcch);
1340	}
1341
1342
1343	/**
1344	* Parses a word, copying it into the supplied buffer, and skipping any spaces
1345	* following it.
1346	*
1347	* @returns @c true on success, @c false on failure.
1348	* @param ppszCursor Pointer to the cursor variable.
1349	* @param pszBuf The output buffer.
1350	* @param cbBuf The size of the output buffer.
1351	*/
1352	static bool mapParseWord(char *ppszCursor, char pszBuf, size_t cbBuf)
1353	{
1354	/* Check that we start on a non-blank. */
1355	char pszStart = ppszCursor;
1356	if (!pszStart \|\| RT_C_IS_SPACE(pszStart))
1357	return false;
1358
1359	/* Find the end of the word. */
1360	char *psz = pszStart + 1;
1361	while (psz && !RT_C_IS_SPACE(psz))
1362	psz++;
1363
1364	/* Copy it. */
1365	size_t cchWord = (uintptr_t)psz - (uintptr_t)pszStart;
1366	if (cchWord >= cbBuf)
1367	return false;
1368	memcpy(pszBuf, pszStart, cchWord);
1369	pszBuf[cchWord] = '\0';
1370
1371	/* Skip blanks following it. */
1372	while (RT_C_IS_SPACE(*psz))
1373	psz++;
1374	*ppszCursor = psz;
1375	return true;
1376	}
1377
1378
1379	/**
1380	* Parses an 16:16 address.
1381	*
1382	* @returns @c true on success, @c false on failure.
1383	* @param ppszCursor Pointer to the cursor variable.
1384	* @param pAddr Where to return the address.
1385	*/
1386	static bool mapParseAddress(char **ppszCursor, PRTFAR16 pAddr)
1387	{
1388	char szWord[32];
1389	if (!mapParseWord(ppszCursor, szWord, sizeof(szWord)))
1390	return false;
1391	size_t cchWord = strlen(szWord);
1392
1393	/* An address is at least 16:16 format. It may be 16:32. It may also be flagged. */
1394	size_t cchAddr = 4 + 1 + 4;
1395	if (cchWord < cchAddr)
1396	return false;
1397	if ( !RT_C_IS_XDIGIT(szWord[0])
1398	\|\| !RT_C_IS_XDIGIT(szWord[1])
1399	\|\| !RT_C_IS_XDIGIT(szWord[2])
1400	\|\| !RT_C_IS_XDIGIT(szWord[3])
1401	\|\| szWord[4] != ':'
1402	\|\| !RT_C_IS_XDIGIT(szWord[5])
1403	\|\| !RT_C_IS_XDIGIT(szWord[6])
1404	\|\| !RT_C_IS_XDIGIT(szWord[7])
1405	\|\| !RT_C_IS_XDIGIT(szWord[8])
1406	)
1407	return false;
1408	if ( cchWord > cchAddr
1409	&& RT_C_IS_XDIGIT(szWord[9])
1410	&& RT_C_IS_XDIGIT(szWord[10])
1411	&& RT_C_IS_XDIGIT(szWord[11])
1412	&& RT_C_IS_XDIGIT(szWord[12]))
1413	cchAddr += 4;
1414
1415	/* Drop flag if present. */
1416	if (cchWord > cchAddr)
1417	{
1418	if (RT_C_IS_XDIGIT(szWord[cchAddr]))
1419	return false;
1420	szWord[cchAddr] = '\0';
1421	cchWord = cchAddr;
1422	}
1423
1424	/* Convert it. */
1425	szWord[4] = '\0';
1426	int rc1 = RTStrToUInt16Full(szWord, 16, &pAddr->sel);
1427	if (rc1 != VINF_SUCCESS)
1428	return false;
1429
1430	int rc2 = RTStrToUInt16Full(szWord + 5, 16, &pAddr->off);
1431	if (rc2 != VINF_SUCCESS)
1432	return false;
1433	return true;
1434	}
1435
1436
1437	/**
1438	* Parses a size.
1439	*
1440	* @returns @c true on success, @c false on failure.
1441	* @param ppszCursor Pointer to the cursor variable.
1442	* @param pcb Where to return the size.
1443	*/
1444	static bool mapParseSize(char *ppszCursor, uint32_t pcb)
1445	{
1446	char szWord[32];
1447	if (!mapParseWord(ppszCursor, szWord, sizeof(szWord)))
1448	return false;
1449	size_t cchWord = strlen(szWord);
1450	if (cchWord != 8)
1451	return false;
1452
1453	int rc = RTStrToUInt32Full(szWord, 16, pcb);
1454	if (rc != VINF_SUCCESS)
1455	return false;
1456	return true;
1457	}
1458
1459
1460	/**
1461	* Parses a section box and the following column header.
1462	*
1463	* @returns @c true on success, @c false + msg on failure, @c false on eof.
1464	* @param pMap Map file handle.
1465	* @param pszSectionNm The expected section name.
1466	* @param cColumns The number of columns.
1467	* @param ... The column names.
1468	*/
1469	static bool mapSkipThruColumnHeadings(PBIOSMAP pMap, const char *pszSectionNm, uint32_t cColumns, ...)
1470	{
1471	if ( mapIsEmptyLine(pMap)
1472	&& !mapSkipEmptyLines(pMap))
1473	return false;
1474
1475	/* +------------+ */
1476	size_t cch;
1477	char *psz = mapStripCurrentLine(pMap, &cch);
1478	if (!psz)
1479	return false;
1480
1481	if ( psz[0] != '+'
1482	\|\| psz[1] != '-'
1483	\|\| psz[2] != '-'
1484	\|\| psz[3] != '-'
1485	\|\| psz[cch - 4] != '-'
1486	\|\| psz[cch - 3] != '-'
1487	\|\| psz[cch - 2] != '-'
1488	\|\| psz[cch - 1] != '+'
1489	)
1490	{
1491	RTMsgError("%s:%d: Expected section box: +-----...", pMap->pszMapFile, pMap->iLine);
1492	return false;
1493	}
1494
1495	/* \| pszSectionNm \| */
1496	psz = mapReadLineStrip(pMap, &cch);
1497	if (!psz)
1498	return false;
1499
1500	size_t cchSectionNm = strlen(pszSectionNm);
1501	if ( psz[0] != '\|'
1502	\|\| psz[1] != ' '
1503	\|\| psz[2] != ' '
1504	\|\| psz[3] != ' '
1505	\|\| psz[cch - 4] != ' '
1506	\|\| psz[cch - 3] != ' '
1507	\|\| psz[cch - 2] != ' '
1508	\|\| psz[cch - 1] != '\|'
1509	\|\| cch != 1 + 3 + cchSectionNm + 3 + 1
1510	\|\| strncmp(&psz[4], pszSectionNm, cchSectionNm)
1511	)
1512	{
1513	RTMsgError("%s:%d: Expected section box: \| %s \|", pMap->pszMapFile, pMap->iLine, pszSectionNm);
1514	return false;
1515	}
1516
1517	/* +------------+ */
1518	psz = mapReadLineStrip(pMap, &cch);
1519	if (!psz)
1520	return false;
1521	if ( psz[0] != '+'
1522	\|\| psz[1] != '-'
1523	\|\| psz[2] != '-'
1524	\|\| psz[3] != '-'
1525	\|\| psz[cch - 4] != '-'
1526	\|\| psz[cch - 3] != '-'
1527	\|\| psz[cch - 2] != '-'
1528	\|\| psz[cch - 1] != '+'
1529	)
1530	{
1531	RTMsgError("%s:%d: Expected section box: +-----...", pMap->pszMapFile, pMap->iLine);
1532	return false;
1533	}
1534
1535	/* There may be a few lines describing the table notation now, surrounded by blank lines. */
1536	do
1537	{
1538	psz = mapReadLineStripRight(pMap, &cch);
1539	if (!psz)
1540	return false;
1541	} while ( *psz == '\0'
1542	\|\| ( !RT_C_IS_SPACE(psz[0])
1543	&& RT_C_IS_SPACE(psz[1])
1544	&& psz[2] == '='
1545	&& RT_C_IS_SPACE(psz[3]))
1546	);
1547
1548	/* Should have the column heading now. */
1549	va_list va;
1550	va_start(va, cColumns);
1551	for (uint32_t i = 0; i < cColumns; i++)
1552	{
1553	const char pszColumn = va_arg(va, const char );
1554	size_t cchColumn = strlen(pszColumn);
1555	if ( strncmp(psz, pszColumn, cchColumn)
1556	\|\| ( psz[cchColumn] != '\0'
1557	&& !RT_C_IS_SPACE(psz[cchColumn])))
1558	{
1559	va_end(va);
1560	RTMsgError("%s:%d: Expected column '%s' found '%s'", pMap->pszMapFile, pMap->iLine, pszColumn, psz);
1561	return false;
1562	}
1563	psz += cchColumn;
1564	while (RT_C_IS_SPACE(*psz))
1565	psz++;
1566	}
1567	va_end(va);
1568
1569	/* The next line is the underlining. */
1570	psz = mapReadLineStripRight(pMap, &cch);
1571	if (!psz)
1572	return false;
1573	if (*psz != '=' \|\| psz[cch - 1] != '=')
1574	{
1575	RTMsgError("%s:%d: Expected column header underlining", pMap->pszMapFile, pMap->iLine);
1576	return false;
1577	}
1578
1579	/* Skip one blank line. */
1580	psz = mapReadLineStripRight(pMap, &cch);
1581	if (!psz)
1582	return false;
1583	if (*psz)
1584	{
1585	RTMsgError("%s:%d: Expected blank line beneath the column headers", pMap->pszMapFile, pMap->iLine);
1586	return false;
1587	}
1588
1589	return true;
1590	}
1591
1592
1593	/**
1594	* Parses a segment list.
1595	*
1596	* @returns @c true on success, @c false + msg on failure, @c false on eof.
1597	* @param pMap The map file handle.
1598	*/
1599	static bool mapParseSegments(PBIOSMAP pMap)
1600	{
1601	for (;;)
1602	{
1603	if (!mapReadLineStripRight(pMap, NULL))
1604	return false;
1605
1606	/* The end? The line should be empty. Expectes segment name to not
1607	start with a space. */
1608	if (!pMap->szLine[0] \|\| RT_C_IS_SPACE(pMap->szLine[0]))
1609	{
1610	if (!pMap->szLine[0])
1611	return true;
1612	RTMsgError("%s:%u: Malformed segment line", pMap->pszMapFile, pMap->iLine);
1613	return false;
1614	}
1615
1616	/* Parse the segment line. */
1617	uint32_t iSeg = g_cSegs;
1618	if (iSeg >= RT_ELEMENTS(g_aSegs))
1619	{
1620	RTMsgError("%s:%u: Too many segments", pMap->pszMapFile, pMap->iLine);
1621	return false;
1622	}
1623
1624	char *psz = pMap->szLine;
1625	if (!mapParseWord(&psz, g_aSegs[iSeg].szName, sizeof(g_aSegs[iSeg].szName)))
1626	RTMsgError("%s:%u: Segment name parser error", pMap->pszMapFile, pMap->iLine);
1627	else if (!mapParseWord(&psz, g_aSegs[iSeg].szClass, sizeof(g_aSegs[iSeg].szClass)))
1628	RTMsgError("%s:%u: Segment class parser error", pMap->pszMapFile, pMap->iLine);
1629	else if (!mapParseWord(&psz, g_aSegs[iSeg].szGroup, sizeof(g_aSegs[iSeg].szGroup)))
1630	RTMsgError("%s:%u: Segment group parser error", pMap->pszMapFile, pMap->iLine);
1631	else if (!mapParseAddress(&psz, &g_aSegs[iSeg].Address))
1632	RTMsgError("%s:%u: Segment address parser error", pMap->pszMapFile, pMap->iLine);
1633	else if (!mapParseSize(&psz, &g_aSegs[iSeg].cb))
1634	RTMsgError("%s:%u: Segment size parser error", pMap->pszMapFile, pMap->iLine);
1635	else
1636	{
1637	g_aSegs[iSeg].uFlatAddr = ((uint32_t)g_aSegs[iSeg].Address.sel << 4) + g_aSegs[iSeg].Address.off;
1638	g_cSegs++;
1639	if (g_cVerbose > 2)
1640	RTStrmPrintf(g_pStdErr, "read segment at %08x / %04x:%04x LB %04x %s / %s / %s\n",
1641	g_aSegs[iSeg].uFlatAddr,
1642	g_aSegs[iSeg].Address.sel,
1643	g_aSegs[iSeg].Address.off,
1644	g_aSegs[iSeg].cb,
1645	g_aSegs[iSeg].szName,
1646	g_aSegs[iSeg].szClass,
1647	g_aSegs[iSeg].szGroup);
1648
1649	while (RT_C_IS_SPACE(*psz))
1650	psz++;
1651	if (!*psz)
1652	continue;
1653	RTMsgError("%s:%u: Junk at end of line", pMap->pszMapFile, pMap->iLine);
1654	}
1655	return false;
1656	}
1657	}
1658
1659
1660	/**
1661	* Sorts the segment array by flat address and adds them to the debug module.
1662	*
1663	* @returns @c true on success, @c false + msg on failure, @c false on eof.
1664	*/
1665	static bool mapSortAndAddSegments(void)
1666	{
1667	for (uint32_t i = 0; i < g_cSegs; i++)
1668	{
1669	for (uint32_t j = i + 1; j < g_cSegs; j++)
1670	if (g_aSegs[j].uFlatAddr < g_aSegs[i].uFlatAddr)
1671	{
1672	BIOSSEG Tmp = g_aSegs[i];
1673	g_aSegs[i] = g_aSegs[j];
1674	g_aSegs[j] = Tmp;
1675	}
1676	if (g_cVerbose > 0)
1677	RTStrmPrintf(g_pStdErr, "segment at %08x / %04x:%04x LB %04x %s / %s / %s\n",
1678	g_aSegs[i].uFlatAddr,
1679	g_aSegs[i].Address.sel,
1680	g_aSegs[i].Address.off,
1681	g_aSegs[i].cb,
1682	g_aSegs[i].szName,
1683	g_aSegs[i].szClass,
1684	g_aSegs[i].szGroup);
1685
1686	RTDBGSEGIDX idx = i;
1687	int rc = RTDbgModSegmentAdd(g_hMapMod, g_aSegs[i].uFlatAddr, g_aSegs[i].cb, g_aSegs[i].szName, 0 /fFlags/, &idx);
1688	if (RT_FAILURE(rc))
1689	{
1690	RTMsgError("RTDbgModSegmentAdd failed on %s: %Rrc", g_aSegs[i].szName);
1691	return false;
1692	}
1693	}
1694	return true;
1695	}
1696
1697
1698	/**
1699	* Parses a segment list.
1700	*
1701	* @returns @c true on success, @c false + msg on failure, @c false on eof.
1702	* @param pMap The map file handle.
1703	*/
1704	static bool mapParseSymbols(PBIOSMAP pMap)
1705	{
1706	for (;;)
1707	{
1708	if (!mapReadLineStripRight(pMap, NULL))
1709	return false;
1710
1711	/* The end? The line should be empty. Expectes segment name to not
1712	start with a space. */
1713	if (!pMap->szLine[0] \|\| RT_C_IS_SPACE(pMap->szLine[0]))
1714	{
1715	if (!pMap->szLine[0])
1716	return true;
1717	return mapError(pMap, "Malformed symbol line");
1718	}
1719
1720	if (!strncmp(pMap->szLine, RT_STR_TUPLE("Module: ")))
1721	{
1722	/* Parse the module line. */
1723	size_t offObj = sizeof("Module: ") - 1;
1724	while (RT_C_IS_SPACE(pMap->szLine[offObj]))
1725	offObj++;
1726	size_t offSrc = offObj;
1727	char ch;
1728	while ((ch = pMap->szLine[offSrc]) != '(' && ch != '\0')
1729	offSrc++;
1730	size_t cchObj = offSrc - offObj;
1731
1732	offSrc++;
1733	size_t cchSrc = offSrc;
1734	while ((ch = pMap->szLine[cchSrc]) != ')' && ch != '\0')
1735	cchSrc++;
1736	cchSrc -= offSrc;
1737	if (ch != ')')
1738	return mapError(pMap, "Symbol/Module line parse error");
1739
1740	PBIOSOBJFILE pObjFile = (PBIOSOBJFILE)RTMemAllocZ(sizeof(*pObjFile) + cchSrc + cchObj + 2);
1741	if (!pObjFile)
1742	return mapError(pMap, "Out of memory");
1743	char psz = (char )(pObjFile + 1);
1744	pObjFile->pszObject = psz;
1745	memcpy(psz, &pMap->szLine[offObj], cchObj);
1746	psz += cchObj;
1747	*psz++ = '\0';
1748	pObjFile->pszSource = psz;
1749	memcpy(psz, &pMap->szLine[offSrc], cchSrc);
1750	psz[cchSrc] = '\0';
1751	RTListAppend(&g_ObjList, &pObjFile->Node);
1752	}
1753	else
1754	{
1755	/* Parse the segment line. */
1756	RTFAR16 Addr;
1757	char *psz = pMap->szLine;
1758	if (!mapParseAddress(&psz, &Addr))
1759	return mapError(pMap, "Symbol address parser error");
1760
1761	char szName[4096];
1762	if (!mapParseWord(&psz, szName, sizeof(szName)))
1763	return mapError(pMap, "Symbol name parser error");
1764
1765	uint32_t uFlatAddr = ((uint32_t)Addr.sel << 4) + Addr.off;
1766	if (uFlatAddr != 0)
1767	{
1768	int rc = RTDbgModSymbolAdd(g_hMapMod, szName, RTDBGSEGIDX_RVA, uFlatAddr, 0 /cb/, 0 /fFlags/, NULL);
1769	if (RT_FAILURE(rc) && rc != VERR_DBG_ADDRESS_CONFLICT)
1770	{
1771	/* HACK ALERT! For dealing with lables at segment size. / /* @todo fix end labels. */
1772	rc = RTDbgModSymbolAdd(g_hMapMod, szName, RTDBGSEGIDX_RVA, uFlatAddr - 1, 0 /cb/, 0 /fFlags/, NULL);
1773	if (RT_FAILURE(rc) && rc != VERR_DBG_ADDRESS_CONFLICT)
1774	return mapError(pMap, "RTDbgModSymbolAdd failed: %Rrc", rc);
1775	}
1776
1777	if (g_cVerbose > 2)
1778	RTStrmPrintf(g_pStdErr, "read symbol - %08x %s\n", uFlatAddr, szName);
1779	while (RT_C_IS_SPACE(*psz))
1780	psz++;
1781	if (*psz)
1782	return mapError(pMap, "Junk at end of line");
1783	}
1784
1785	}
1786	}
1787	}
1788
1789
1790	/**
1791	* Parses the given map file.
1792	*
1793	* @returns RTEXITCODE_SUCCESS and lots of globals, or RTEXITCODE_FAILURE and a
1794	* error message.
1795	* @param pMap The map file handle.
1796	*/
1797	static RTEXITCODE mapParseFile(PBIOSMAP pMap)
1798	{
1799	int rc = RTDbgModCreate(&g_hMapMod, "VBoxBios", 0 /cbSeg/, 0 /fFlags/);
1800	if (RT_FAILURE(rc))
1801	return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTDbgModCreate failed: %Rrc", rc);
1802
1803	/*
1804	* Read the header.
1805	*/
1806	if (!mapReadLine(pMap))
1807	return RTEXITCODE_FAILURE;
1808	if (strncmp(pMap->szLine, RT_STR_TUPLE("Open Watcom Linker Version")))
1809	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Unexpected map-file header: '%s'", pMap->szLine);
1810	if ( !mapSkipNonEmptyLines(pMap)
1811	\|\| !mapSkipEmptyLines(pMap))
1812	return RTEXITCODE_FAILURE;
1813
1814	/*
1815	* Skip groups.
1816	*/
1817	if (!mapSkipThruColumnHeadings(pMap, "Groups", 3, "Group", "Address", "Size", NULL))
1818	return RTEXITCODE_FAILURE;
1819	if (!mapSkipNonEmptyLines(pMap))
1820	return RTEXITCODE_FAILURE;
1821
1822	/*
1823	* Parse segments.
1824	*/
1825	if (!mapSkipThruColumnHeadings(pMap, "Segments", 5, "Segment", "Class", "Group", "Address", "Size"))
1826	return RTEXITCODE_FAILURE;
1827	if (!mapParseSegments(pMap))
1828	return RTEXITCODE_FAILURE;
1829	if (!mapSortAndAddSegments())
1830	return RTEXITCODE_FAILURE;
1831
1832	/*
1833	* Parse symbols.
1834	*/
1835	if (!mapSkipThruColumnHeadings(pMap, "Memory Map", 2, "Address", "Symbol"))
1836	return RTEXITCODE_FAILURE;
1837	if (!mapParseSymbols(pMap))
1838	return RTEXITCODE_FAILURE;
1839
1840	/* Ignore the rest of the file. */
1841	return RTEXITCODE_SUCCESS;
1842	}
1843
1844
1845	/**
1846	* Parses the linker map file for the BIOS.
1847	*
1848	* This is generated by the Watcom linker.
1849	*
1850	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
1851	* @param pszBiosMap Path to the map file.
1852	*/
1853	static RTEXITCODE ParseMapFile(const char *pszBiosMap)
1854	{
1855	BIOSMAP Map;
1856	Map.pszMapFile = pszBiosMap;
1857	Map.hStrm = NULL;
1858	Map.iLine = 0;
1859	Map.fEof = false;
1860	Map.cch = 0;
1861	Map.offNW = 0;
1862	int rc = RTStrmOpen(pszBiosMap, "r", &Map.hStrm);
1863	if (RT_FAILURE(rc))
1864	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Error opening '%s': %Rrc", pszBiosMap, rc);
1865	RTEXITCODE rcExit = mapParseFile(&Map);
1866	RTStrmClose(Map.hStrm);
1867	return rcExit;
1868	}
1869
1870
1871	/**
1872	* Reads the BIOS image into memory (g_pbImg and g_cbImg).
1873	*
1874	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
1875	* @param pszBiosImg Path to the image file.
1876	*/
1877	static RTEXITCODE ReadBiosImage(const char *pszBiosImg)
1878	{
1879	void *pvImg;
1880	size_t cbImg;
1881	int rc = RTFileReadAll(pszBiosImg, &pvImg, &cbImg);
1882	if (RT_FAILURE(rc))
1883	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Error reading '%s': %Rrc", pszBiosImg, rc);
1884
1885	size_t cbImgExpect;
1886	switch (g_enmBiosType)
1887	{
1888	case kBiosType_System: cbImgExpect = _64K; break;
1889	case kBiosType_Vga: cbImgExpect = _32K; break;
1890	default: cbImgExpect = 0; break;
1891	}
1892	if (cbImg != cbImgExpect)
1893	{
1894	RTFileReadAllFree(pvImg, cbImg);
1895	return RTMsgErrorExit(RTEXITCODE_FAILURE, "The BIOS image %u bytes intead of %u bytes", cbImg, cbImgExpect);
1896	}
1897
1898	g_pbImg = (uint8_t *)pvImg;
1899	g_cbImg = cbImg;
1900	return RTEXITCODE_SUCCESS;
1901	}
1902
1903
1904	int main(int argc, char **argv)
1905	{
1906	int rc = RTR3InitExe(argc, &argv, 0);
1907	if (RT_FAILURE(rc))
1908	return RTMsgInitFailure(rc);
1909
1910	RTListInit(&g_ObjList);
1911
1912	/*
1913	* Option config.
1914	*/
1915	static RTGETOPTDEF const s_aOpts[] =
1916	{
1917	{ "--bios-image", 'i', RTGETOPT_REQ_STRING },
1918	{ "--bios-map", 'm', RTGETOPT_REQ_STRING },
1919	{ "--bios-sym", 's', RTGETOPT_REQ_STRING },
1920	{ "--bios-type", 't', RTGETOPT_REQ_STRING },
1921	{ "--output", 'o', RTGETOPT_REQ_STRING },
1922	{ "--verbose", 'v', RTGETOPT_REQ_NOTHING },
1923	{ "--quiet", 'q', RTGETOPT_REQ_NOTHING },
1924	};
1925
1926	const char *pszBiosMap = NULL;
1927	const char *pszBiosSym = NULL;
1928	const char *pszBiosImg = NULL;
1929	const char *pszOutput = NULL;
1930
1931	RTGETOPTUNION ValueUnion;
1932	RTGETOPTSTATE GetOptState;
1933	rc = RTGetOptInit(&GetOptState, argc, argv, &s_aOpts[0], RT_ELEMENTS(s_aOpts), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
1934	AssertReleaseRCReturn(rc, RTEXITCODE_FAILURE);
1935
1936	/*
1937	* Process the options.
1938	*/
1939	while ((rc = RTGetOpt(&GetOptState, &ValueUnion)) != 0)
1940	{
1941	switch (rc)
1942	{
1943	case 'i':
1944	if (pszBiosImg)
1945	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "--bios-image is given more than once");
1946	pszBiosImg = ValueUnion.psz;
1947	break;
1948
1949	case 'm':
1950	if (pszBiosMap)
1951	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "--bios-map is given more than once");
1952	pszBiosMap = ValueUnion.psz;
1953	break;
1954
1955	case 's':
1956	if (pszBiosSym)
1957	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "--bios-sym is given more than once");
1958	pszBiosSym = ValueUnion.psz;
1959	break;
1960
1961	case 'o':
1962	if (pszOutput)
1963	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "--output is given more than once");
1964	pszOutput = ValueUnion.psz;
1965	break;
1966
1967	case 't':
1968	if (!strcmp(ValueUnion.psz, "system"))
1969	{
1970	g_enmBiosType = kBiosType_System;
1971	g_uBiosFlatBase = 0xf0000;
1972	}
1973	else if (!strcmp(ValueUnion.psz, "vga"))
1974	{
1975	g_enmBiosType = kBiosType_Vga;
1976	g_uBiosFlatBase = 0xc0000;
1977	}
1978	else
1979	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Unknown bios type '%s'", ValueUnion.psz);
1980	break;
1981
1982	case 'v':
1983	g_cVerbose++;
1984	break;
1985
1986	case 'q':
1987	g_cVerbose = 0;
1988	break;
1989
1990	case 'H':
1991	RTPrintf("usage: %Rbn --bios-image <file.img> --bios-map <file.map> [--output <file.asm>]\n",
1992	argv[0]);
1993	return RTEXITCODE_SUCCESS;
1994
1995	case 'V':
1996	{
1997	/* The following is assuming that svn does it's job here. */
1998	RTPrintf("r%u\n", RTBldCfgRevision());
1999	return RTEXITCODE_SUCCESS;
2000	}
2001
2002	default:
2003	return RTGetOptPrintError(rc, &ValueUnion);
2004	}
2005	}
2006
2007	/*
2008	* Got it all?
2009	*/
2010	if (!pszBiosImg)
2011	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "--bios-image is required");
2012	if (!pszBiosMap)
2013	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "--bios-map is required");
2014	if (!pszBiosSym)
2015	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "--bios-sym is required");
2016
2017	/*
2018	* Do the job.
2019	*/
2020	RTEXITCODE rcExit;
2021	rcExit = ReadBiosImage(pszBiosImg);
2022	if (rcExit == RTEXITCODE_SUCCESS)
2023	rcExit = ParseMapFile(pszBiosMap);
2024	if (rcExit == RTEXITCODE_SUCCESS)
2025	rcExit = ParseSymFile(pszBiosSym);
2026	if (rcExit == RTEXITCODE_SUCCESS)
2027	rcExit = OpenOutputFile(pszOutput);
2028	if (rcExit == RTEXITCODE_SUCCESS)
2029	rcExit = DisassembleBiosImage();
2030
2031	return rcExit;
2032	}
2033

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

source: vbox/trunk/src/VBox/Devices/BiosCommonCode/MakeAlternativeSource.cpp@ 45045

Download in other formats: