Adding upstream version 7.0.14-dfsg.upstream/7.0.14-dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

14 files changed, 3555 insertions, 0 deletions

diff --git a/src/VBox/Devices/BiosCommonCode/ASMBitLastSetU16.asm b/src/VBox/Devices/BiosCommonCode/ASMBitLastSetU16.asm
new file mode 100644
index 00000000..0ad8b6c6
--- /dev/null
+++ b/src/VBox/Devices/BiosCommonCode/ASMBitLastSetU16.asm
@@ -0,0 +1,76 @@
+; $Id: ASMBitLastSetU16.asm $
+;; @file
+; BiosCommonCode - ASMBitLastSetU16() - borrowed from IPRT.
+;
+
+;
+; Copyright (C) 2006-2023 Oracle and/or its affiliates.
+;
+; This file is part of VirtualBox base platform packages, as
+; available from https://www.virtualbox.org.
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; as published by the Free Software Foundation, in version 3 of the
+; License.
+;
+; This program is distributed in the hope that it will be useful, but
+; WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+; General Public License for more details.
+;
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, see <https://www.gnu.org/licenses>.
+;
+; SPDX-License-Identifier: GPL-3.0-only
+;
+
+
+;*******************************************************************************
+;* Header Files                                                                *
+;*******************************************************************************
+public _ASMBitLastSetU16
+
+        .8086
+
+_TEXT   segment public 'CODE' use16
+        assume cs:_TEXT
+
+
+;;
+; Finds the last bit which is set in the given 16-bit integer.
+;
+; Bits are numbered from 1 (least significant) to 16.
+;
+; @returns (ax)     index [1..16] of the last set bit.
+; @returns (ax)     0 if all bits are cleared.
+; @param   u16      Integer to search for set bits.
+;
+; @cproto DECLASM(unsigned) ASMBitLastSetU16(uint32_t u16);
+;
+_ASMBitLastSetU16   proc
+        .8086
+        push    bp
+        mov     bp, sp
+
+        mov     cx, [bp + 2 + 2]
+        test    cx, cx                  ; check if zero (eliminates checking dec ax result)
+        jz      return_zero
+
+        mov     ax, 16
+next_bit:
+        shl     cx, 1
+        jc      return
+        dec     ax
+        jmp     next_bit
+
+return_zero:
+        xor     ax, ax
+return:
+        pop     bp
+        ret
+_ASMBitLastSetU16   endp
+
+_TEXT           ends
+                end
+
diff --git a/src/VBox/Devices/BiosCommonCode/DoUInt32Div.c b/src/VBox/Devices/BiosCommonCode/DoUInt32Div.c
new file mode 100644
index 00000000..0b1acc40
--- /dev/null
+++ b/src/VBox/Devices/BiosCommonCode/DoUInt32Div.c
@@ -0,0 +1,43 @@
+/* $Id: DoUInt32Div.c $ */
+/** @file
+ * AHCI host adapter driver to boot from SATA disks.
+ */
+
+/*
+ * Copyright (C) 2011-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#define ARCH_BITS 16
+#include <iprt/types.h>
+#include <iprt/uint32.h>
+
+
+uint32_t __cdecl DoUInt32Div(RTUINT32U Dividend, RTUINT32U Divisor, RTUINT32U __far *pReminder)
+{
+    RTUINT32U Quotient;
+    RTUInt32DivRem(&Dividend, &Divisor, &Quotient, pReminder);
+    return Quotient.u;
+}
+
diff --git a/src/VBox/Devices/BiosCommonCode/MakeAlternativeSource.cpp b/src/VBox/Devices/BiosCommonCode/MakeAlternativeSource.cpp
new file mode 100644
index 00000000..159fa239
--- /dev/null
+++ b/src/VBox/Devices/BiosCommonCode/MakeAlternativeSource.cpp
@@ -0,0 +1,2203 @@
+/* $Id: MakeAlternativeSource.cpp $ */
+/** @file
+ * MakeAlternative - Generate an Alternative BIOS Source that requires less tools.
+ */
+
+/*
+ * Copyright (C) 2012-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <iprt/asm.h>
+#include <iprt/buildconfig.h>
+#include <iprt/ctype.h>
+#include <iprt/dbg.h>
+#include <iprt/err.h>
+#include <iprt/file.h>
+#include <iprt/getopt.h>
+#include <iprt/initterm.h>
+#include <iprt/list.h>
+#include <iprt/mem.h>
+#include <iprt/message.h>
+#include <iprt/string.h>
+#include <iprt/stream.h>
+#include <iprt/x86.h>
+
+#include <VBox/dis.h>
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+/**
+ * A BIOS segment.
+ */
+typedef struct BIOSSEG
+{
+    char        szName[32];
+    char        szClass[32];
+    char        szGroup[32];
+    RTFAR16     Address;
+    uint32_t    uFlatAddr;
+    uint32_t    cb;
+    /** RVA into g_hSymMod. */
+    uint32_t    uRva;
+} BIOSSEG;
+/** Pointer to a BIOS segment. */
+typedef BIOSSEG *PBIOSSEG;
+
+
+/**
+ * A BIOS object file.
+ */
+typedef struct BIOSOBJFILE
+{
+    RTLISTNODE  Node;
+    char       *pszSource;
+    char       *pszObject;
+} BIOSOBJFILE;
+/** A BIOS object file. */
+typedef BIOSOBJFILE *PBIOSOBJFILE;
+
+
+/**
+ * Pointer to a BIOS map parser handle.
+ */
+typedef struct BIOSMAP
+{
+    /** The stream pointer. */
+    PRTSTREAM   hStrm;
+    /** The file name. */
+    const char *pszMapFile;
+    /** Set when EOF has been reached. */
+    bool        fEof;
+    /** The current line number (0 based).*/
+    uint32_t    iLine;
+    /** The length of the current line. */
+    uint32_t    cch;
+    /** The offset of the first non-white character on the line. */
+    uint32_t    offNW;
+    /** The line buffer. */
+    char        szLine[16384];
+} BIOSMAP;
+/** Pointer to a BIOS map parser handle. */
+typedef BIOSMAP *PBIOSMAP;
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+/** The verbosity level.*/
+static unsigned         g_cVerbose = 2 /*0*/;
+/** Pointer to the BIOS image. */
+static uint8_t const   *g_pbImg;
+/** The size of the BIOS image. */
+static size_t           g_cbImg;
+
+/** Debug module for the map file.  */
+static RTDBGMOD         g_hMapMod = NIL_RTDBGMOD;
+/** The number of BIOS segments found in the map file. */
+static uint32_t         g_cSegs = 0;
+/** Array of BIOS segments from the map file. */
+static BIOSSEG          g_aSegs[32];
+/** List of BIOSOBJFILE. */
+static RTLISTANCHOR     g_ObjList;
+
+/** Debug module with symbols. */
+static RTDBGMOD         g_hSymMod = NIL_RTDBGMOD;
+
+/** The output stream. */
+static PRTSTREAM        g_hStrmOutput = NULL;
+
+/** The type of BIOS we're working on. */
+static enum BIOSTYPE
+{
+    kBiosType_System = 0,
+    kBiosType_Vga
+}                       g_enmBiosType = kBiosType_System;
+/** The flat ROM base address. */
+static uint32_t         g_uBiosFlatBase = 0xf0000;
+
+
+static bool outputPrintfV(const char *pszFormat, va_list va)
+{
+    int rc = RTStrmPrintfV(g_hStrmOutput, pszFormat, va);
+    if (RT_FAILURE(rc))
+    {
+        RTMsgError("Output error: %Rrc\n", rc);
+        return false;
+    }
+    return true;
+}
+
+
+static bool outputPrintf(const char *pszFormat, ...)
+{
+    va_list va;
+    va_start(va, pszFormat);
+    bool fRc = outputPrintfV(pszFormat, va);
+    va_end(va);
+    return fRc;
+}
+
+
+/**
+ * Opens the output file for writing.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pszOutput           Path to the output file.
+ */
+static RTEXITCODE OpenOutputFile(const char *pszOutput)
+{
+    if (!pszOutput)
+        g_hStrmOutput = g_pStdOut;
+    else
+    {
+        int rc = RTStrmOpen(pszOutput, "w", &g_hStrmOutput);
+        if (RT_FAILURE(rc))
+            return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to open output file '%s': %Rrc", pszOutput, rc);
+    }
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * Displays a disassembly error and returns @c false.
+ *
+ * @returns @c false.
+ * @param   pszFormat           The error format string.
+ * @param   ...                 Format argument.
+ */
+static bool disError(const char *pszFormat, ...)
+{
+    va_list va;
+    va_start(va, pszFormat);
+    RTMsgErrorV(pszFormat, va);
+    va_end(va);
+    return false;
+}
+
+
+/**
+ * Output the disassembly file header.
+ *
+ * @returns @c true on success,
+ */
+static bool disFileHeader(void)
+{
+    bool fRc;
+    fRc = outputPrintf("; $Id: MakeAlternativeSource.cpp $ \n"
+                       ";; @file\n"
+                       "; Auto Generated source file. Do not edit.\n"
+                       ";\n"
+                       );
+    if (!fRc)
+        return fRc;
+
+    /*
+     * List the header of each source file, up to and including the
+     * copyright notice.
+     */
+    bool fNeedLgplDisclaimer = false;
+    PBIOSOBJFILE pObjFile;
+    RTListForEach(&g_ObjList, pObjFile, BIOSOBJFILE, Node)
+    {
+        PRTSTREAM hStrm;
+        int rc = RTStrmOpen(pObjFile->pszSource, "r", &hStrm);
+        if (RT_SUCCESS(rc))
+        {
+            fRc = outputPrintf("\n"
+                               ";\n"
+                               "; Source file: %Rbn\n"
+                               ";\n"
+                               , pObjFile->pszSource);
+            uint32_t    iLine           = 0;
+            bool        fSeenCopyright  = false;
+            char        szLine[4096];
+            while ((rc = RTStrmGetLine(hStrm, szLine, sizeof(szLine))) == VINF_SUCCESS)
+            {
+                iLine++;
+
+                /* Check if we're done. */
+                char *psz = RTStrStrip(szLine);
+                if (   fSeenCopyright
+                    && (   (psz[0] == '*' && psz[1] == '/')
+                        || psz[0] == '\0') )
+                    break;
+
+                /* Strip comment suffix. */
+                size_t cch = strlen(psz);
+                if (cch >= 2 && psz[cch - 1] == '/' && psz[cch - 2] == '*')
+                {
+                    psz[cch - 2] = '\0';
+                    RTStrStripR(psz);
+                }
+
+                /* Skip line prefix. */
+                if (psz[0] == '/' && psz[1] == '*')
+                    psz += 2;
+                else if (psz[0] == '*')
+                    psz += 1;
+                else
+                    while (*psz == ';')
+                        psz++;
+                if (RT_C_IS_SPACE(*psz))
+                    psz++;
+
+                /* Skip the doxygen file tag line. */
+                if (!strcmp(psz, "* @file") || !strcmp(psz, "@file"))
+                    continue;
+
+                /* Detect copyright section. */
+                if (    !fSeenCopyright
+                    && (   strstr(psz, "Copyright")
+                        || strstr(psz, "copyright")) )
+                    fSeenCopyright = true;
+
+                /* Detect LGPL. */
+                if (strstr(psz, "LGPL"))
+                    fNeedLgplDisclaimer = true;
+
+                fRc = outputPrintf(";  %s\n", psz) && fRc;
+            }
+
+            RTStrmClose(hStrm);
+            if (rc != VINF_SUCCESS)
+                return disError("Error reading '%s': rc=%Rrc iLine=%u", pObjFile->pszSource, rc, iLine);
+        }
+    }
+
+    /*
+     * Add Oracle LGPL disclaimer.
+     */
+    if (fNeedLgplDisclaimer)
+        outputPrintf("\n"
+                     ";\n"
+                     "; Oracle LGPL Disclaimer: For the avoidance of doubt, except that if any license choice\n"
+                     "; other than GPL or LGPL is available it will apply instead, Oracle elects to use only\n"
+                     "; the Lesser General Public License version 2.1 (LGPLv2) at this time for any software where\n"
+                     "; a choice of LGPL license versions is made available with the language indicating\n"
+                     "; that LGPLv2 or any later version may be used, or where a choice of which version\n"
+                     "; of the LGPL is applied is otherwise unspecified.\n"
+                     ";\n"
+                     "\n");
+
+    /*
+     * Set the org.
+     */
+    fRc = outputPrintf("\n"
+                       "\n"
+                       "\n"
+                       ) && fRc;
+    return fRc;
+}
+
+
+/**
+ * Checks if a byte sequence could be a string litteral.
+ *
+ * @returns @c true if it is, @c false if it isn't.
+ * @param   uFlatAddr           The address of the byte sequence.
+ * @param   cb                  The length of the sequence.
+ */
+static bool disIsString(uint32_t uFlatAddr, uint32_t cb)
+{
+    if (cb < 6)
+        return false;
+
+    uint8_t const *pb = &g_pbImg[uFlatAddr - g_uBiosFlatBase];
+    while (cb > 0)
+    {
+        if (   !RT_C_IS_PRINT(*pb)
+            && *pb != '\r'
+            && *pb != '\n'
+            && *pb != '\t')
+        {
+            if (*pb == '\0')
+            {
+                do
+                {
+                    pb++;
+                    cb--;
+                } while (cb > 0 && *pb == '\0');
+                return cb == 0;
+            }
+            return false;
+        }
+        pb++;
+        cb--;
+    }
+
+    return true;
+}
+
+
+#if 0 /* unused */
+/**
+ * Checks if a dword could be a far 16:16 BIOS address.
+ *
+ * @returns @c true if it is, @c false if it isn't.
+ * @param   uFlatAddr           The address of the dword.
+ */
+static bool disIsFarBiosAddr(uint32_t uFlatAddr)
+{
+    uint16_t const *pu16 = (uint16_t const *)&g_pbImg[uFlatAddr - g_uBiosFlatBase];
+    if (pu16[1] < 0xf000)
+        return false;
+    if (pu16[1] > 0xfff0)
+        return false;
+    uint32_t uFlatAddr2 = (uint32_t)(pu16[1] << 4) | pu16[0];
+    if (uFlatAddr2 >= g_uBiosFlatBase + g_cbImg)
+        return false;
+    return true;
+}
+#endif
+
+
+static bool disByteData(uint32_t uFlatAddr, uint32_t cb)
+{
+    uint8_t const  *pb = &g_pbImg[uFlatAddr - g_uBiosFlatBase];
+    size_t          cbOnLine = 0;
+    while (cb-- > 0)
+    {
+        bool fRc;
+        if (cbOnLine >= 16)
+        {
+            fRc = outputPrintf("\n"
+                               "    db  0%02xh", *pb);
+            cbOnLine = 1;
+        }
+        else if (!cbOnLine)
+        {
+            fRc = outputPrintf("    db  0%02xh", *pb);
+            cbOnLine = 1;
+        }
+        else
+        {
+            fRc = outputPrintf(", 0%02xh", *pb);
+            cbOnLine++;
+        }
+        if (!fRc)
+            return false;
+        pb++;
+    }
+    return outputPrintf("\n");
+}
+
+
+static bool disWordData(uint32_t uFlatAddr, uint32_t cb)
+{
+    if (cb & 1)
+        return disError("disWordData expects word aligned size: cb=%#x uFlatAddr=%#x", uFlatAddr, cb);
+
+    uint16_t const *pu16 = (uint16_t const *)&g_pbImg[uFlatAddr - g_uBiosFlatBase];
+    size_t          cbOnLine = 0;
+    while (cb > 0)
+    {
+        bool fRc;
+        if (cbOnLine >= 16)
+        {
+            fRc = outputPrintf("\n"
+                               "    dw  0%04xh", *pu16);
+            cbOnLine = 2;
+        }
+        else if (!cbOnLine)
+        {
+            fRc = outputPrintf("    dw  0%04xh", *pu16);
+            cbOnLine = 2;
+        }
+        else
+        {
+            fRc = outputPrintf(", 0%04xh", *pu16);
+            cbOnLine += 2;
+        }
+        if (!fRc)
+            return false;
+        pu16++;
+        cb -= 2;
+    }
+    return outputPrintf("\n");
+}
+
+
+static bool disDWordData(uint32_t uFlatAddr, uint32_t cb)
+{
+    if (cb & 3)
+        return disError("disWordData expects dword aligned size: cb=%#x uFlatAddr=%#x", uFlatAddr, cb);
+
+    uint32_t const *pu32 = (uint32_t const *)&g_pbImg[uFlatAddr - g_uBiosFlatBase];
+    size_t          cbOnLine = 0;
+    while (cb > 0)
+    {
+        bool fRc;
+        if (cbOnLine >= 16)
+        {
+            fRc = outputPrintf("\n"
+                               "    dd  0%08xh", *pu32);
+            cbOnLine = 4;
+        }
+        else if (!cbOnLine)
+        {
+            fRc = outputPrintf("    dd  0%08xh", *pu32);
+            cbOnLine = 4;
+        }
+        else
+        {
+            fRc = outputPrintf(", 0%08xh", *pu32);
+            cbOnLine += 4;
+        }
+        if (!fRc)
+            return false;
+        pu32++;
+        cb -= 4;
+    }
+    return outputPrintf("\n");
+}
+
+
+static bool disStringData(uint32_t uFlatAddr, uint32_t cb)
+{
+    uint8_t const  *pb        = &g_pbImg[uFlatAddr - g_uBiosFlatBase];
+    uint32_t        cchOnLine = 0;
+    while (cb > 0)
+    {
+        /* Line endings and beginnings. */
+        if (cchOnLine >= 72)
+        {
+            if (!outputPrintf("\n"))
+                return false;
+            cchOnLine = 0;
+        }
+        if (   !cchOnLine
+            && !outputPrintf("    db  "))
+            return false;
+
+        /* See how many printable character we've got. */
+        uint32_t cchPrintable = 0;
+        while (   cchPrintable < cb
+               && RT_C_IS_PRINT(pb[cchPrintable])
+               && pb[cchPrintable] != '\'')
+            cchPrintable++;
+
+        bool fRc = true;
+        if (cchPrintable)
+        {
+            if (cchPrintable + cchOnLine > 72)
+                cchPrintable = 72 - cchOnLine;
+            if (cchOnLine)
+            {
+                fRc = outputPrintf(", '%.*s'", cchPrintable, pb);
+                cchOnLine += 4 + cchPrintable;
+            }
+            else
+            {
+                fRc = outputPrintf("'%.*s'", cchPrintable, pb);
+                cchOnLine += 2 + cchPrintable;
+            }
+            pb += cchPrintable;
+            cb -= cchPrintable;
+        }
+        else
+        {
+            if (cchOnLine)
+            {
+                fRc = outputPrintf(", 0%02xh", *pb);
+                cchOnLine += 6;
+            }
+            else
+            {
+                fRc = outputPrintf("0%02xh", *pb);
+                cchOnLine += 4;
+            }
+            pb++;
+            cb--;
+        }
+        if (!fRc)
+            return false;
+    }
+    return outputPrintf("\n");
+}
+
+
+/**
+ * For dumping a portion of a string table.
+ *
+ * @returns @c true on success, @c false on failure.
+ * @param   uFlatAddr           The start address.
+ * @param   cb                  The size of the string table.
+ */
+static bool disStringsData(uint32_t uFlatAddr, uint32_t cb)
+{
+    uint8_t const  *pb        = &g_pbImg[uFlatAddr - g_uBiosFlatBase];
+    uint32_t        cchOnLine = 0;
+    uint8_t         bPrev     = 255;
+    while (cb > 0)
+    {
+        /* Line endings and beginnings. */
+        if (   cchOnLine >= 72
+            || (bPrev == '\0' && *pb != '\0'))
+        {
+            if (!outputPrintf("\n"))
+                return false;
+            cchOnLine = 0;
+        }
+        if (   !cchOnLine
+            && !outputPrintf("    db   "))
+            return false;
+
+        /* See how many printable character we've got. */
+        uint32_t cchPrintable = 0;
+        while (   cchPrintable < cb
+               && RT_C_IS_PRINT(pb[cchPrintable])
+               && pb[cchPrintable] != '\'')
+            cchPrintable++;
+
+        bool fRc = true;
+        if (cchPrintable)
+        {
+            if (cchPrintable + cchOnLine > 72)
+                cchPrintable = 72 - cchOnLine;
+            if (cchOnLine)
+            {
+                fRc = outputPrintf(", '%.*s'", cchPrintable, pb);
+                cchOnLine += 4 + cchPrintable;
+            }
+            else
+            {
+                fRc = outputPrintf("'%.*s'", cchPrintable, pb);
+                cchOnLine += 2 + cchPrintable;
+            }
+            pb += cchPrintable;
+            cb -= cchPrintable;
+        }
+        else
+        {
+            if (cchOnLine)
+            {
+                fRc = outputPrintf(", 0%02xh", *pb);
+                cchOnLine += 6;
+            }
+            else
+            {
+                fRc = outputPrintf("0%02xh", *pb);
+                cchOnLine += 4;
+            }
+            pb++;
+            cb--;
+        }
+        if (!fRc)
+            return false;
+        bPrev = pb[-1];
+    }
+    return outputPrintf("\n");
+}
+
+
+/**
+ * Minds the gap between two segments.
+ *
+ * Gaps should generally be zero filled.
+ *
+ * @returns @c true on success, @c false on failure.
+ * @param   uFlatAddr           The address of the gap.
+ * @param   cbPadding           The size of the gap.
+ */
+static bool disCopySegmentGap(uint32_t uFlatAddr, uint32_t cbPadding)
+{
+    if (g_cVerbose > 0)
+        outputPrintf("\n"
+                     "  ; Padding %#x bytes at %#x\n", cbPadding, uFlatAddr);
+    uint8_t const  *pb = &g_pbImg[uFlatAddr - g_uBiosFlatBase];
+    if (ASMMemIsZero(pb, cbPadding))
+        return outputPrintf("  times %u db 0\n", cbPadding);
+
+    return disByteData(uFlatAddr, cbPadding);
+}
+
+
+/**
+ * Worker for disGetNextSymbol that only does the looking up, no RTDBSYMBOL::cb
+ * calc.
+ *
+ * @param   uFlatAddr           The address to start searching at.
+ * @param   cbMax               The size of the search range.
+ * @param   poff                Where to return the offset between the symbol
+ *                              and @a uFlatAddr.
+ * @param   pSym                Where to return the symbol data.
+ */
+static void disGetNextSymbolWorker(uint32_t uFlatAddr, uint32_t cbMax, uint32_t *poff, PRTDBGSYMBOL pSym)
+{
+    RTINTPTR offMap = RTINTPTR_MAX;
+    RTDBGSYMBOL MapSym;
+    int rcMap = RTDbgModSymbolByAddr(g_hMapMod, RTDBGSEGIDX_RVA, uFlatAddr, RTDBGSYMADDR_FLAGS_GREATER_OR_EQUAL, &offMap, &MapSym);
+
+    RTINTPTR off = RTINTPTR_MAX;
+    int rc = RTDbgModSymbolByAddr(g_hSymMod, RTDBGSEGIDX_RVA, uFlatAddr - g_uBiosFlatBase,
+                                  RTDBGSYMADDR_FLAGS_GREATER_OR_EQUAL, &off, pSym);
+    if (   RT_SUCCESS(rc)
+        && RT_ABS(off) <= RT_ABS(offMap))
+        pSym->Value += g_uBiosFlatBase;
+    else
+    {
+        *pSym = MapSym;
+        off   = offMap;
+        rc    = rcMap;
+    }
+    if (RT_SUCCESS(rc))
+    {
+        /* negative offset, indicates beyond. */
+        if (off <= 0)
+        {
+            *poff = (uint32_t)-off;
+
+            /* Mangle symbols the assembler might confuse with instructions. */
+            size_t cchName = strlen(pSym->szName);
+            if (   cchName <= 4
+                && (   strcmp("wait", pSym->szName) == 0
+                    || strcmp("hlt", pSym->szName) == 0))
+            {
+                memmove(&pSym->szName[1], &pSym->szName[0], cchName);
+                pSym->szName[0] = '_';
+                pSym->szName[cchName + 1] = '_';
+                pSym->szName[cchName + 2] = '\0';
+            }
+            return;
+        }
+
+        outputPrintf("  ; !! RTDbgModSymbolByAddr(,,%#x,,) -> off=%RTptr cb=%RTptr uValue=%RTptr '%s'\n",
+                     uFlatAddr, off, pSym->cb, pSym->Value, pSym->szName);
+    }
+    else if (rc != VERR_SYMBOL_NOT_FOUND)
+        outputPrintf("  ; !! RTDbgModSymbolByAddr(,,%#x,,) -> %Rrc\n", uFlatAddr, rc);
+
+    RTStrPrintf(pSym->szName, sizeof(pSym->szName), "_dummy_addr_%#x", uFlatAddr + cbMax);
+    pSym->Value     = uFlatAddr + cbMax;
+    pSym->cb        = 0;
+    pSym->offSeg    = uFlatAddr + cbMax;
+    pSym->iSeg      = RTDBGSEGIDX_RVA;
+    pSym->iOrdinal  = 0;
+    pSym->fFlags    = 0;
+    *poff = cbMax;
+}
+
+
+/**
+ * Gets the symbol at or after the given address.
+ *
+ * If there are no symbols in the specified range, @a pSym and @a poff will be
+ * set up to indicate a symbol at the first byte after the range.
+ *
+ * @param   uFlatAddr           The address to start searching at.
+ * @param   cbMax               The size of the search range.
+ * @param   poff                Where to return the offset between the symbol
+ *                              and @a uFlatAddr.
+ * @param   pSym                Where to return the symbol data.
+ */
+static void disGetNextSymbol(uint32_t uFlatAddr, uint32_t cbMax, uint32_t *poff, PRTDBGSYMBOL pSym)
+{
+    disGetNextSymbolWorker(uFlatAddr, cbMax, poff, pSym);
+    if (   *poff < cbMax
+        && pSym->cb == 0)
+    {
+        if (*poff + 1 < cbMax)
+        {
+            uint32_t    off2;
+            RTDBGSYMBOL Sym2;
+            disGetNextSymbolWorker(uFlatAddr + *poff + 1, cbMax - *poff - 1, &off2, &Sym2);
+            pSym->cb = off2 + 1;
+        }
+        else
+            pSym->cb = 1;
+    }
+    if (pSym->cb > cbMax - *poff)
+        pSym->cb = cbMax - *poff;
+
+    if (g_cVerbose > 1)
+        outputPrintf("  ; disGetNextSymbol %#x LB %#x -> off=%#x cb=%RTptr uValue=%RTptr '%s'\n",
+                     uFlatAddr, cbMax, *poff, pSym->cb, pSym->Value, pSym->szName);
+
+}
+
+
+/**
+ * For dealing with the const segment (string constants).
+ *
+ * @returns @c true on success, @c false on failure.
+ * @param   iSeg                The segment.
+ */
+static bool disConstSegment(uint32_t iSeg)
+{
+    uint32_t    uFlatAddr = g_aSegs[iSeg].uFlatAddr;
+    uint32_t    cb        = g_aSegs[iSeg].cb;
+
+    while (cb > 0)
+    {
+        uint32_t    off;
+        RTDBGSYMBOL Sym;
+        disGetNextSymbol(uFlatAddr, cb, &off, &Sym);
+
+        if (off > 0)
+        {
+            if (!disStringsData(uFlatAddr, off))
+                return false;
+            cb        -= off;
+            uFlatAddr += off;
+            off        = 0;
+            if (!cb)
+                break;
+        }
+
+        bool fRc;
+        if (off == 0)
+        {
+            size_t cchName = strlen(Sym.szName);
+            fRc = outputPrintf("%s: %*s; %#x LB %#x\n", Sym.szName, cchName < 41 - 2 ? cchName - 41 - 2 : 0, "", uFlatAddr, Sym.cb);
+            if (!fRc)
+                return false;
+            fRc = disStringsData(uFlatAddr, Sym.cb);
+            uFlatAddr += Sym.cb;
+            cb        -= Sym.cb;
+        }
+        else
+        {
+            fRc = disStringsData(uFlatAddr, Sym.cb);
+            uFlatAddr += cb;
+            cb = 0;
+        }
+        if (!fRc)
+            return false;
+    }
+
+    return true;
+}
+
+
+
+static bool disDataSegment(uint32_t iSeg)
+{
+    uint32_t    uFlatAddr = g_aSegs[iSeg].uFlatAddr;
+    uint32_t    cb        = g_aSegs[iSeg].cb;
+
+    while (cb > 0)
+    {
+        uint32_t    off;
+        RTDBGSYMBOL Sym;
+        disGetNextSymbol(uFlatAddr, cb, &off, &Sym);
+
+        if (off > 0)
+        {
+            if (!disByteData(uFlatAddr, off))
+                return false;
+            cb        -= off;
+            uFlatAddr += off;
+            off        = 0;
+            if (!cb)
+                break;
+        }
+
+        bool fRc;
+        if (off == 0)
+        {
+            size_t cchName = strlen(Sym.szName);
+            fRc = outputPrintf("%s: %*s; %#x LB %#x\n", Sym.szName, cchName < 41 - 2 ? cchName - 41 - 2 : 0, "", uFlatAddr, Sym.cb);
+            if (!fRc)
+                return false;
+
+            if (Sym.cb == 2)
+                fRc = disWordData(uFlatAddr, 2);
+            //else if (Sym.cb == 4 && disIsFarBiosAddr(uFlatAddr))
+            //    fRc = disDWordData(uFlatAddr, 4);
+            else if (Sym.cb == 4)
+                fRc = disDWordData(uFlatAddr, 4);
+            else if (disIsString(uFlatAddr, Sym.cb))
+                fRc = disStringData(uFlatAddr, Sym.cb);
+            else
+                fRc = disByteData(uFlatAddr, Sym.cb);
+
+            uFlatAddr += Sym.cb;
+            cb        -= Sym.cb;
+        }
+        else
+        {
+            fRc = disByteData(uFlatAddr, cb);
+            uFlatAddr += cb;
+            cb = 0;
+        }
+        if (!fRc)
+            return false;
+    }
+
+    return true;
+}
+
+
+static bool disIsCodeAndAdjustSize(uint32_t uFlatAddr, PRTDBGSYMBOL pSym, PBIOSSEG pSeg)
+{
+    RT_NOREF_PV(uFlatAddr);
+
+    switch (g_enmBiosType)
+    {
+        /*
+         * This is for the PC BIOS.
+         */
+        case kBiosType_System:
+            if (!strcmp(pSeg->szName, "BIOSSEG"))
+            {
+                if (   !strcmp(pSym->szName, "rom_fdpt")
+                    || !strcmp(pSym->szName, "pmbios_gdt")
+                    || !strcmp(pSym->szName, "pmbios_gdt_desc")
+                    || !strcmp(pSym->szName, "_pmode_IDT")
+                    || !strcmp(pSym->szName, "_rmode_IDT")
+                    || !strncmp(pSym->szName, RT_STR_TUPLE("font"))
+                    || !strcmp(pSym->szName, "bios_string")
+                    || !strcmp(pSym->szName, "vector_table")
+                    || !strcmp(pSym->szName, "pci_routing_table_structure")
+                    || !strcmp(pSym->szName, "_pci_routing_table")
+                    )
+                    return false;
+            }
+
+            if (!strcmp(pSym->szName, "cpu_reset"))
+                pSym->cb = RT_MIN(pSym->cb, 5);
+            else if (!strcmp(pSym->szName, "pci_init_end"))
+                pSym->cb = RT_MIN(pSym->cb, 3);
+            break;
+
+        /*
+         * This is for the VGA BIOS.
+         */
+        case kBiosType_Vga:
+            break;
+    }
+
+    return true;
+}
+
+
+static bool disIs16BitCode(const char *pszSymbol)
+{
+    RT_NOREF_PV(pszSymbol);
+    return true;
+}
+
+
+static bool disIsMemoryParameter(PCDISOPPARAM pParam, uint16_t fParam)
+{
+    return fParam != OP_PARM_NONE
+        && DISUSE_IS_EFFECTIVE_ADDR(pParam->fUse);
+}
+
+
+static bool disAccessesMemory(PCDISCPUSTATE pCpuState)
+{
+    PCDISOPCODE pCurInstr = pCpuState->pCurInstr;
+    return disIsMemoryParameter(&pCpuState->Param1, pCurInstr->fParam1)
+        || disIsMemoryParameter(&pCpuState->Param2, pCurInstr->fParam2)
+        || disIsMemoryParameter(&pCpuState->Param3, pCurInstr->fParam3)
+        || disIsMemoryParameter(&pCpuState->Param4, pCurInstr->fParam4);
+}
+
+
+/**
+ * Deals with instructions that YASM will assemble differently than WASM/WCC.
+ */
+static size_t disHandleYasmDifferences(PDISCPUSTATE pCpuState, uint32_t uFlatAddr, uint32_t cbInstr,
+                                       char *pszBuf, size_t cbBuf, size_t cchUsed)
+{
+    bool fDifferent = DISFormatYasmIsOddEncoding(pCpuState);
+    uint8_t const  *pb = &g_pbImg[uFlatAddr - g_uBiosFlatBase];
+
+    /*
+     * Disassembler bugs.
+     */
+    /** @todo Group 1a and 11 seems to be disassembled incorrectly when
+     *        modrm.reg != 0. Those encodings should be invalid AFAICT. */
+
+    if (   (   pCpuState->bOpCode  == 0x8f            /* group 1a */
+            || pCpuState->bOpCode  == 0xc7            /* group 11 */
+            || pCpuState->bOpCode  == 0xc6            /* group 11 - not verified */
+           )
+        && pCpuState->ModRM.Bits.Reg != 0)
+        fDifferent = true;
+    /*
+     * Check these out and consider adding them to DISFormatYasmIsOddEncoding.
+     */
+    else if (   pb[0] == 0xf3
+             && pb[1] == 0x66
+             && pb[2] == 0x6d)
+        fDifferent = true; /* rep insd      - prefix switched. */
+    else if (   pb[0] == 0xc6
+             && pb[1] == 0xc5
+             && pb[2] == 0xba)
+        fDifferent = true; /* mov ch, 0bah  - yasm uses a short sequence: 0xb5 0xba. */
+
+    /*
+     * 32-bit retf.
+     */
+    else if (   pb[0] == 0x66
+             && pb[1] == 0xcb)
+        fDifferent = true;
+
+    /*
+     * Handle different stuff.
+     */
+    if (fDifferent)
+    {
+        disByteData(uFlatAddr, cbInstr); /* lazy bird. */
+
+        if (cchUsed + 2 < cbBuf)
+        {
+            memmove(pszBuf + 2, pszBuf, cchUsed + 1); /* include terminating \0 */
+            cchUsed += 2;
+        }
+
+        pszBuf[0] = ';';
+        pszBuf[1] = ' ';
+    }
+
+    return cchUsed;
+}
+
+
+/**
+ * @callback_method_impl{FNDISREADBYTES}
+ *
+ * @remarks @a uSrcAddr is the flat address.
+ */
+static DECLCALLBACK(int) disReadOpcodeBytes(PDISCPUSTATE pDis, uint8_t offInstr, uint8_t cbMinRead, uint8_t cbMaxRead)
+{
+    RT_NOREF_PV(cbMinRead);
+
+    RTUINTPTR   offBios  = pDis->uInstrAddr + offInstr - g_uBiosFlatBase;
+    size_t      cbToRead = cbMaxRead;
+    if (offBios + cbToRead > g_cbImg)
+    {
+        if (offBios >= g_cbImg)
+            cbToRead = 0;
+        else
+            cbToRead = g_cbImg - offBios;
+    }
+    memcpy(&pDis->abInstr[offInstr], &g_pbImg[offBios], cbToRead);
+    pDis->cbCachedInstr = (uint8_t)(offInstr + cbToRead);
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Disassembles code.
+ *
+ * @returns @c true on success, @c false on failure.
+ * @param   uFlatAddr           The address where the code starts.
+ * @param   cb                  The amount of code to disassemble.
+ * @param   fIs16Bit            Is is 16-bit (@c true) or 32-bit (@c false).
+ */
+static bool disCode(uint32_t uFlatAddr, uint32_t cb, bool fIs16Bit)
+{
+    uint8_t const  *pb = &g_pbImg[uFlatAddr - g_uBiosFlatBase];
+
+    while (cb > 0)
+    {
+        /* Trailing zero padding detection. */
+        if (   *pb == '\0'
+            && ASMMemIsZero(pb, RT_MIN(cb, 8)))
+        {
+            void    *pv      = ASMMemFirstNonZero(pb, cb);
+            uint32_t cbZeros = pv ? (uint32_t)((uint8_t const *)pv - pb) : cb;
+            if (!outputPrintf("    times %#x db 0\n", cbZeros))
+                return false;
+            cb -= cbZeros;
+            pb += cbZeros;
+            uFlatAddr += cbZeros;
+            if (   cb == 2
+                && pb[0] == 'X'
+                && pb[1] == 'M')
+                return disStringData(uFlatAddr, cb);
+        }
+        /* Work arounds for switch tables and such (disas assertions). */
+        else if (    0
+                 || (   pb[0] == 0x50   /* int13_cdemu switch */
+                     && pb[1] == 0x4e
+                     && pb[2] == 0x49
+                     && pb[3] == 0x48
+                     && pb[4] == 0x47
+                    )
+                 || (   pb[0] == 0x8b   /* _int13_harddisk_ext switch */
+                     && pb[1] == 0x46
+                     && pb[2] == 0x16
+                     && pb[3] == 0x30
+                     && pb[4] == 0xe8
+                     && pb[5] == 0x80
+                    )
+                 || (   pb[0] == 0xd8
+                     && pb[1] == 0x5f
+                     && pb[2] == 0x0b
+                     && pb[3] == 0x60
+                     && pb[4] == 0x0b
+                     && pb[5] == 0x60
+                    )
+                 || (   pb[0] == 0x67   /* _pci16_function switch */
+                     && pb[1] == 0x92
+                     && pb[2] == 0x81
+                     && pb[3] == 0x92
+                     && pb[4] == 0x94
+                     && pb[5] == 0x92
+                     )
+                 || (   pb[0] == 0xa3   /* _int1a_function switch */
+                     && pb[1] == 0x67
+                     && pb[2] == 0xca
+                     && pb[3] == 0x67
+                     && pb[4] == 0xef
+                     && pb[5] == 0x67
+                    )
+                 || (   pb[0] == 0x0b   /* _ahci_init byte table */
+                     && pb[1] == 0x05
+                     && pb[2] == 0x04
+                     && pb[3] == 0x03
+                     && pb[4] == 0x02
+                     && pb[5] == 0x01
+                    )
+                 || (   pb[0] == 0x00   /* bytes after apm_out_str_ */
+                     && pb[1] == 0x00
+                     && pb[2] == 0x00
+                     && pb[3] == 0x00
+                     && pb[4] == 0x00
+                     && pb[5] == 0x00
+                     && pb[6] == 0xe0
+                     && pb[7] == 0xa0
+                     && pb[8] == 0xe2
+                     && pb[9] == 0xa0
+                    )
+                 || (   pb[0] == 0xf0   /* switch for apm_worker */
+                     && pb[1] == 0xa0
+                     && pb[2] == 0xf2
+                     && pb[3] == 0xa0
+                     && pb[4] == 0xf6
+                     && pb[5] == 0xa0
+                    )
+                 || (   pb[0] == 0xd4
+                     && pb[1] == 0xc6
+                     && pb[2] == 0xc5
+                     && pb[3] == 0xba
+                     && pb[4] == 0xb8
+                     && pb[5] == 0xb6
+                    )
+                 || (   pb[0] == 0xec   /* _int15_function switch */
+                     && pb[1] == 0xe9
+                     && pb[2] == 0xd8
+                     && pb[3] == 0xc1
+                     && pb[4] == 0xc0
+                     && pb[5] == 0xbf
+                    )
+                 || (   pb[0] == 0x21   /* _int15_function32 switch */
+                     && pb[1] == 0x66
+                     && pb[2] == 0x43
+                     && pb[3] == 0x66
+                     && pb[4] == 0x66
+                     && pb[5] == 0x66
+                    )
+                 || (   pb[0] == 0xf0   /* int15_function_mouse switch */
+                     && pb[1] == 0x75
+                     && pb[2] == 0x66
+                     && pb[3] == 0x76
+                     && pb[4] == 0xe9
+                     && pb[5] == 0x76
+                    )
+                 || (   pb[0] == 0x60
+                     && pb[1] == 0xa0
+                     && pb[2] == 0x62
+                     && pb[3] == 0xa0
+                     && pb[4] == 0x66
+                     && pb[5] == 0xa0
+                    )
+                 || 0
+                 )
+            return disByteData(uFlatAddr, cb);
+        else
+        {
+            unsigned    cbInstr;
+            DISCPUSTATE CpuState;
+            CpuState.ModRM.Bits.Mod = 3;
+            int rc = DISInstrWithReader(uFlatAddr, fIs16Bit ? DISCPUMODE_16BIT : DISCPUMODE_32BIT,
+                                        disReadOpcodeBytes, NULL, &CpuState, &cbInstr);
+            if (   RT_SUCCESS(rc)
+                && cbInstr <= cb
+                && CpuState.pCurInstr
+                && CpuState.pCurInstr->uOpcode != OP_INVALID
+                && CpuState.pCurInstr->uOpcode != OP_ILLUD2
+                && (   !(CpuState.fPrefix & DISPREFIX_ADDRSIZE)
+                    || disAccessesMemory(&CpuState)))
+            {
+                char szTmp[4096];
+                size_t cch = DISFormatYasmEx(&CpuState, szTmp, sizeof(szTmp),
+                                             DIS_FMT_FLAGS_STRICT
+                                             | DIS_FMT_FLAGS_BYTES_RIGHT | DIS_FMT_FLAGS_BYTES_COMMENT | DIS_FMT_FLAGS_BYTES_SPACED,
+                                             NULL, NULL);
+                cch = disHandleYasmDifferences(&CpuState, uFlatAddr, cbInstr, szTmp, sizeof(szTmp), cch);
+                Assert(cch < sizeof(szTmp));
+
+                if (g_cVerbose > 1)
+                {
+                    while (cch < 72)
+                        szTmp[cch++] = ' ';
+
+                    RTDBGLINE LineInfo = {0};
+                    RTINTPTR  offLine = -1;
+                    int rcLine = RTDbgModLineByAddr(g_hSymMod, RTDBGSEGIDX_RVA, uFlatAddr - g_uBiosFlatBase,  &offLine, &LineInfo);
+                    if (RT_SUCCESS(rcLine) && offLine == 0 && cch < sizeof(szTmp) - 16)
+                        RTStrPrintf(&szTmp[cch], sizeof(szTmp) - cch, "; %#x %Rbn:%u",
+                                    uFlatAddr, LineInfo.szFilename, LineInfo.uLineNo);
+                    else
+                        RTStrPrintf(&szTmp[cch], sizeof(szTmp) - cch, "; %#x", uFlatAddr);
+                }
+
+                if (!outputPrintf("    %s\n", szTmp))
+                    return false;
+                cb -= cbInstr;
+                pb += cbInstr;
+                uFlatAddr += cbInstr;
+            }
+            else
+            {
+                if (!disByteData(uFlatAddr, 1))
+                    return false;
+                cb--;
+                pb++;
+                uFlatAddr++;
+            }
+        }
+    }
+    return true;
+}
+
+
+static bool disCodeSegment(uint32_t iSeg)
+{
+    uint32_t    uFlatAddr = g_aSegs[iSeg].uFlatAddr;
+    uint32_t    cb        = g_aSegs[iSeg].cb;
+
+    while (cb > 0)
+    {
+        uint32_t    off;
+        RTDBGSYMBOL Sym;
+        disGetNextSymbol(uFlatAddr, cb, &off, &Sym);
+
+        if (off > 0)
+        {
+            if (!disByteData(uFlatAddr, off))
+                return false;
+            cb        -= off;
+            uFlatAddr += off;
+            off        = 0;
+            if (!cb)
+                break;
+        }
+
+        bool fRc;
+        if (off == 0)
+        {
+            size_t cchName = strlen(Sym.szName);
+            fRc = outputPrintf("%s: %*s; %#x LB %#x\n", Sym.szName, cchName < 41 - 2 ? cchName - 41 - 2 : 0, "", uFlatAddr, Sym.cb);
+            if (!fRc)
+                return false;
+
+            if (disIsCodeAndAdjustSize(uFlatAddr, &Sym, &g_aSegs[iSeg]))
+                fRc = disCode(uFlatAddr, Sym.cb, disIs16BitCode(Sym.szName));
+            else
+                fRc = disByteData(uFlatAddr, Sym.cb);
+
+            uFlatAddr += Sym.cb;
+            cb        -= Sym.cb;
+        }
+        else
+        {
+            fRc = disByteData(uFlatAddr, cb);
+            uFlatAddr += cb;
+            cb = 0;
+        }
+        if (!fRc)
+            return false;
+    }
+
+    return true;
+}
+
+
+static RTEXITCODE DisassembleBiosImage(void)
+{
+    if (!disFileHeader())
+        return RTEXITCODE_FAILURE;
+
+    /*
+     * Work the image segment by segment.
+     */
+    bool        fRc       = true;
+    uint32_t    uFlatAddr = g_uBiosFlatBase;
+    for (uint32_t iSeg = 0; iSeg < g_cSegs && fRc; iSeg++)
+    {
+        /* Is there a gap between the segments? */
+        if (uFlatAddr < g_aSegs[iSeg].uFlatAddr)
+        {
+            fRc = disCopySegmentGap(uFlatAddr, g_aSegs[iSeg].uFlatAddr - uFlatAddr);
+            if (!fRc)
+                break;
+            uFlatAddr = g_aSegs[iSeg].uFlatAddr;
+        }
+        else if (uFlatAddr > g_aSegs[iSeg].uFlatAddr)
+            return RTMsgErrorExit(RTEXITCODE_FAILURE, "Overlapping segments: %u and %u; uFlatAddr=%#x\n", iSeg - 1, iSeg, uFlatAddr);
+
+        /* Disassemble the segment. */
+        fRc = outputPrintf("\n"
+                           "section %s progbits vstart=%#x align=1 ; size=%#x class=%s group=%s\n",
+                           g_aSegs[iSeg].szName, g_aSegs[iSeg].uFlatAddr - g_uBiosFlatBase,
+                           g_aSegs[iSeg].cb, g_aSegs[iSeg].szClass, g_aSegs[iSeg].szGroup);
+        if (!fRc)
+            return RTEXITCODE_FAILURE;
+        if (!strcmp(g_aSegs[iSeg].szName, "CONST"))
+            fRc = disConstSegment(iSeg);
+        else if (!strcmp(g_aSegs[iSeg].szClass, "DATA"))
+            fRc = disDataSegment(iSeg);
+        else
+            fRc = disCodeSegment(iSeg);
+
+        /* Advance. */
+        uFlatAddr += g_aSegs[iSeg].cb;
+    }
+
+    /* Final gap. */
+    if (uFlatAddr < g_uBiosFlatBase + g_cbImg)
+        fRc = disCopySegmentGap(uFlatAddr, (uint32_t)(g_uBiosFlatBase + g_cbImg - uFlatAddr));
+    else if (uFlatAddr > g_uBiosFlatBase + g_cbImg)
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "Last segment spills beyond 1MB; uFlatAddr=%#x\n", uFlatAddr);
+
+    if (!fRc)
+        return RTEXITCODE_FAILURE;
+    return RTEXITCODE_SUCCESS;
+}
+
+
+
+/**
+ * Parses the symbol file for the BIOS.
+ *
+ * This is in ELF/DWARF format.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pszBiosSym          Path to the sym file.
+ */
+static RTEXITCODE ParseSymFile(const char *pszBiosSym)
+{
+    int rc = RTDbgModCreateFromImage(&g_hSymMod, pszBiosSym, "VBoxBios",  RTLDRARCH_WHATEVER, NIL_RTDBGCFG);
+    if (RT_FAILURE(rc))
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "Error opening '%s': %Rrc", pszBiosSym, rc);
+
+    if (g_cVerbose > 0)
+    {
+        /* Show segments */
+        RTDBGSEGIDX cSegs = RTDbgModSegmentCount(g_hSymMod);
+        for (RTDBGSEGIDX iSeg = 0; iSeg < cSegs; iSeg++)
+        {
+            RTDBGSEGMENT SegInfo;
+            rc = RTDbgModSegmentByIndex(g_hSymMod, iSeg, &SegInfo);
+            if (RT_SUCCESS(rc))
+                RTMsgInfo("Seg#%u: %05RX64 LB %04RX64 rva %04RX64 %s\n", iSeg, SegInfo.Address, SegInfo.cb, SegInfo.uRva, SegInfo.szName);
+            else
+                RTMsgInfo("Seg#%u: RTDbgModSegmentByIndex -> %Rrc\n", iSeg, rc);
+
+        }
+    }
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * Display an error with the mapfile name and current line, return false.
+ *
+ * @returns @c false.
+ * @param   pMap                The map file handle.
+ * @param   pszFormat           The format string.
+ * @param   ...                 Format arguments.
+ */
+static bool mapError(PBIOSMAP pMap, const char *pszFormat, ...)
+{
+    va_list va;
+    va_start(va, pszFormat);
+    RTMsgError("%s:%d: %N", pMap->pszMapFile, pMap->iLine, pszFormat, &va);
+    va_end(va);
+    return false;
+}
+
+
+/**
+ * Reads a line from the file.
+ *
+ * @returns @c true on success, @c false + msg on failure, @c false on eof.
+ * @param   pMap                The map file handle.
+ */
+static bool mapReadLine(PBIOSMAP pMap)
+{
+    int rc = RTStrmGetLine(pMap->hStrm, pMap->szLine, sizeof(pMap->szLine));
+    if (RT_FAILURE(rc))
+    {
+        if (rc == VERR_EOF)
+        {
+            pMap->fEof      = true;
+            pMap->cch       = 0;
+            pMap->offNW     = 0;
+            pMap->szLine[0] = '\0';
+        }
+        else
+            RTMsgError("%s:%d: Read error %Rrc", pMap->pszMapFile, pMap->iLine + 1, rc);
+        return false;
+    }
+    pMap->iLine++;
+    pMap->cch   = (uint32_t)strlen(pMap->szLine);
+
+    /* Check out leading white space. */
+    if (!RT_C_IS_SPACE(pMap->szLine[0]))
+        pMap->offNW = 0;
+    else
+    {
+        uint32_t off = 1;
+        while (RT_C_IS_SPACE(pMap->szLine[off]))
+            off++;
+        pMap->offNW = off;
+    }
+
+    return true;
+}
+
+
+/**
+ * Checks if it is an empty line.
+ * @returns @c true if empty, @c false if not.
+ * @param   pMap                The map file handle.
+ */
+static bool mapIsEmptyLine(PBIOSMAP pMap)
+{
+    Assert(pMap->offNW <= pMap->cch);
+    return pMap->offNW == pMap->cch;
+}
+
+
+/**
+ * Reads ahead in the map file until a non-empty line or EOF is encountered.
+ *
+ * @returns @c true on success, @c false + msg on failure, @c false on eof.
+ * @param   pMap                The map file handle.
+ */
+static bool mapSkipEmptyLines(PBIOSMAP pMap)
+{
+    for (;;)
+    {
+        if (!mapReadLine(pMap))
+            return false;
+        if (pMap->offNW < pMap->cch)
+            return true;
+    }
+}
+
+
+/**
+ * Reads ahead in the map file until an empty line or EOF is encountered.
+ *
+ * @returns @c true on success, @c false + msg on failure, @c false on eof.
+ * @param   pMap                The map file handle.
+ */
+static bool mapSkipNonEmptyLines(PBIOSMAP pMap)
+{
+    for (;;)
+    {
+        if (!mapReadLine(pMap))
+            return false;
+        if (pMap->offNW == pMap->cch)
+            return true;
+    }
+}
+
+
+/**
+ * Strips the current line.
+ *
+ * The string length may change.
+ *
+ * @returns Pointer to the first non-space character.
+ * @param   pMap                The map file handle.
+ * @param   pcch                Where to return the length of the unstripped
+ *                              part.  Optional.
+ */
+static char *mapStripCurrentLine(PBIOSMAP pMap, size_t *pcch)
+{
+    char *psz    = &pMap->szLine[pMap->offNW];
+    char *pszEnd = &pMap->szLine[pMap->cch];
+    while (   (uintptr_t)pszEnd > (uintptr_t)psz
+           && RT_C_IS_SPACE(pszEnd[-1]))
+    {
+        *--pszEnd = '\0';
+        pMap->cch--;
+    }
+    if (pcch)
+        *pcch = pszEnd - psz;
+    return psz;
+}
+
+
+/**
+ * Reads a line from the file and right strips it.
+ *
+ * @returns Pointer to szLine on success, @c NULL + msg on failure, @c NULL on
+ *          EOF.
+ * @param   pMap                The map file handle.
+ * @param   pcch                Where to return the length of the unstripped
+ *                              part.  Optional.
+ */
+static char *mapReadLineStripRight(PBIOSMAP pMap, size_t *pcch)
+{
+    if (!mapReadLine(pMap))
+        return NULL;
+    mapStripCurrentLine(pMap, NULL);
+    if (pcch)
+        *pcch = pMap->cch;
+    return pMap->szLine;
+}
+
+
+/**
+ * mapReadLine() + mapStripCurrentLine().
+ *
+ * @returns Pointer to the first non-space character in the new line. NULL on
+ *          read error (bitched already) or end of file.
+ * @param   pMap                The map file handle.
+ * @param   pcch                Where to return the length of the unstripped
+ *                              part.  Optional.
+ */
+static char *mapReadLineStrip(PBIOSMAP pMap, size_t *pcch)
+{
+    if (!mapReadLine(pMap))
+        return NULL;
+    return mapStripCurrentLine(pMap, pcch);
+}
+
+
+/**
+ * Parses a word, copying it into the supplied buffer, and skipping any spaces
+ * following it.
+ *
+ * @returns @c true on success, @c false on failure.
+ * @param   ppszCursor          Pointer to the cursor variable.
+ * @param   pszBuf              The output buffer.
+ * @param   cbBuf               The size of the output buffer.
+ */
+static bool mapParseWord(char **ppszCursor, char *pszBuf, size_t cbBuf)
+{
+    /* Check that we start on a non-blank. */
+    char *pszStart  = *ppszCursor;
+    if (!*pszStart || RT_C_IS_SPACE(*pszStart))
+        return false;
+
+    /* Find the end of the word. */
+    char *psz = pszStart + 1;
+    while (*psz && !RT_C_IS_SPACE(*psz))
+        psz++;
+
+    /* Copy it. */
+    size_t cchWord = (uintptr_t)psz - (uintptr_t)pszStart;
+    if (cchWord >= cbBuf)
+        return false;
+    memcpy(pszBuf, pszStart, cchWord);
+    pszBuf[cchWord] = '\0';
+
+    /* Skip blanks following it. */
+    while (RT_C_IS_SPACE(*psz))
+        psz++;
+    *ppszCursor = psz;
+    return true;
+}
+
+
+/**
+ * Parses an 16:16 address.
+ *
+ * @returns @c true on success, @c false on failure.
+ * @param   ppszCursor          Pointer to the cursor variable.
+ * @param   pAddr               Where to return the address.
+ */
+static bool mapParseAddress(char **ppszCursor, PRTFAR16 pAddr)
+{
+    char szWord[32];
+    if (!mapParseWord(ppszCursor, szWord, sizeof(szWord)))
+        return false;
+    size_t cchWord = strlen(szWord);
+
+    /* An address is at least 16:16 format. It may be 16:32. It may also be flagged. */
+    size_t cchAddr = 4 + 1 + 4;
+    if (cchWord < cchAddr)
+        return false;
+    if (   !RT_C_IS_XDIGIT(szWord[0])
+        || !RT_C_IS_XDIGIT(szWord[1])
+        || !RT_C_IS_XDIGIT(szWord[2])
+        || !RT_C_IS_XDIGIT(szWord[3])
+        || szWord[4] != ':'
+        || !RT_C_IS_XDIGIT(szWord[5])
+        || !RT_C_IS_XDIGIT(szWord[6])
+        || !RT_C_IS_XDIGIT(szWord[7])
+        || !RT_C_IS_XDIGIT(szWord[8])
+       )
+        return false;
+    if (   cchWord > cchAddr
+        && RT_C_IS_XDIGIT(szWord[9])
+        && RT_C_IS_XDIGIT(szWord[10])
+        && RT_C_IS_XDIGIT(szWord[11])
+        && RT_C_IS_XDIGIT(szWord[12]))
+        cchAddr += 4;
+
+    /* Drop flag if present. */
+    if (cchWord > cchAddr)
+    {
+        if (RT_C_IS_XDIGIT(szWord[cchAddr]))
+            return false;
+        szWord[cchAddr] = '\0';
+        cchWord = cchAddr;
+    }
+
+    /* Convert it. */
+    szWord[4] = '\0';
+    int rc1 = RTStrToUInt16Full(szWord,     16, &pAddr->sel);
+    if (rc1 != VINF_SUCCESS)
+        return false;
+
+    int rc2 = RTStrToUInt16Full(szWord + 5, 16, &pAddr->off);
+    if (rc2 != VINF_SUCCESS)
+        return false;
+    return true;
+}
+
+
+/**
+ * Parses a size.
+ *
+ * @returns @c true on success, @c false on failure.
+ * @param   ppszCursor          Pointer to the cursor variable.
+ * @param   pcb                 Where to return the size.
+ */
+static bool mapParseSize(char **ppszCursor, uint32_t *pcb)
+{
+    char szWord[32];
+    if (!mapParseWord(ppszCursor, szWord, sizeof(szWord)))
+        return false;
+    size_t cchWord = strlen(szWord);
+    if (cchWord != 8)
+        return false;
+
+    int rc = RTStrToUInt32Full(szWord, 16, pcb);
+    if (rc != VINF_SUCCESS)
+        return false;
+    return true;
+}
+
+
+/**
+ * Parses a section box and the following column header.
+ *
+ * @returns @c true on success, @c false + msg on failure, @c false on eof.
+ * @param   pMap            Map file handle.
+ * @param   pszSectionNm    The expected section name.
+ * @param   cColumns        The number of columns.
+ * @param   ...             The column names.
+ */
+static bool mapSkipThruColumnHeadings(PBIOSMAP pMap, const char *pszSectionNm, uint32_t cColumns, ...)
+{
+    if (   mapIsEmptyLine(pMap)
+        && !mapSkipEmptyLines(pMap))
+        return false;
+
+    /* +------------+ */
+    size_t cch;
+    char  *psz = mapStripCurrentLine(pMap, &cch);
+    if (!psz)
+        return false;
+
+    if (   psz[0] != '+'
+        || psz[1] != '-'
+        || psz[2] != '-'
+        || psz[3] != '-'
+        || psz[cch - 4] != '-'
+        || psz[cch - 3] != '-'
+        || psz[cch - 2] != '-'
+        || psz[cch - 1] != '+'
+       )
+    {
+        RTMsgError("%s:%d: Expected section box: +-----...", pMap->pszMapFile, pMap->iLine);
+        return false;
+    }
+
+    /* |   pszSectionNm   | */
+    psz = mapReadLineStrip(pMap, &cch);
+    if (!psz)
+        return false;
+
+    size_t cchSectionNm = strlen(pszSectionNm);
+    if (   psz[0] != '|'
+        || psz[1] != ' '
+        || psz[2] != ' '
+        || psz[3] != ' '
+        || psz[cch - 4] != ' '
+        || psz[cch - 3] != ' '
+        || psz[cch - 2] != ' '
+        || psz[cch - 1] != '|'
+        || cch != 1 + 3 + cchSectionNm + 3 + 1
+        || strncmp(&psz[4], pszSectionNm, cchSectionNm)
+        )
+    {
+        RTMsgError("%s:%d: Expected section box: |   %s   |", pMap->pszMapFile, pMap->iLine, pszSectionNm);
+        return false;
+    }
+
+    /* +------------+ */
+    psz = mapReadLineStrip(pMap, &cch);
+    if (!psz)
+        return false;
+    if (   psz[0] != '+'
+        || psz[1] != '-'
+        || psz[2] != '-'
+        || psz[3] != '-'
+        || psz[cch - 4] != '-'
+        || psz[cch - 3] != '-'
+        || psz[cch - 2] != '-'
+        || psz[cch - 1] != '+'
+       )
+    {
+        RTMsgError("%s:%d: Expected section box: +-----...", pMap->pszMapFile, pMap->iLine);
+        return false;
+    }
+
+    /* There may be a few lines describing the table notation now, surrounded by blank lines. */
+    do
+    {
+        psz = mapReadLineStripRight(pMap, &cch);
+        if (!psz)
+            return false;
+    } while (   *psz == '\0'
+             || (   !RT_C_IS_SPACE(psz[0])
+                 && RT_C_IS_SPACE(psz[1])
+                 && psz[2] == '='
+                 && RT_C_IS_SPACE(psz[3]))
+            );
+
+    /* Should have the column heading now. */
+    va_list va;
+    va_start(va, cColumns);
+    for (uint32_t i = 0; i < cColumns; i++)
+    {
+        const char *pszColumn = va_arg(va, const char *);
+        size_t      cchColumn = strlen(pszColumn);
+        if (   strncmp(psz, pszColumn, cchColumn)
+            || (    psz[cchColumn] != '\0'
+                && !RT_C_IS_SPACE(psz[cchColumn])))
+        {
+            va_end(va);
+            RTMsgError("%s:%d: Expected column '%s' found '%s'", pMap->pszMapFile, pMap->iLine, pszColumn, psz);
+            return false;
+        }
+        psz += cchColumn;
+        while (RT_C_IS_SPACE(*psz))
+            psz++;
+    }
+    va_end(va);
+
+    /* The next line is the underlining. */
+    psz = mapReadLineStripRight(pMap, &cch);
+    if (!psz)
+        return false;
+    if (*psz != '=' || psz[cch - 1] != '=')
+    {
+        RTMsgError("%s:%d: Expected column header underlining", pMap->pszMapFile, pMap->iLine);
+        return false;
+    }
+
+    /* Skip one blank line. */
+    psz = mapReadLineStripRight(pMap, &cch);
+    if (!psz)
+        return false;
+    if (*psz)
+    {
+        RTMsgError("%s:%d: Expected blank line beneath the column headers", pMap->pszMapFile, pMap->iLine);
+        return false;
+    }
+
+    return true;
+}
+
+
+/**
+ * Parses a segment list.
+ *
+ * @returns @c true on success, @c false + msg on failure, @c false on eof.
+ * @param   pMap                The map file handle.
+ */
+static bool mapParseSegments(PBIOSMAP pMap)
+{
+    for (;;)
+    {
+        if (!mapReadLineStripRight(pMap, NULL))
+            return false;
+
+        /* The end? The line should be empty. Expectes segment name to not
+           start with a space. */
+        if (!pMap->szLine[0] || RT_C_IS_SPACE(pMap->szLine[0]))
+        {
+            if (!pMap->szLine[0])
+                return true;
+            RTMsgError("%s:%u: Malformed segment line", pMap->pszMapFile, pMap->iLine);
+            return false;
+        }
+
+        /* Parse the segment line. */
+        uint32_t iSeg = g_cSegs;
+        if (iSeg >= RT_ELEMENTS(g_aSegs))
+        {
+            RTMsgError("%s:%u: Too many segments", pMap->pszMapFile, pMap->iLine);
+            return false;
+        }
+
+        char *psz = pMap->szLine;
+        if (!mapParseWord(&psz, g_aSegs[iSeg].szName, sizeof(g_aSegs[iSeg].szName)))
+            RTMsgError("%s:%u: Segment name parser error", pMap->pszMapFile, pMap->iLine);
+        else if (!mapParseWord(&psz, g_aSegs[iSeg].szClass, sizeof(g_aSegs[iSeg].szClass)))
+            RTMsgError("%s:%u: Segment class parser error", pMap->pszMapFile, pMap->iLine);
+        else if (!mapParseWord(&psz, g_aSegs[iSeg].szGroup, sizeof(g_aSegs[iSeg].szGroup)))
+            RTMsgError("%s:%u: Segment group parser error", pMap->pszMapFile, pMap->iLine);
+        else if (!mapParseAddress(&psz, &g_aSegs[iSeg].Address))
+            RTMsgError("%s:%u: Segment address parser error", pMap->pszMapFile, pMap->iLine);
+        else if (!mapParseSize(&psz, &g_aSegs[iSeg].cb))
+            RTMsgError("%s:%u: Segment size parser error", pMap->pszMapFile, pMap->iLine);
+        else
+        {
+            g_aSegs[iSeg].uFlatAddr = ((uint32_t)g_aSegs[iSeg].Address.sel << 4) + g_aSegs[iSeg].Address.off;
+            g_cSegs++;
+            if (g_cVerbose > 2)
+                RTStrmPrintf(g_pStdErr, "read segment at %08x / %04x:%04x LB %04x %s / %s / %s\n",
+                             g_aSegs[iSeg].uFlatAddr,
+                             g_aSegs[iSeg].Address.sel,
+                             g_aSegs[iSeg].Address.off,
+                             g_aSegs[iSeg].cb,
+                             g_aSegs[iSeg].szName,
+                             g_aSegs[iSeg].szClass,
+                             g_aSegs[iSeg].szGroup);
+
+            while (RT_C_IS_SPACE(*psz))
+                psz++;
+            if (!*psz)
+                continue;
+            RTMsgError("%s:%u: Junk at end of line", pMap->pszMapFile, pMap->iLine);
+        }
+        return false;
+    }
+}
+
+
+/**
+ * Sorts the segment array by flat address and adds them to the debug module.
+ *
+ * @returns @c true on success, @c false + msg on failure, @c false on eof.
+ */
+static bool mapSortAndAddSegments(void)
+{
+    for (uint32_t i = 0; i < g_cSegs; i++)
+    {
+        for (uint32_t j = i + 1; j < g_cSegs; j++)
+            if (g_aSegs[j].uFlatAddr < g_aSegs[i].uFlatAddr)
+            {
+                BIOSSEG Tmp = g_aSegs[i];
+                g_aSegs[i] = g_aSegs[j];
+                g_aSegs[j] = Tmp;
+            }
+        g_aSegs[i].uRva = g_aSegs[i].uFlatAddr - g_aSegs[0].uFlatAddr;
+
+        if (g_cVerbose > 0)
+            RTStrmPrintf(g_pStdErr, "segment at %08x / %04x / %04x:%04x LB %04x %s / %s / %s\n",
+                         g_aSegs[i].uFlatAddr,
+                         g_aSegs[i].uRva,
+                         g_aSegs[i].Address.sel,
+                         g_aSegs[i].Address.off,
+                         g_aSegs[i].cb,
+                         g_aSegs[i].szName,
+                         g_aSegs[i].szClass,
+                         g_aSegs[i].szGroup);
+
+        RTDBGSEGIDX idx = i;
+        int rc = RTDbgModSegmentAdd(g_hMapMod, g_aSegs[i].uFlatAddr, g_aSegs[i].cb, g_aSegs[i].szName, 0 /*fFlags*/, &idx);
+        if (RT_FAILURE(rc))
+        {
+            RTMsgError("RTDbgModSegmentAdd failed on %s: %Rrc", g_aSegs[i].szName);
+            return false;
+        }
+    }
+    return true;
+}
+
+
+/**
+ * Parses a segment list.
+ *
+ * @returns @c true on success, @c false + msg on failure, @c false on eof.
+ * @param   pMap                The map file handle.
+ */
+static bool mapParseSymbols(PBIOSMAP pMap)
+{
+    for (;;)
+    {
+        if (!mapReadLineStripRight(pMap, NULL))
+            return false;
+
+        /* The end? The line should be empty. Expectes segment name to not
+           start with a space. */
+        if (!pMap->szLine[0] || RT_C_IS_SPACE(pMap->szLine[0]))
+        {
+            if (!pMap->szLine[0])
+                return true;
+            return mapError(pMap, "Malformed symbol line");
+        }
+
+        if (!strncmp(pMap->szLine, RT_STR_TUPLE("Module: ")))
+        {
+            /* Parse the module line. */
+            size_t offObj = sizeof("Module: ") - 1;
+            while (RT_C_IS_SPACE(pMap->szLine[offObj]))
+                offObj++;
+            size_t offSrc = offObj;
+            char ch;
+            while ((ch = pMap->szLine[offSrc]) != '(' && ch != '\0')
+                offSrc++;
+            size_t cchObj = offSrc - offObj;
+
+            offSrc++;
+            size_t cchSrc = offSrc;
+            while ((ch = pMap->szLine[cchSrc]) != ')' && ch != '\0')
+                cchSrc++;
+            cchSrc -= offSrc;
+            if (ch != ')')
+                return mapError(pMap, "Symbol/Module line parse error");
+
+            PBIOSOBJFILE pObjFile = (PBIOSOBJFILE)RTMemAllocZ(sizeof(*pObjFile) + cchSrc + cchObj + 2);
+            if (!pObjFile)
+                return mapError(pMap, "Out of memory");
+            char *psz = (char *)(pObjFile + 1);
+            pObjFile->pszObject = psz;
+            memcpy(psz, &pMap->szLine[offObj], cchObj);
+            psz += cchObj;
+            *psz++ = '\0';
+            pObjFile->pszSource = psz;
+            memcpy(psz, &pMap->szLine[offSrc], cchSrc);
+            psz[cchSrc] = '\0';
+            RTListAppend(&g_ObjList, &pObjFile->Node);
+        }
+        else
+        {
+            /* Parse the segment line. */
+            RTFAR16     Addr;
+            char       *psz = pMap->szLine;
+            if (!mapParseAddress(&psz, &Addr))
+                return mapError(pMap, "Symbol address parser error");
+
+            char        szName[4096];
+            if (!mapParseWord(&psz, szName, sizeof(szName)))
+                return mapError(pMap, "Symbol name parser error");
+
+            uint32_t    uFlatAddr = ((uint32_t)Addr.sel << 4) + Addr.off;
+            if (uFlatAddr != 0)
+            {
+                int rc = RTDbgModSymbolAdd(g_hMapMod, szName, RTDBGSEGIDX_RVA, uFlatAddr, 0 /*cb*/,  0 /*fFlags*/, NULL);
+                if (RT_FAILURE(rc) && rc != VERR_DBG_ADDRESS_CONFLICT)
+                {
+                    /* HACK ALERT! For dealing with lables at segment size. */ /** @todo fix end labels. */
+                    rc = RTDbgModSymbolAdd(g_hMapMod, szName, RTDBGSEGIDX_RVA, uFlatAddr - 1, 0 /*cb*/,  0 /*fFlags*/, NULL);
+                    if (RT_FAILURE(rc) && rc != VERR_DBG_ADDRESS_CONFLICT)
+                        return mapError(pMap, "RTDbgModSymbolAdd failed: %Rrc", rc);
+                }
+
+                if (g_cVerbose > 2)
+                    RTStrmPrintf(g_pStdErr, "read symbol - %08x %s\n", uFlatAddr, szName);
+                while (RT_C_IS_SPACE(*psz))
+                    psz++;
+                if (*psz)
+                    return mapError(pMap, "Junk at end of line");
+            }
+
+        }
+    }
+}
+
+
+/**
+ * Parses the given map file.
+ *
+ * @returns RTEXITCODE_SUCCESS and lots of globals, or RTEXITCODE_FAILURE and a
+ *          error message.
+ * @param   pMap                The map file handle.
+ */
+static RTEXITCODE mapParseFile(PBIOSMAP pMap)
+{
+    int rc = RTDbgModCreate(&g_hMapMod, "VBoxBios", 0 /*cbSeg*/, 0 /*fFlags*/);
+    if (RT_FAILURE(rc))
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTDbgModCreate failed: %Rrc", rc);
+
+    /*
+     * Read the header.
+     */
+    if (!mapReadLine(pMap))
+        return RTEXITCODE_FAILURE;
+    if (strncmp(pMap->szLine, RT_STR_TUPLE("Open Watcom Linker Version")))
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "Unexpected map-file header: '%s'", pMap->szLine);
+    if (   !mapSkipNonEmptyLines(pMap)
+        || !mapSkipEmptyLines(pMap))
+        return RTEXITCODE_FAILURE;
+
+    /*
+     * Skip groups.
+     */
+    if (!mapSkipThruColumnHeadings(pMap, "Groups", 3, "Group", "Address", "Size", NULL))
+        return RTEXITCODE_FAILURE;
+    if (!mapSkipNonEmptyLines(pMap))
+        return RTEXITCODE_FAILURE;
+
+    /*
+     * Parse segments.
+     */
+    if (!mapSkipThruColumnHeadings(pMap, "Segments", 5, "Segment", "Class", "Group", "Address", "Size"))
+        return RTEXITCODE_FAILURE;
+    if (!mapParseSegments(pMap))
+        return RTEXITCODE_FAILURE;
+    if (!mapSortAndAddSegments())
+        return RTEXITCODE_FAILURE;
+
+    /*
+     * Parse symbols.
+     */
+    if (!mapSkipThruColumnHeadings(pMap, "Memory Map", 2, "Address", "Symbol"))
+        return RTEXITCODE_FAILURE;
+    if (!mapParseSymbols(pMap))
+        return RTEXITCODE_FAILURE;
+
+    /* Ignore the rest of the file. */
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * Parses the linker map file for the BIOS.
+ *
+ * This is generated by the Watcom linker.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pszBiosMap          Path to the map file.
+ */
+static RTEXITCODE ParseMapFile(const char *pszBiosMap)
+{
+    BIOSMAP Map;
+    Map.pszMapFile = pszBiosMap;
+    Map.hStrm      = NULL;
+    Map.iLine      = 0;
+    Map.fEof       = false;
+    Map.cch        = 0;
+    Map.offNW      = 0;
+    int rc = RTStrmOpen(pszBiosMap, "r", &Map.hStrm);
+    if (RT_FAILURE(rc))
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "Error opening '%s': %Rrc", pszBiosMap, rc);
+    RTEXITCODE rcExit = mapParseFile(&Map);
+    RTStrmClose(Map.hStrm);
+    return rcExit;
+}
+
+
+/**
+ * Reads the BIOS image into memory (g_pbImg and g_cbImg).
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pszBiosImg          Path to the image file.
+ */
+static RTEXITCODE ReadBiosImage(const char *pszBiosImg)
+{
+    void  *pvImg;
+    size_t cbImg;
+    int rc = RTFileReadAll(pszBiosImg, &pvImg, &cbImg);
+    if (RT_FAILURE(rc))
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "Error reading '%s': %Rrc", pszBiosImg, rc);
+
+    size_t cbImgExpect;
+    switch (g_enmBiosType)
+    {
+        case kBiosType_System:  cbImgExpect = _64K; break;
+        case kBiosType_Vga:     cbImgExpect = _32K; break;
+        default:                cbImgExpect = 0; break;
+    }
+    if (cbImg != cbImgExpect)
+    {
+        RTFileReadAllFree(pvImg, cbImg);
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "The BIOS image %u bytes intead of %u bytes", cbImg, cbImgExpect);
+    }
+
+    g_pbImg = (uint8_t *)pvImg;
+    g_cbImg = cbImg;
+    return RTEXITCODE_SUCCESS;
+}
+
+
+int main(int argc, char **argv)
+{
+    int rc = RTR3InitExe(argc, &argv, 0);
+    if (RT_FAILURE(rc))
+        return RTMsgInitFailure(rc);
+
+    RTListInit(&g_ObjList);
+
+    /*
+     * Option config.
+     */
+    static RTGETOPTDEF const s_aOpts[] =
+    {
+        { "--bios-image",               'i',                    RTGETOPT_REQ_STRING },
+        { "--bios-map",                 'm',                    RTGETOPT_REQ_STRING },
+        { "--bios-sym",                 's',                    RTGETOPT_REQ_STRING },
+        { "--bios-type",                't',                    RTGETOPT_REQ_STRING },
+        { "--output",                   'o',                    RTGETOPT_REQ_STRING },
+        { "--verbose",                  'v',                    RTGETOPT_REQ_NOTHING },
+        { "--quiet",                    'q',                    RTGETOPT_REQ_NOTHING },
+    };
+
+    const char *pszBiosMap = NULL;
+    const char *pszBiosSym = NULL;
+    const char *pszBiosImg = NULL;
+    const char *pszOutput  = NULL;
+
+    RTGETOPTUNION   ValueUnion;
+    RTGETOPTSTATE   GetOptState;
+    rc = RTGetOptInit(&GetOptState, argc, argv, &s_aOpts[0], RT_ELEMENTS(s_aOpts), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
+    AssertReleaseRCReturn(rc, RTEXITCODE_FAILURE);
+
+    /*
+     * Process the options.
+     */
+    while ((rc = RTGetOpt(&GetOptState, &ValueUnion)) != 0)
+    {
+        switch (rc)
+        {
+            case 'i':
+                if (pszBiosImg)
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "--bios-image is given more than once");
+                pszBiosImg = ValueUnion.psz;
+                break;
+
+            case 'm':
+                if (pszBiosMap)
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "--bios-map is given more than once");
+                pszBiosMap = ValueUnion.psz;
+                break;
+
+            case 's':
+                if (pszBiosSym)
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "--bios-sym is given more than once");
+                pszBiosSym = ValueUnion.psz;
+                break;
+
+            case 'o':
+                if (pszOutput)
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "--output is given more than once");
+                pszOutput = ValueUnion.psz;
+                break;
+
+            case 't':
+                if (!strcmp(ValueUnion.psz, "system"))
+                {
+                    g_enmBiosType = kBiosType_System;
+                    g_uBiosFlatBase = 0xf0000;
+                }
+                else if (!strcmp(ValueUnion.psz, "vga"))
+                {
+                    g_enmBiosType = kBiosType_Vga;
+                    g_uBiosFlatBase = 0xc0000;
+                }
+                else
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Unknown bios type '%s'", ValueUnion.psz);
+                break;
+
+            case 'v':
+                g_cVerbose++;
+                break;
+
+            case 'q':
+                g_cVerbose = 0;
+                break;
+
+            case 'H':
+                RTPrintf("usage: %Rbn --bios-image <file.img> --bios-map <file.map> [--output <file.asm>]\n",
+                         argv[0]);
+                return RTEXITCODE_SUCCESS;
+
+            case 'V':
+            {
+                /* The following is assuming that svn does it's job here. */
+                char szRev[] = "$Revision: 155244 $";
+                char *psz = szRev;
+                while (*psz && !RT_C_IS_DIGIT(*psz))
+                    psz++;
+                size_t i = strlen(psz);
+                while (i > 0 && !RT_C_IS_DIGIT(psz[i - 1]))
+                    psz[--i] = '\0';
+
+                RTPrintf("r%s\n", psz);
+                return RTEXITCODE_SUCCESS;
+            }
+
+            default:
+                return RTGetOptPrintError(rc, &ValueUnion);
+        }
+    }
+
+    /*
+     * Got it all?
+     */
+    if (!pszBiosImg)
+        return RTMsgErrorExit(RTEXITCODE_SYNTAX, "--bios-image is required");
+    if (!pszBiosMap)
+        return RTMsgErrorExit(RTEXITCODE_SYNTAX, "--bios-map is required");
+    if (!pszBiosSym)
+        return RTMsgErrorExit(RTEXITCODE_SYNTAX, "--bios-sym is required");
+
+    /*
+     * Do the job.
+     */
+    RTEXITCODE rcExit;
+    rcExit = ReadBiosImage(pszBiosImg);
+    if (rcExit == RTEXITCODE_SUCCESS)
+        rcExit = ParseMapFile(pszBiosMap);
+    if (rcExit == RTEXITCODE_SUCCESS)
+        rcExit = ParseSymFile(pszBiosSym);
+    if (rcExit == RTEXITCODE_SUCCESS)
+        rcExit = OpenOutputFile(pszOutput);
+    if (rcExit == RTEXITCODE_SUCCESS)
+        rcExit = DisassembleBiosImage();
+
+    return rcExit;
+}
+
diff --git a/src/VBox/Devices/BiosCommonCode/Makefile.kmk b/src/VBox/Devices/BiosCommonCode/Makefile.kmk
new file mode 100644
index 00000000..d3dfa5c6
--- /dev/null
+++ b/src/VBox/Devices/BiosCommonCode/Makefile.kmk
@@ -0,0 +1,43 @@
+# $Id: Makefile.kmk $
+## @file
+# Sub-Makefile for the New BIOS ROM.
+#
+
+#
+# Copyright (C) 2012-2023 Oracle and/or its affiliates.
+#
+# This file is part of VirtualBox base platform packages, as
+# available from https://www.virtualbox.org.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation, in version 3 of the
+# License.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see <https://www.gnu.org/licenses>.
+#
+# SPDX-License-Identifier: GPL-3.0-only
+#
+
+SUB_DEPTH = ../../../..
+include $(KBUILD_PATH)/subheader.kmk
+
+#
+# MakeAlternative - For distros without OpenWatcom.
+#
+BLDPROGS += MakeAlternativeSource
+MakeAlternativeSource_TEMPLATE = VBoxAdvBldProg
+MakeAlternativeSource_DEFS     = IN_DIS
+MakeAlternativeSource_SOURCES  = MakeAlternativeSource.cpp
+MakeAlternativeSource_LIBS     = \
+	$(PATH_STAGE_LIB)/DisasmBldProg$(VBOX_HOSTSUFF_LIB)
+
+
+include $(FILE_KBUILD_SUB_FOOTER)
+
diff --git a/src/VBox/Devices/BiosCommonCode/__I4D.asm b/src/VBox/Devices/BiosCommonCode/__I4D.asm
new file mode 100644
index 00000000..8a0e2278
--- /dev/null
+++ b/src/VBox/Devices/BiosCommonCode/__I4D.asm
@@ -0,0 +1,98 @@
+; $Id: __I4D.asm $
+;; @file
+; Compiler support routines.
+;
+
+;
+; Copyright (C) 2012-2023 Oracle and/or its affiliates.
+;
+; This file is part of VirtualBox base platform packages, as
+; available from https://www.virtualbox.org.
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; as published by the Free Software Foundation, in version 3 of the
+; License.
+;
+; This program is distributed in the hope that it will be useful, but
+; WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+; General Public License for more details.
+;
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, see <https://www.gnu.org/licenses>.
+;
+; SPDX-License-Identifier: GPL-3.0-only
+;
+
+
+;*******************************************************************************
+;*  Exported Symbols                                                           *
+;*******************************************************************************
+public          __I4D
+
+if VBOX_BIOS_CPU lt 80386
+extrn NeedToImplementOn8086__I4D:near
+endif
+
+; MASM (ML.EXE) is used for PXE and no longer understands the .8086 directive.
+; WASM is used for the BIOS and understands it just fine.
+ifdef __WASM__
+                .8086
+endif
+
+
+_TEXT           segment public 'CODE' use16
+                assume cs:_TEXT
+
+;;
+; 32-bit signed division.
+;
+; @param    dx:ax   Dividend.
+; @param    cx:bx   Divisor.
+; @returns  dx:ax   Quotient.
+;           cx:bx   Remainder.
+;
+__I4D:
+                pushf
+if VBOX_BIOS_CPU ge 80386
+                .386
+                push    eax
+                push    edx
+                push    ecx
+
+                rol     eax, 16
+                mov     ax, dx
+                ror     eax, 16
+                xor     edx, edx
+
+                shr     ecx, 16
+                mov     cx, bx
+
+                idiv    ecx                 ; eax:edx / ecx -> eax=quotient, edx=remainder.
+
+                mov     bx, dx
+                pop     ecx
+                shr     edx, 16
+                mov     cx, dx
+
+                pop     edx
+                ror     eax, 16
+                mov     dx, ax
+                add     sp, 2
+                pop     ax
+                rol     eax, 16
+ifdef __WASM__
+                .8086
+endif
+
+else
+                call    NeedToImplementOn8086__I4D
+endif
+                popf
+                ret
+
+
+_TEXT           ends
+                end
+
diff --git a/src/VBox/Devices/BiosCommonCode/__I4M.asm b/src/VBox/Devices/BiosCommonCode/__I4M.asm
new file mode 100644
index 00000000..9c2f58d1
--- /dev/null
+++ b/src/VBox/Devices/BiosCommonCode/__I4M.asm
@@ -0,0 +1,97 @@
+; $Id: __I4M.asm $
+;; @file
+; Compiler support routines.
+;
+
+;
+; Copyright (C) 2012-2023 Oracle and/or its affiliates.
+;
+; This file is part of VirtualBox base platform packages, as
+; available from https://www.virtualbox.org.
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; as published by the Free Software Foundation, in version 3 of the
+; License.
+;
+; This program is distributed in the hope that it will be useful, but
+; WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+; General Public License for more details.
+;
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, see <https://www.gnu.org/licenses>.
+;
+; SPDX-License-Identifier: GPL-3.0-only
+;
+
+
+;*******************************************************************************
+;*  Exported Symbols                                                           *
+;*******************************************************************************
+public          __I4M
+
+if VBOX_BIOS_CPU lt 80386
+extrn NeedToImplementOn8086__I4M:near
+endif
+
+; MASM (ML.EXE) is used for PXE and no longer understands the .8086 directive.
+; WASM is used for the BIOS and understands it just fine.
+ifdef __WASM__
+                .8086
+endif
+
+_TEXT           segment public 'CODE' use16
+                assume cs:_TEXT
+
+;;
+; 32-bit signed multiplication.
+;
+; @param    dx:ax   Factor 1.
+; @param    cx:bx   Factor 2.
+; @returns  dx:ax   Result.
+; cx, es may be modified; di is preserved
+;
+__I4M:
+                pushf
+if VBOX_BIOS_CPU ge 80386
+                .386
+                push    eax
+                push    edx
+                push    ecx
+                push    ebx
+
+                rol     eax, 16
+                mov     ax, dx
+                ror     eax, 16
+                xor     edx, edx
+
+                shr     ecx, 16
+                mov     cx, bx
+
+                imul    ecx                 ; eax * ecx -> edx:eax
+
+                pop     ebx
+                pop     ecx
+
+                pop     edx
+                ror     eax, 16
+                mov     dx, ax
+                add     sp, 2
+                pop     ax
+                rol     eax, 16
+ifdef __WASM__
+                .8086
+endif
+
+else
+                call    NeedToImplementOn8086__I4M
+endif
+
+                popf
+                ret
+
+
+_TEXT           ends
+                end
+
diff --git a/src/VBox/Devices/BiosCommonCode/__U4D.asm b/src/VBox/Devices/BiosCommonCode/__U4D.asm
new file mode 100644
index 00000000..7d8bee47
--- /dev/null
+++ b/src/VBox/Devices/BiosCommonCode/__U4D.asm
@@ -0,0 +1,151 @@
+; $Id: __U4D.asm $
+;; @file
+; Compiler support routines.
+;
+
+;
+; Copyright (C) 2012-2023 Oracle and/or its affiliates.
+;
+; This file is part of VirtualBox base platform packages, as
+; available from https://www.virtualbox.org.
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; as published by the Free Software Foundation, in version 3 of the
+; License.
+;
+; This program is distributed in the hope that it will be useful, but
+; WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+; General Public License for more details.
+;
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, see <https://www.gnu.org/licenses>.
+;
+; SPDX-License-Identifier: GPL-3.0-only
+;
+
+
+;*******************************************************************************
+;*  Exported Symbols                                                           *
+;*******************************************************************************
+public          __U4D
+
+; MASM (ML.EXE) is used for PXE and no longer understands the .8086 directive.
+; WASM is used for the BIOS and understands it just fine.
+ifdef __WASM__
+                .8086
+endif
+
+
+if VBOX_BIOS_CPU lt 80386
+extrn _DoUInt32Div:near
+endif
+
+
+_TEXT           segment public 'CODE' use16
+                assume cs:_TEXT
+
+
+;;
+; 32-bit unsigned division.
+;
+; @param    dx:ax   Dividend.
+; @param    cx:bx   Divisor.
+; @returns  dx:ax   Quotient.
+;           cx:bx   Remainder.
+;
+__U4D:
+                pushf
+if VBOX_BIOS_CPU ge 80386
+                .386
+                push    eax
+                push    edx
+                push    ecx
+
+                rol     eax, 16
+                mov     ax, dx
+                ror     eax, 16
+                xor     edx, edx
+
+                shr     ecx, 16
+                mov     cx, bx
+
+                div     ecx                 ; eax:edx / ecx -> eax=quotient, edx=remainder.
+
+                mov     bx, dx
+                pop     ecx
+                shr     edx, 16
+                mov     cx, dx
+
+                pop     edx
+                ror     eax, 16
+                mov     dx, ax
+                add     sp, 2
+                pop     ax
+                rol     eax, 16
+ifdef __WASM__
+                .8086
+endif
+else
+                ;
+                ; If the divisor is only 16-bit, use a fast path
+                ;
+                test    cx, cx
+                jnz     do_it_the_hard_way
+
+                div     bx              ; dx:ax / bx -> ax=quotient, dx=remainder
+
+                mov     bx, dx          ; remainder in cx:bx, and we know cx=0
+
+                xor     dx, dx          ; quotient in dx:ax, dx must be zero
+
+                popf
+                ret
+
+do_it_the_hard_way:
+                ; Call C function do this.
+                push    ds
+                push    es
+
+                ;
+                ; Convert to a C __cdecl call - not doing this in assembly.
+                ;
+
+                ; Set up a frame of sorts, allocating 4 bytes for the result buffer.
+                push    bp
+                sub     sp, 04h
+                mov     bp, sp
+
+                ; Pointer to the return buffer.
+                push    ss
+                push    bp
+                add     bp, 04h                 ; Correct bp.
+
+                ; The divisor.
+                push    cx
+                push    bx
+
+                ; The dividend.
+                push    dx
+                push    ax
+
+                call    _DoUInt32Div
+
+                ; Load the remainder.
+                mov     cx, [bp - 02h]
+                mov     bx, [bp - 04h]
+
+                ; The quotient is already in dx:ax
+
+                mov     sp, bp
+                pop     bp
+                pop     es
+                pop     ds
+endif
+                popf
+                ret
+
+_TEXT           ends
+                end
+
diff --git a/src/VBox/Devices/BiosCommonCode/__U4M.asm b/src/VBox/Devices/BiosCommonCode/__U4M.asm
new file mode 100644
index 00000000..e3c4c2c4
--- /dev/null
+++ b/src/VBox/Devices/BiosCommonCode/__U4M.asm
@@ -0,0 +1,125 @@
+; $Id: __U4M.asm $
+;; @file
+; Compiler support routines.
+;
+
+;
+; Copyright (C) 2012-2023 Oracle and/or its affiliates.
+;
+; This file is part of VirtualBox base platform packages, as
+; available from https://www.virtualbox.org.
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; as published by the Free Software Foundation, in version 3 of the
+; License.
+;
+; This program is distributed in the hope that it will be useful, but
+; WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+; General Public License for more details.
+;
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, see <https://www.gnu.org/licenses>.
+;
+; SPDX-License-Identifier: GPL-3.0-only
+;
+
+
+;*******************************************************************************
+;*  Exported Symbols                                                           *
+;*******************************************************************************
+public          __U4M
+
+; MASM (ML.EXE) is used for PXE and no longer understands the .8086 directive.
+; WASM is used for the BIOS and understands it just fine.
+ifdef __WASM__
+                .8086
+endif
+
+_TEXT           segment public 'CODE' use16
+                assume cs:_TEXT
+
+;;
+; 32-bit unsigned multiplication.
+;
+; @param    dx:ax   Factor 1.
+; @param    cx:bx   Factor 2.
+; @returns  dx:ax   Result.
+;
+__U4M:
+                pushf
+if VBOX_BIOS_CPU ge 80386
+                .386
+                push    eax
+                push    edx
+                push    ecx
+
+                rol     eax, 16
+                mov     ax, dx
+                ror     eax, 16
+                xor     edx, edx
+
+                shr     ecx, 16
+                mov     cx, bx
+
+                mul     ecx                 ; eax * ecx -> edx:eax
+
+                pop     ecx
+
+                pop     edx
+                ror     eax, 16
+                mov     dx, ax
+                add     sp, 2
+                pop     ax
+                rol     eax, 16
+ifdef __WASM__
+                .8086
+endif
+
+else
+                push    si              ; high result
+                push    di              ; low result
+
+                ;
+                ;        dx:ax * cx:bx =
+                ;-----------------------
+                ;        ax*bx
+                ; +   dx*bx             ; only lower 16 bits relevant.
+                ; +   ax*cx             ; ditto
+                ; +dx*cx                ; not relevant
+                ; -------------
+                ; =      dx:ax
+                ;
+
+                push    ax              ; stash the low factor 1 part for the 3rd multiplication.
+                mov     di, dx          ; stash the high factor 1 part for the 2nd multiplication.
+
+                ; multiply the two low factor "digits": ax * bx
+                mul     bx
+                mov     si, dx
+                xchg    di, ax          ; save low result and loads high factor 1 into ax for the next step
+
+                ; Multiply the low right "digit" by the high left one and add it to the high result part
+                mul     bx
+                add     si, ax
+
+                ; Multiply the high right "digit" by the low left on and add it ot the high result part.
+                pop     ax
+                mul     cx
+                add     si, ax
+
+                ; Load the result.
+                mov     dx, si
+                mov     ax, di
+
+                pop     di
+                pop     si
+endif
+                popf
+                ret
+
+
+_TEXT           ends
+                end
+
diff --git a/src/VBox/Devices/BiosCommonCode/__U8LS.asm b/src/VBox/Devices/BiosCommonCode/__U8LS.asm
new file mode 100644
index 00000000..85e8024e
--- /dev/null
+++ b/src/VBox/Devices/BiosCommonCode/__U8LS.asm
@@ -0,0 +1,65 @@
+; $Id: __U8LS.asm $
+;; @file
+; Compiler support routines.
+;
+
+;
+; Copyright (C) 2012-2023 Oracle and/or its affiliates.
+;
+; This file is part of VirtualBox base platform packages, as
+; available from https://www.virtualbox.org.
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; as published by the Free Software Foundation, in version 3 of the
+; License.
+;
+; This program is distributed in the hope that it will be useful, but
+; WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+; General Public License for more details.
+;
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, see <https://www.gnu.org/licenses>.
+;
+; SPDX-License-Identifier: GPL-3.0-only
+;
+
+
+;*******************************************************************************
+;*  Exported Symbols                                                           *
+;*******************************************************************************
+public          __U8LS
+
+
+                .8086
+
+_TEXT           segment public 'CODE' use16
+                assume cs:_TEXT
+
+;;
+; 64-bit left shift.
+;
+; @param    ax:bx:cx:dx Value. (AX is the most significant, DX the least)
+; @param    si          Shift count.
+; @returns  ax:bx:cx:dx Shifted value.
+; si is zeroed
+;
+__U8LS:
+
+                test    si, si
+                jz      u8ls_quit
+u8ls_rot:
+                shl     dx, 1
+                rcl     cx, 1
+                rcl     bx, 1
+                rcl     ax, 1
+                dec     si
+                jnz     u8ls_rot
+u8ls_quit:
+                ret
+
+
+_TEXT           ends
+                end
+
diff --git a/src/VBox/Devices/BiosCommonCode/__U8RS.asm b/src/VBox/Devices/BiosCommonCode/__U8RS.asm
new file mode 100644
index 00000000..9e126d21
--- /dev/null
+++ b/src/VBox/Devices/BiosCommonCode/__U8RS.asm
@@ -0,0 +1,64 @@
+; $Id: __U8RS.asm $
+;; @file
+; Compiler support routines.
+;
+
+;
+; Copyright (C) 2012-2023 Oracle and/or its affiliates.
+;
+; This file is part of VirtualBox base platform packages, as
+; available from https://www.virtualbox.org.
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; as published by the Free Software Foundation, in version 3 of the
+; License.
+;
+; This program is distributed in the hope that it will be useful, but
+; WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+; General Public License for more details.
+;
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, see <https://www.gnu.org/licenses>.
+;
+; SPDX-License-Identifier: GPL-3.0-only
+;
+
+
+;*******************************************************************************
+;*  Exported Symbols                                                           *
+;*******************************************************************************
+public          __U8RS
+
+
+                .8086
+
+_TEXT           segment public 'CODE' use16
+                assume cs:_TEXT
+
+;;
+; 64-bit unsigned right shift.
+;
+; @param    ax:bx:cx:dx Value. (AX is the most significant, DX the least)
+; @param    si          Shift count.
+; @returns  ax:bx:cx:dx Shifted value.
+; si is zeroed
+;
+__U8RS:
+
+                test    si, si
+                jz      u8rs_quit
+u8rs_rot:
+                shr     ax, 1
+                rcr     bx, 1
+                rcr     cx, 1
+                rcr     dx, 1
+                dec     si
+                jnz     u8rs_rot
+u8rs_quit:
+                ret
+
+_TEXT           ends
+                end
+
diff --git a/src/VBox/Devices/BiosCommonCode/biosorg_check.sed b/src/VBox/Devices/BiosCommonCode/biosorg_check.sed
new file mode 100644
index 00000000..5aa3f923
--- /dev/null
+++ b/src/VBox/Devices/BiosCommonCode/biosorg_check.sed
@@ -0,0 +1,199 @@
+# $Id: biosorg_check.sed $
+## @file
+# For converting biosorg_check_<addr> lines in a wlink mapfile
+# to kmk_expr checks.
+#
+
+#
+# Copyright (C) 2012-2023 Oracle and/or its affiliates.
+#
+# This file is part of VirtualBox base platform packages, as
+# available from https://www.virtualbox.org.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation, in version 3 of the
+# License.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see <https://www.gnu.org/licenses>.
+#
+# SPDX-License-Identifier: GPL-3.0-only
+#
+
+
+/biosorg_check_at_/b check_at
+/biosorg_check_before_or_at_/b check_before_or_at
+b end
+
+:check_at
+#p # --debug
+s/\(.*\)/\L\1/g
+s/....:\(....\). *biosorg_check_at_0\(\1\)h *//
+/^$/b end
+q 1
+b end
+
+# after or equal.
+:check_before_or_at
+#p # --debug
+s/\(.*\)/\L\1/g
+
+h
+s/^....:\(....\). *biosorg_check_before_or_at_0\(....\)h */\2/
+x
+s/^....:\(....\)/\1 /
+
+
+# Loop for comparing the two addresses.  The one in the pattern buffer (left) must be
+# smaller or equal to the one in in the pattern buffer (BIOSORG address).
+:compare_loop
+/^f/b match_f_or_greater
+/^e/b match_e_or_greater
+/^d/b match_d_or_greater
+/^c/b match_c_or_greater
+/^b/b match_b_or_greater
+/^a/b match_a_or_greater
+/^9/b match_9_or_greater
+/^8/b match_8_or_greater
+/^7/b match_7_or_greater
+/^6/b match_6_or_greater
+/^5/b match_5_or_greater
+/^4/b match_4_or_greater
+/^3/b match_3_or_greater
+/^2/b match_2_or_greater
+/^1/b match_1_or_greater
+/^0/b match_0_or_greater
+:bad
+p
+x
+p
+q 1
+b end
+
+:bad_other
+x
+b bad
+
+
+:match_f_or_greater
+x
+/^f/b next_compare
+b bad_other
+
+:match_e_or_greater
+x
+/^f/b end
+/^e/b next_compare
+b bad_other
+
+:match_d_or_greater
+x
+/^[e-f]/b end
+/^d/b next_compare
+b bad_other
+
+:match_c_or_greater
+x
+/^[d-f]/b end
+/^c/b next_compare
+b bad_other
+
+:match_b_or_greater
+x
+/^[c-f]/b end
+/^b/b next_compare
+b bad_other
+
+:match_a_or_greater
+x
+/^[b-f]/b end
+/^a/b next_compare
+b bad_other
+
+:match_9_or_greater
+x
+/^[a-f]/b end
+/^9/b next_compare
+b bad_other
+
+:match_8_or_greater
+x
+/^[9a-f]/b end
+/^8/b next_compare
+b bad_other
+
+:match_7_or_greater
+x
+/^[8-9a-f]/b end
+/^7/b next_compare
+b bad_other
+
+:match_6_or_greater
+x
+/^[7-9a-f]/b end
+/^6/b next_compare
+b bad_other
+
+:match_5_or_greater
+x
+/^[6-9a-f]/b end
+/^5/b next_compare
+b bad_other
+
+:match_4_or_greater
+x
+/^[5-9a-f]/b end
+/^4/b next_compare
+b bad_other
+
+:match_3_or_greater
+x
+/^[4-9a-f]/b end
+/^3/b next_compare
+b bad_other
+
+:match_2_or_greater
+x
+/^[3-9a-f]/b end
+/^2/b next_compare
+b bad_other
+
+:match_1_or_greater
+x
+/^[2-9a-f]/b end
+/^1/b next_compare
+b bad_other
+
+:match_0_or_greater
+x
+/^[1-9a-f]/b end
+/^0/b next_compare
+b bad_other
+
+
+# Next round of the loop.
+# 1. Drop the leading digit of the max address (BIOSORG).
+# 2. Check if we've reached end of the address. If so, check that we've reached the space in the actual address.
+# 3. Switch buffers so the actual address in the pattern space.
+# 4. Drop the leading digit of the actual address.
+# 5. Repeat.
+:next_compare
+s/^.//
+/^$/b end_of_compare
+x
+s/^.//
+b compare_loop
+
+:end_of_compare
+x
+/^. /b end
+b bad
+
+:end
+
diff --git a/src/VBox/Devices/BiosCommonCode/commondefs.inc b/src/VBox/Devices/BiosCommonCode/commondefs.inc
new file mode 100644
index 00000000..dcd9edfd
--- /dev/null
+++ b/src/VBox/Devices/BiosCommonCode/commondefs.inc
@@ -0,0 +1,251 @@
+; $Id: commondefs.inc $
+;; @file
+; Stuff for drawing the BIOS logo.
+;
+
+;
+; Copyright (C) 2004-2023 Oracle and/or its affiliates.
+;
+; This file is part of VirtualBox base platform packages, as
+; available from https://www.virtualbox.org.
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; as published by the Free Software Foundation, in version 3 of the
+; License.
+;
+; This program is distributed in the hope that it will be useful, but
+; WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+; General Public License for more details.
+;
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, see <https://www.gnu.org/licenses>.
+;
+; SPDX-License-Identifier: GPL-3.0-only
+;
+
+
+;; Switches back to default CPU mode.
+SET_DEFAULT_CPU macro
+ if VBOX_BIOS_CPU eq 8086
+        .8086
+ elseif VBOX_BIOS_CPU eq 80186
+        .186
+ elseif VBOX_BIOS_CPU eq 80286
+        .286
+ elseif VBOX_BIOS_CPU eq 80386
+        .386
+ else
+  .errnz 1, Unsupported target CPU value: VBOX_BIOS_CPU
+        .386
+ endif
+endm
+
+
+;; Switches back to default CPU mode, max 286.
+SET_DEFAULT_CPU_286 macro
+ if VBOX_BIOS_CPU eq 8086
+        .8086
+ elseif VBOX_BIOS_CPU eq 80186
+        .186
+ else
+        .286
+ endif
+endm
+
+
+;;
+; Pretends to do a call by pushing the return address and jumping
+; to the function.
+;
+; This is slightly problematic on 8086 since it doesn't support pushing
+; word immediates. OTOH, it support pushing memory, so we'll do that
+; instead when targeting 8086.
+;
+if 0 ;; this crap crashes wasm, makes it call exit(0), or similar weird stuff.
+     ;; switched to a simpler approach where I define the one return address variable myself.
+DO_JMP_CALL     macro calling, returning
+ if VBOX_BIOS_CPU gt 8086
+        push    returning
+        jmp     calling
+ else
+        push    word ptr cs:[%jmp_call_addr_&returning]
+        jmp     calling
+;public jmp_call_addr_&returning
+%jmp_call_addr_&returning: dw offset retaddr
+ endif
+endm
+
+DO_JMP_CALL_AGAIN macro calling, returning
+ if VBOX_BIOS_CPU gt 8086
+        push    returning
+        jmp     calling
+ else
+        push    word ptr cs:[%jmp_call_addr_&returning]
+        jmp     calling
+ endif
+endm
+
+else  ; Simplified.
+DO_JMP_CALL_EX  macro calling, returning, returning_ptr_var
+ if VBOX_BIOS_CPU gt 8086
+        push    returning
+        jmp     calling
+  else
+        push    word ptr cs:[returning_ptr_var]
+        jmp     calling
+  endif
+endm
+
+endif ; Simplified.
+
+
+;; For handling the pusha instruction depending on target CPU.
+DO_pusha        macro
+ if VBOX_BIOS_CPU gt 8086
+        pusha
+ else
+        push    ax
+        push    cx
+        push    dx
+        push    bx
+        push    sp
+        push    bp
+        push    si
+        push    di
+ endif
+endm
+
+
+;; For handling the popad/popa instruction depending on target CPU.
+DO_popa         macro
+ if VBOX_BIOS_CPU gt 8086
+        popa
+ else
+        pop     di
+        pop     si
+        pop     bp
+        pop     bx ;pop sp
+        pop     bx
+        pop     dx
+        pop     cx
+        pop     ax
+ endif
+endm
+
+
+;; For handling the pushad/pusha instruction depending on target CPU.
+DO_PUSHAD       macro
+ if VBOX_BIOS_CPU ge 80386
+        pushad
+ elseif VBOX_BIOS_CPU gt 8086
+        pusha
+ else
+        push    ax
+        push    cx
+        push    dx
+        push    bx
+        push    sp
+        push    bp
+        push    si
+        push    di
+ endif
+endm
+
+
+;; For handling the popad/popa instruction depending on target CPU.
+DO_POPAD        macro
+ if VBOX_BIOS_CPU ge 80386
+        popad
+ elseif VBOX_BIOS_CPU gt 8086
+        popa
+ else
+        pop     di
+        pop     si
+        pop     bp
+        pop     bx ;pop sp
+        pop     bx
+        pop     dx
+        pop     cx
+        pop     ax
+ endif
+endm
+
+
+;; ASSUMES working stack.
+DO_shr          macro reg, count
+ if VBOX_BIOS_CPU ge 80186
+        shr     reg, count
+ else
+  if count ge 6
+        push    cx
+        mov     cl, count
+        shr     reg, cl
+        pop     cx
+  else
+   if count ge 5
+        shr     reg, 1
+   endif
+   if count ge 4
+        shr     reg, 1
+   endif
+   if count ge 3
+        shr     reg, 1
+   endif
+   if count ge 2
+        shr     reg, 1
+   endif
+   if count ge 1
+        shr     reg, 1
+   endif
+  endif
+ endif
+endm
+
+
+;; ASSUMES working stack.
+DO_shl          macro reg, count
+ if VBOX_BIOS_CPU ge 80186
+        shl     reg, count
+ else
+  if count ge 6
+        push    cx
+        mov     cl, count
+        shl     reg, cl
+        pop     cx
+  else
+   if count ge 5
+        shl     reg, 1
+   endif
+   if count ge 4
+        shl     reg, 1
+   endif
+   if count ge 3
+        shl     reg, 1
+   endif
+   if count ge 2
+        shl     reg, 1
+   endif
+   if count ge 1
+        shl     reg, 1
+   endif
+  endif
+ endif
+endm
+
+
+
+
+;; Adds a special label that will have its address checked after linking.
+BIOSORG_CHECK macro addr
+public biosorg_check_at_&addr
+biosorg_check_at_&addr:
+        endm
+
+;; Adds a special label that will have its address checked after linking.
+BIOSORG_CHECK_BEFORE macro addr
+public biosorg_check_before_or_at_&addr
+biosorg_check_before_or_at_&addr:
+        endm
+
diff --git a/src/VBox/Devices/BiosCommonCode/fmemcpy.asm b/src/VBox/Devices/BiosCommonCode/fmemcpy.asm
new file mode 100644
index 00000000..3aa900b7
--- /dev/null
+++ b/src/VBox/Devices/BiosCommonCode/fmemcpy.asm
@@ -0,0 +1,75 @@
+; $Id: fmemcpy.asm $
+;; @file
+; Compiler support routines.
+;
+
+;
+; Copyright (C) 2012-2023 Oracle and/or its affiliates.
+;
+; This file is part of VirtualBox base platform packages, as
+; available from https://www.virtualbox.org.
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; as published by the Free Software Foundation, in version 3 of the
+; License.
+;
+; This program is distributed in the hope that it will be useful, but
+; WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+; General Public License for more details.
+;
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, see <https://www.gnu.org/licenses>.
+;
+; SPDX-License-Identifier: GPL-3.0-only
+;
+
+
+;*******************************************************************************
+;*  Exported Symbols                                                           *
+;*******************************************************************************
+public          _fmemcpy_
+
+
+                .8086
+
+_TEXT           segment public 'CODE' use16
+                assume cs:_TEXT
+
+
+;;
+; memcpy taking far pointers.
+;
+; cx, es may be modified; si, di are preserved
+;
+; @returns  dx:ax unchanged.
+; @param    dx:ax   Pointer to the destination memory.
+; @param    cx:bx   Pointer to the source memory.
+; @param    sp+2    The number of bytes to copy (dw).
+;
+_fmemcpy_:
+                push    bp
+                mov     bp, sp
+                push    di
+                push    ds
+                push    si
+
+                mov     es, dx
+                mov     di, ax
+                mov     ds, cx
+                mov     si, bx
+                mov     cx, [bp + 4]
+                rep     movsb
+
+                pop     si
+                pop     ds
+                pop     di
+                mov     sp, bp
+                pop     bp
+                ret
+
+
+_TEXT           ends
+                end
+
diff --git a/src/VBox/Devices/BiosCommonCode/fmemset.asm b/src/VBox/Devices/BiosCommonCode/fmemset.asm
new file mode 100644
index 00000000..e681f791
--- /dev/null
+++ b/src/VBox/Devices/BiosCommonCode/fmemset.asm
@@ -0,0 +1,65 @@
+; $Id: fmemset.asm $
+;; @file
+; Compiler support routines.
+;
+
+;
+; Copyright (C) 2012-2023 Oracle and/or its affiliates.
+;
+; This file is part of VirtualBox base platform packages, as
+; available from https://www.virtualbox.org.
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; as published by the Free Software Foundation, in version 3 of the
+; License.
+;
+; This program is distributed in the hope that it will be useful, but
+; WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+; General Public License for more details.
+;
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, see <https://www.gnu.org/licenses>.
+;
+; SPDX-License-Identifier: GPL-3.0-only
+;
+
+
+;*******************************************************************************
+;*  Exported Symbols                                                           *
+;*******************************************************************************
+public          _fmemset_
+
+
+                .8086
+
+_TEXT           segment public 'CODE' use16
+                assume cs:_TEXT
+
+
+;;
+; memset taking a far pointer.
+;
+; cx, es may be modified; di is preserved
+;
+; @returns  dx:ax unchanged.
+; @param    dx:ax   Pointer to the memory.
+; @param    bl      The fill value.
+; @param    cx      The number of bytes to fill.
+;
+_fmemset_:
+                push    di
+
+                mov     es, dx
+                mov     di, ax
+                xchg    al, bl
+                rep stosb
+                xchg    al, bl
+
+                pop     di
+                ret
+
+_TEXT           ends
+                end
+