VirtualBox

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

Last change on this file since 67683 was 67495, checked in by vboxsync, 7 years ago

Devices/BIOS: update alternative code

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

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