/* $Id: VBoxBs3ObjConverter.cpp $ */ /** @file * VirtualBox Validation Kit - Boot Sector 3 object file convert. */ /* * 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 . * * The contents of this file may alternatively be used under the terms * of the Common Development and Distribution License Version 1.0 * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included * in the VirtualBox distribution, in which case the provisions of the * CDDL are applicable instead of those of the GPL. * * You may elect to license modified versions of this file under the * terms and conditions of either the GPL or the CDDL or both. * * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0 */ /********************************************************************************************************************************* * Header Files * *********************************************************************************************************************************/ #include #include #include #include #include #include #include #include #include #include #include #include #include #include /********************************************************************************************************************************* * Defined Constants And Macros * *********************************************************************************************************************************/ #if ARCH_BITS == 64 && !defined(RT_OS_WINDOWS) && !defined(RT_OS_DARWIN) # define ELF_FMT_X64 "lx" # define ELF_FMT_D64 "ld" #else # define ELF_FMT_X64 "llx" # define ELF_FMT_D64 "lld" #endif /** Compares an OMF string with a constant string. */ #define IS_OMF_STR_EQUAL_EX(a_cch1, a_pch1, a_szConst2) \ ( (a_cch1) == sizeof(a_szConst2) - 1 && memcmp(a_pch1, a_szConst2, sizeof(a_szConst2) - 1) == 0 ) /** Compares an OMF string with a constant string. */ #define IS_OMF_STR_EQUAL(a_pchZeroPrefixed, a_szConst2) \ IS_OMF_STR_EQUAL_EX((uint8_t)((a_pchZeroPrefixed)[0]), &((a_pchZeroPrefixed)[1]), a_szConst2) /********************************************************************************************************************************* * Global Variables * *********************************************************************************************************************************/ /** Verbosity level. */ static unsigned g_cVerbose = 0; /** Indicates that it's output from the 16-bit watcom C or C++ compiler. * We will do some massaging for fixup records when this is used. */ static bool g_f16BitWatcomC = false; /* * Minimal assertion support. */ RTDECL(bool) RTAssertShouldPanic(void) { return true; } RTDECL(void) RTAssertMsg1Weak(const char *pszExpr, unsigned uLine, const char *pszFile, const char *pszFunction) { fprintf(stderr, "VBoxBs3ObjConverter: assertion failed in %s (%s:%u)!\n" "VBoxBs3ObjConverter: %s\n", pszFunction, pszFile, uLine, pszExpr); } /** * Opens a file for binary reading or writing. * * @returns File stream handle. * @param pszFile The name of the file. * @param fWrite Whether to open for writing or reading. */ static FILE *openfile(const char *pszFile, bool fWrite) { #if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2) FILE *pFile = fopen(pszFile, fWrite ? "wb" : "rb"); #else FILE *pFile = fopen(pszFile, fWrite ? "w" : "r"); #endif if (!pFile) fprintf(stderr, "error: Failed to open '%s' for %s: %s (%d)\n", pszFile, fWrite ? "writing" : "reading", strerror(errno), errno); return pFile; } /** * Read the given file into memory. * * @returns true on success, false on failure. * @param pszFile The file to read. * @param ppvFile Where to return the memory. * @param pcbFile Where to return the size. */ static bool readfile(const char *pszFile, void **ppvFile, size_t *pcbFile) { FILE *pFile = openfile(pszFile, false); if (pFile) { /* * Figure the size. */ if (fseek(pFile, 0, SEEK_END) == 0) { long cbFile = ftell(pFile); if (cbFile > 0) { if (fseek(pFile, SEEK_SET, 0) == 0) { /* * Allocate and read content. */ void *pvFile = malloc((size_t)cbFile); if (pvFile) { if (fread(pvFile, cbFile, 1, pFile) == 1) { *ppvFile = pvFile; *pcbFile = (size_t)cbFile; fclose(pFile); return true; } free(pvFile); fprintf(stderr, "error: fread failed in '%s': %s (%d)\n", pszFile, strerror(errno), errno); } else fprintf(stderr, "error: failed to allocate %ld bytes of memory for '%s'\n", cbFile, pszFile); } else fprintf(stderr, "error: fseek #2 failed in '%s': %s (%d)\n", pszFile, strerror(errno), errno); } else fprintf(stderr, "error: ftell failed in '%s': %s (%d)\n", pszFile, strerror(errno), errno); } else fprintf(stderr, "error: fseek #1 failed in '%s': %s (%d)\n", pszFile, strerror(errno), errno); fclose(pFile); } return false; } /** * Write the given file into memory. * * @returns true on success, false on failure. * @param pszFile The file to write. * @param pvFile Where to return the memory. * @param cbFile Where to return the size. */ static bool writefile(const char *pszFile, void const *pvFile, size_t cbFile) { remove(pszFile); FILE *pFile = openfile(pszFile, true); if (pFile) { if (fwrite(pvFile, cbFile, 1, pFile) == 1) { fclose(pFile); return true; } fprintf(stderr, "error: fwrite failed in '%s': %s (%d)\n", pszFile, strerror(errno), errno); fclose(pFile); } return false; } /** * Reports an error and returns false. * * @returns false * @param pszFile The filename. * @param pszFormat The message format string. * @param ... Format arguments. */ static bool error(const char *pszFile, const char *pszFormat, ...) { fflush(stdout); fprintf(stderr, "error: %s: ", pszFile); va_list va; va_start(va, pszFormat); vfprintf(stderr, pszFormat, va); va_end(va); return false; } /********************************************************************************************************************************* * Common OMF Writer * *********************************************************************************************************************************/ /** Entry for each segment/section in the source format for mapping it to a * segment defintion. */ typedef struct OMFTOSEGDEF { /** The segment defintion index of the section, UINT16_MAX if not translated. */ uint16_t iSegDef; /** The group index for this segment, UINT16_MAX if not applicable. */ uint16_t iGrpDef; /** The class name table entry, UINT16_MAX if not applicable. */ uint16_t iClassNm; /** The group name for this segment, UINT16_MAX if not applicable. */ uint16_t iGrpNm; /** The group name for this segment, UINT16_MAX if not applicable. */ uint16_t iSegNm; /** The number of public definitions for this segment. */ uint32_t cPubDefs; /** The segment name (OMF). */ char *pszName; } OMFTOSEGDEF; /** Pointer to a segment/section to segdef mapping. */ typedef OMFTOSEGDEF *POMFTOSEGDEF; /** Symbol table translation type. */ typedef enum OMFSYMTYPE { /** Invalid symbol table entry (aux sym). */ OMFSYMTYPE_INVALID = 0, /** Ignored. */ OMFSYMTYPE_IGNORED, /** A public defintion. */ OMFSYMTYPE_PUBDEF, /** An external definition. */ OMFSYMTYPE_EXTDEF, /** A segment reference for fixups. */ OMFSYMTYPE_SEGDEF, /** Internal symbol that may be used for fixups. */ OMFSYMTYPE_INTERNAL } OMFSYMTYPE; /** Symbol table translation. */ typedef struct OMFSYMBOL { /** What this source symbol table entry should be translated into. */ OMFSYMTYPE enmType; /** The OMF table index. UINT16_MAX if not applicable. */ uint16_t idx; /** The OMF segment definition index. */ uint16_t idxSegDef; /** The OMF group definition index. */ uint16_t idxGrpDef; } OMFSYMBOL; /** Pointer to an source symbol table translation entry. */ typedef OMFSYMBOL *POMFSYMBOL; /** OMF Writer LNAME lookup record. */ typedef struct OMFWRLNAME { /** Pointer to the next entry with the name hash. */ struct OMFWRLNAME *pNext; /** The LNAMES index number. */ uint16_t idxName; /** The name length. */ uint8_t cchName; /** The name (variable size). */ char szName[1]; } OMFWRLNAME; /** Pointer to the a OMF writer LNAME lookup record. */ typedef OMFWRLNAME *POMFWRLNAME; /** * OMF converter & writer instance. */ typedef struct OMFWRITER { /** The source file name (for bitching). */ const char *pszSrc; /** The destination output file. */ FILE *pDst; /** Pointer to the table mapping from source segments/section to segdefs. */ POMFTOSEGDEF paSegments; /** Number of source segments/sections. */ uint32_t cSegments; /** Number of entries in the source symbol table. */ uint32_t cSymbols; /** Pointer to the table mapping from source symbols to OMF stuff. */ POMFSYMBOL paSymbols; /** LEDATA segment offset. */ uint32_t offSeg; /** Start of the current LEDATA record. */ uint32_t offSegRec; /** The LEDATA end segment offset. */ uint32_t offSegEnd; /** The current LEDATA segment. */ uint16_t idx; /** The index of the next list of names entry. */ uint16_t idxNextName; /** The current record size. */ uint16_t cbRec; /** The current record type */ uint8_t bType; /** The record data buffer (too large, but whatever). */ uint8_t abData[_1K + 64]; /** Current FIXUPP entry. */ uint8_t iFixupp; /** FIXUPP records being prepared for LEDATA currently stashed in abData. * We may have to adjust addend values in the LEDATA when converting to OMF * fixups. */ struct { uint16_t cbRec; uint8_t abData[_1K + 64]; uint8_t abAlign[2]; /**< Alignment padding. */ } aFixupps[3]; /** The index of the FLAT group. */ uint16_t idxGrpFlat; /** The EXTDEF index of the __ImageBase symbol. */ uint16_t idxExtImageBase; /** LNAME lookup hash table. To avoid too many duplicates. */ POMFWRLNAME apNameLookup[63]; } OMFWRITE; /** Pointer to an OMF writer. */ typedef OMFWRITE *POMFWRITER; /** * Creates an OMF writer instance. */ static POMFWRITER omfWriter_Create(const char *pszSrc, uint32_t cSegments, uint32_t cSymbols, FILE *pDst) { POMFWRITER pThis = (POMFWRITER)calloc(sizeof(OMFWRITER), 1); if (pThis) { pThis->pszSrc = pszSrc; pThis->idxNextName = 1; /* We start counting at 1. */ pThis->cSegments = cSegments; pThis->paSegments = (POMFTOSEGDEF)calloc(sizeof(OMFTOSEGDEF), cSegments); if (pThis->paSegments) { pThis->cSymbols = cSymbols; pThis->paSymbols = (POMFSYMBOL)calloc(sizeof(OMFSYMBOL), cSymbols); if (pThis->paSymbols) { pThis->pDst = pDst; return pThis; } free(pThis->paSegments); } free(pThis); } error(pszSrc, "Out of memory!\n"); return NULL; } /** * Destroys the given OMF writer instance. * @param pThis OMF writer instance. */ static void omfWriter_Destroy(POMFWRITER pThis) { free(pThis->paSymbols); for (uint32_t i = 0; i < pThis->cSegments; i++) if (pThis->paSegments[i].pszName) free(pThis->paSegments[i].pszName); free(pThis->paSegments); uint32_t i = RT_ELEMENTS(pThis->apNameLookup); while (i-- > 0) { POMFWRLNAME pNext = pThis->apNameLookup[i]; pThis->apNameLookup[i] = NULL; while (pNext) { POMFWRLNAME pFree = pNext; pNext = pNext->pNext; free(pFree); } } free(pThis); } static bool omfWriter_RecBegin(POMFWRITER pThis, uint8_t bType) { pThis->bType = bType; pThis->cbRec = 0; return true; } static bool omfWriter_RecAddU8(POMFWRITER pThis, uint8_t b) { if (pThis->cbRec < OMF_MAX_RECORD_PAYLOAD) { pThis->abData[pThis->cbRec++] = b; return true; } return error(pThis->pszSrc, "Exceeded max OMF record length (bType=%#x)!\n", pThis->bType); } static bool omfWriter_RecAddU16(POMFWRITER pThis, uint16_t u16) { if (pThis->cbRec + 2U <= OMF_MAX_RECORD_PAYLOAD) { pThis->abData[pThis->cbRec++] = (uint8_t)u16; pThis->abData[pThis->cbRec++] = (uint8_t)(u16 >> 8); return true; } return error(pThis->pszSrc, "Exceeded max OMF record length (bType=%#x)!\n", pThis->bType); } static bool omfWriter_RecAddU32(POMFWRITER pThis, uint32_t u32) { if (pThis->cbRec + 4U <= OMF_MAX_RECORD_PAYLOAD) { pThis->abData[pThis->cbRec++] = (uint8_t)u32; pThis->abData[pThis->cbRec++] = (uint8_t)(u32 >> 8); pThis->abData[pThis->cbRec++] = (uint8_t)(u32 >> 16); pThis->abData[pThis->cbRec++] = (uint8_t)(u32 >> 24); return true; } return error(pThis->pszSrc, "Exceeded max OMF record length (bType=%#x)!\n", pThis->bType); } static bool omfWriter_RecAddIdx(POMFWRITER pThis, uint16_t idx) { if (idx < 128) return omfWriter_RecAddU8(pThis, (uint8_t)idx); if (idx < _32K) return omfWriter_RecAddU8(pThis, (uint8_t)(idx >> 8) | 0x80) && omfWriter_RecAddU8(pThis, (uint8_t)idx); return error(pThis->pszSrc, "Index out of range %#x\n", idx); } static bool omfWriter_RecAddBytes(POMFWRITER pThis, const void *pvData, size_t cbData) { const uint16_t cbNasmHack = OMF_MAX_RECORD_PAYLOAD + 1; if (cbData + pThis->cbRec <= cbNasmHack) { memcpy(&pThis->abData[pThis->cbRec], pvData, cbData); pThis->cbRec += (uint16_t)cbData; return true; } return error(pThis->pszSrc, "Exceeded max OMF record length (bType=%#x, cbData=%#x, cbRec=%#x, max=%#x)!\n", pThis->bType, (unsigned)cbData, pThis->cbRec, OMF_MAX_RECORD_PAYLOAD); } static bool omfWriter_RecAddStringNEx(POMFWRITER pThis, const char *pchString, size_t cchString, bool fPrependUnderscore) { if (cchString < 256) { return omfWriter_RecAddU8(pThis, (uint8_t)cchString + fPrependUnderscore) && (!fPrependUnderscore || omfWriter_RecAddU8(pThis, '_')) && omfWriter_RecAddBytes(pThis, pchString, cchString); } return error(pThis->pszSrc, "String too long (%u bytes): '%*.*s'\n", (unsigned)cchString, (int)cchString, (int)cchString, pchString); } static bool omfWriter_RecAddStringN(POMFWRITER pThis, const char *pchString, size_t cchString) { return omfWriter_RecAddStringNEx(pThis, pchString, cchString, false /*fPrependUnderscore*/); } static bool omfWriter_RecAddString(POMFWRITER pThis, const char *pszString) { return omfWriter_RecAddStringNEx(pThis, pszString, strlen(pszString), false /*fPrependUnderscore*/); } static bool omfWriter_RecEnd(POMFWRITER pThis, bool fAddCrc) { if ( !fAddCrc || omfWriter_RecAddU8(pThis, 0)) { OMFRECHDR RecHdr = { pThis->bType, RT_H2LE_U16(pThis->cbRec) }; if ( fwrite(&RecHdr, sizeof(RecHdr), 1, pThis->pDst) == 1 && fwrite(pThis->abData, pThis->cbRec, 1, pThis->pDst) == 1) { pThis->bType = 0; pThis->cbRec = 0; return true; } return error(pThis->pszSrc, "Write error\n"); } return false; } static bool omfWriter_RecEndWithCrc(POMFWRITER pThis) { return omfWriter_RecEnd(pThis, true /*fAddCrc*/); } static bool omfWriter_BeginModule(POMFWRITER pThis, const char *pszFile) { return omfWriter_RecBegin(pThis, OMF_THEADR) && omfWriter_RecAddString(pThis, pszFile) && omfWriter_RecEndWithCrc(pThis); } /** * Simple stupid string hashing function (for LNAMES) * @returns 8-bit hash. * @param pchName The string. * @param cchName The string length. */ DECLINLINE(uint8_t) omfWriter_HashStrU8(const char *pchName, size_t cchName) { if (cchName) return (uint8_t)(cchName + pchName[cchName >> 1]); return 0; } /** * Looks up a LNAME. * * @returns Index (0..32K) if found, UINT16_MAX if not found. * @param pThis The OMF writer. * @param pchName The name to look up. * @param cchName The length of the name. */ static uint16_t omfWriter_LNamesLookupN(POMFWRITER pThis, const char *pchName, size_t cchName) { uint8_t uHash = omfWriter_HashStrU8(pchName, cchName); uHash %= RT_ELEMENTS(pThis->apNameLookup); POMFWRLNAME pCur = pThis->apNameLookup[uHash]; while (pCur) { if ( pCur->cchName == cchName && memcmp(pCur->szName, pchName, cchName) == 0) return pCur->idxName; pCur = pCur->pNext; } return UINT16_MAX; } /** * Add a LNAME lookup record. * * @returns success indicator. * @param pThis The OMF writer. * @param pchName The name to look up. * @param cchName The length of the name. * @param idxName The name index. */ static bool omfWriter_LNamesAddLookup(POMFWRITER pThis, const char *pchName, size_t cchName, uint16_t idxName) { POMFWRLNAME pCur = (POMFWRLNAME)malloc(sizeof(*pCur) + cchName); if (!pCur) return error("???", "Out of memory!\n"); pCur->idxName = idxName; pCur->cchName = (uint8_t)cchName; memcpy(pCur->szName, pchName, cchName); pCur->szName[cchName] = '\0'; uint8_t uHash = omfWriter_HashStrU8(pchName, cchName); uHash %= RT_ELEMENTS(pThis->apNameLookup); pCur->pNext = pThis->apNameLookup[uHash]; pThis->apNameLookup[uHash] = pCur; return true; } static bool omfWriter_LNamesAddN(POMFWRITER pThis, const char *pchName, size_t cchName, uint16_t *pidxName) { /* See if we've already got that name in the list. */ uint16_t idxName; if (pidxName) /* If pidxName is NULL, we assume the caller might just be passing stuff thru. */ { idxName = omfWriter_LNamesLookupN(pThis, pchName, cchName); if (idxName != UINT16_MAX) { *pidxName = idxName; return true; } } /* split? */ if (pThis->cbRec + 1 /*len*/ + cchName + 1 /*crc*/ > OMF_MAX_RECORD_PAYLOAD) { if (pThis->cbRec == 0) return error(pThis->pszSrc, "Too long LNAME '%*.*s'\n", (int)cchName, (int)cchName, pchName); if ( !omfWriter_RecEndWithCrc(pThis) || !omfWriter_RecBegin(pThis, OMF_LNAMES)) return false; } idxName = pThis->idxNextName++; if (pidxName) *pidxName = idxName; return omfWriter_RecAddStringN(pThis, pchName, cchName) && omfWriter_LNamesAddLookup(pThis, pchName, cchName, idxName); } static bool omfWriter_LNamesAdd(POMFWRITER pThis, const char *pszName, uint16_t *pidxName) { return omfWriter_LNamesAddN(pThis, pszName, strlen(pszName), pidxName); } static bool omfWriter_LNamesBegin(POMFWRITER pThis, bool fAddZeroEntry) { /* First entry is an empty string. */ return omfWriter_RecBegin(pThis, OMF_LNAMES) && ( pThis->idxNextName > 1 || !fAddZeroEntry || omfWriter_LNamesAddN(pThis, "", 0, NULL)); } static bool omfWriter_LNamesEnd(POMFWRITER pThis) { return omfWriter_RecEndWithCrc(pThis); } static bool omfWriter_SegDef(POMFWRITER pThis, uint8_t bSegAttr, uint32_t cbSeg, uint16_t idxSegName, uint16_t idxSegClass, uint16_t idxOverlay = 1 /* NULL entry */) { return omfWriter_RecBegin(pThis, OMF_SEGDEF32) && omfWriter_RecAddU8(pThis, bSegAttr) && omfWriter_RecAddU32(pThis, cbSeg) && omfWriter_RecAddIdx(pThis, idxSegName) && omfWriter_RecAddIdx(pThis, idxSegClass) && omfWriter_RecAddIdx(pThis, idxOverlay) && omfWriter_RecEndWithCrc(pThis); } static bool omfWriter_SegDef16(POMFWRITER pThis, uint8_t bSegAttr, uint32_t cbSeg, uint16_t idxSegName, uint16_t idxSegClass, uint16_t idxOverlay = 1 /* NULL entry */) { Assert(cbSeg <= UINT16_MAX); return omfWriter_RecBegin(pThis, OMF_SEGDEF16) && omfWriter_RecAddU8(pThis, bSegAttr) && omfWriter_RecAddU16(pThis, cbSeg) && omfWriter_RecAddIdx(pThis, idxSegName) && omfWriter_RecAddIdx(pThis, idxSegClass) && omfWriter_RecAddIdx(pThis, idxOverlay) && omfWriter_RecEndWithCrc(pThis); } static bool omfWriter_GrpDefBegin(POMFWRITER pThis, uint16_t idxGrpName) { return omfWriter_RecBegin(pThis, OMF_GRPDEF) && omfWriter_RecAddIdx(pThis, idxGrpName); } static bool omfWriter_GrpDefAddSegDef(POMFWRITER pThis, uint16_t idxSegDef) { return omfWriter_RecAddU8(pThis, 0xff) && omfWriter_RecAddIdx(pThis, idxSegDef); } static bool omfWriter_GrpDefEnd(POMFWRITER pThis) { return omfWriter_RecEndWithCrc(pThis); } static bool omfWriter_PubDefBegin(POMFWRITER pThis, uint16_t idxGrpDef, uint16_t idxSegDef) { return omfWriter_RecBegin(pThis, OMF_PUBDEF32) && omfWriter_RecAddIdx(pThis, idxGrpDef) && omfWriter_RecAddIdx(pThis, idxSegDef) && ( idxSegDef != 0 || omfWriter_RecAddU16(pThis, 0)); } static bool omfWriter_PubDefAddN(POMFWRITER pThis, uint32_t uValue, const char *pchString, size_t cchString, bool fPrependUnderscore) { /* Split? */ if (pThis->cbRec + 1 + cchString + 4 + 1 + 1 + fPrependUnderscore > OMF_MAX_RECORD_PAYLOAD) { if (cchString >= 256) return error(pThis->pszSrc, "PUBDEF string too long %u ('%s')\n", (unsigned)cchString, (int)cchString, (int)cchString, pchString); if (!omfWriter_RecEndWithCrc(pThis)) return false; /* Figure out the initial data length. */ pThis->cbRec = 1 + ((pThis->abData[0] & 0x80) != 0); if (pThis->abData[pThis->cbRec] != 0) pThis->cbRec += 1 + ((pThis->abData[pThis->cbRec] & 0x80) != 0); else pThis->cbRec += 3; pThis->bType = OMF_PUBDEF32; } return omfWriter_RecAddStringNEx(pThis, pchString, cchString, fPrependUnderscore) && omfWriter_RecAddU32(pThis, uValue) && omfWriter_RecAddIdx(pThis, 0); /* type */ } static bool omfWriter_PubDefAdd(POMFWRITER pThis, uint32_t uValue, const char *pszString, bool fPrependUnderscore) { return omfWriter_PubDefAddN(pThis, uValue, pszString, strlen(pszString), fPrependUnderscore); } static bool omfWriter_PubDefEnd(POMFWRITER pThis) { return omfWriter_RecEndWithCrc(pThis); } /** * EXTDEF - Begin record. */ static bool omfWriter_ExtDefBegin(POMFWRITER pThis) { return omfWriter_RecBegin(pThis, OMF_EXTDEF); } /** * EXTDEF - Add an entry, split record if necessary. */ static bool omfWriter_ExtDefAddN(POMFWRITER pThis, const char *pchString, size_t cchString, uint16_t idxType, bool fPrependUnderscore) { /* Split? */ if (pThis->cbRec + 1 + cchString + 1 + 1 + fPrependUnderscore > OMF_MAX_RECORD_PAYLOAD) { if (cchString >= 256) return error(pThis->pszSrc, "EXTDEF string too long %u ('%s')\n", (unsigned)cchString, (int)cchString, (int)cchString, pchString); if ( !omfWriter_RecEndWithCrc(pThis) || !omfWriter_RecBegin(pThis, OMF_EXTDEF)) return false; } return omfWriter_RecAddStringNEx(pThis, pchString, cchString, fPrependUnderscore) && omfWriter_RecAddIdx(pThis, idxType); /* type */ } /** * EXTDEF - Add an entry, split record if necessary. */ static bool omfWriter_ExtDefAdd(POMFWRITER pThis, const char *pszString, bool fPrependUnderscore) { return omfWriter_ExtDefAddN(pThis, pszString, strlen(pszString), 0, fPrependUnderscore); } /** * EXTDEF - End of record. */ static bool omfWriter_ExtDefEnd(POMFWRITER pThis) { return omfWriter_RecEndWithCrc(pThis); } /** * COMENT/LINK_PASS_SEP - Add a link pass separator comment. */ static bool omfWriter_LinkPassSeparator(POMFWRITER pThis) { return omfWriter_RecBegin(pThis, OMF_COMENT) && omfWriter_RecAddU8(pThis, OMF_CTYP_NO_LIST) && omfWriter_RecAddU8(pThis, OMF_CCLS_LINK_PASS_SEP) && omfWriter_RecAddU8(pThis, 1) && omfWriter_RecEndWithCrc(pThis); } /** * LEDATA + FIXUPP - Begin records. */ static bool omfWriter_LEDataBegin(POMFWRITER pThis, uint16_t idxSeg, uint32_t offSeg) { if ( omfWriter_RecBegin(pThis, OMF_LEDATA32) && omfWriter_RecAddIdx(pThis, idxSeg) && omfWriter_RecAddU32(pThis, offSeg)) { pThis->idx = idxSeg; pThis->offSeg = offSeg; pThis->offSegRec = offSeg; pThis->offSegEnd = offSeg + OMF_MAX_RECORD_PAYLOAD - 1 /*CRC*/ - pThis->cbRec; pThis->offSegEnd &= ~(uint32_t)7; /* qword align. */ /* Reset the associated FIXUPP records. */ pThis->iFixupp = 0; for (unsigned i = 0; i < RT_ELEMENTS(pThis->aFixupps); i++) pThis->aFixupps[i].cbRec = 0; return true; } return false; } /** * LEDATA + FIXUPP - Begin records. */ static bool omfWriter_LEDataBeginEx(POMFWRITER pThis, uint16_t idxSeg, uint32_t offSeg, uint32_t cbData, uint32_t cbRawData, void const *pbRawData, uint8_t **ppbData) { if ( omfWriter_RecBegin(pThis, OMF_LEDATA32) && omfWriter_RecAddIdx(pThis, idxSeg) && omfWriter_RecAddU32(pThis, offSeg)) { if ( cbData <= _1K && pThis->cbRec + cbData + 1 <= OMF_MAX_RECORD_PAYLOAD) { uint8_t *pbDst = &pThis->abData[pThis->cbRec]; if (ppbData) *ppbData = pbDst; if (cbRawData) memcpy(pbDst, pbRawData, RT_MIN(cbData, cbRawData)); if (cbData > cbRawData) memset(&pbDst[cbRawData], 0, cbData - cbRawData); pThis->cbRec += cbData; pThis->idx = idxSeg; pThis->offSegRec = offSeg; pThis->offSeg = offSeg + cbData; pThis->offSegEnd = offSeg + cbData; /* Reset the associated FIXUPP records. */ pThis->iFixupp = 0; for (unsigned i = 0; i < RT_ELEMENTS(pThis->aFixupps); i++) pThis->aFixupps[i].cbRec = 0; return true; } error(pThis->pszSrc, "Too much data for LEDATA record! (%#x)\n", (unsigned)cbData); } return false; } /** * LEDATA + FIXUPP - Add FIXUPP subrecord bytes, split if necessary. */ static bool omfWriter_LEDataAddFixuppBytes(POMFWRITER pThis, void *pvSubRec, size_t cbSubRec) { /* Split? */ unsigned iFixupp = pThis->iFixupp; if (pThis->aFixupps[iFixupp].cbRec + cbSubRec >= OMF_MAX_RECORD_PAYLOAD) { if (g_cVerbose >= 2) printf("debug: FIXUPP split\n"); iFixupp++; if (iFixupp >= RT_ELEMENTS(pThis->aFixupps)) return error(pThis->pszSrc, "Out of FIXUPP records\n"); pThis->iFixupp = iFixupp; pThis->aFixupps[iFixupp].cbRec = 0; /* paranoia */ } /* Append the sub-record data. */ memcpy(&pThis->aFixupps[iFixupp].abData[pThis->aFixupps[iFixupp].cbRec], pvSubRec, cbSubRec); pThis->aFixupps[iFixupp].cbRec += (uint16_t)cbSubRec; return true; } /** * LEDATA + FIXUPP - Add fixup, split if necessary. */ static bool omfWriter_LEDataAddFixup(POMFWRITER pThis, uint16_t offDataRec, bool fSelfRel, uint8_t bLocation, uint8_t bFrame, uint16_t idxFrame, uint8_t bTarget, uint16_t idxTarget, bool fTargetDisp, uint32_t offTargetDisp) { if (g_cVerbose >= 2) printf("debug: FIXUP[%#x]: off=%#x frame=%u:%#x target=%u:%#x disp=%d:%#x\n", pThis->aFixupps[pThis->iFixupp].cbRec, offDataRec, bFrame, idxFrame, bTarget, idxTarget, fTargetDisp, offTargetDisp); if ( offDataRec >= _1K || bFrame >= 6 || bTarget > 6 || idxFrame >= _32K || idxTarget >= _32K || fTargetDisp != (bTarget <= OMF_FIX_T_FRAME_NO) ) return error(pThis->pszSrc, "Internal error: offDataRec=%#x bFrame=%u idxFrame=%#x bTarget=%u idxTarget=%#x fTargetDisp=%d offTargetDisp=%#x\n", offDataRec, bFrame, idxFrame, bTarget, idxTarget, fTargetDisp, offTargetDisp); /* * Encode the FIXUP subrecord. */ uint8_t abFixup[16]; uint8_t off = 0; /* Location */ abFixup[off++] = (offDataRec >> 8) | (bLocation << 2) | ((uint8_t)!fSelfRel << 6) | 0x80; abFixup[off++] = (uint8_t)offDataRec; /* Fix Data */ abFixup[off++] = 0x00 /*F=0*/ | (bFrame << 4) | 0x00 /*T=0*/ | bTarget; /* Frame Datum */ if (bFrame <= OMF_FIX_F_FRAME_NO) { if (idxFrame >= 128) abFixup[off++] = (uint8_t)(idxFrame >> 8) | 0x80; abFixup[off++] = (uint8_t)idxFrame; } /* Target Datum */ if (idxTarget >= 128) abFixup[off++] = (uint8_t)(idxTarget >> 8) | 0x80; abFixup[off++] = (uint8_t)idxTarget; /* Target Displacement */ if (fTargetDisp) { abFixup[off++] = RT_BYTE1(offTargetDisp); abFixup[off++] = RT_BYTE2(offTargetDisp); abFixup[off++] = RT_BYTE3(offTargetDisp); abFixup[off++] = RT_BYTE4(offTargetDisp); } return omfWriter_LEDataAddFixuppBytes(pThis, abFixup, off); } /** * LEDATA + FIXUPP - Add simple fixup, split if necessary. */ static bool omfWriter_LEDataAddFixupNoDisp(POMFWRITER pThis, uint16_t offDataRec, uint8_t bLocation, uint8_t bFrame, uint16_t idxFrame, uint8_t bTarget, uint16_t idxTarget) { return omfWriter_LEDataAddFixup(pThis, offDataRec, false /*fSelfRel*/, bLocation, bFrame, idxFrame, bTarget, idxTarget, false /*fTargetDisp*/, 0 /*offTargetDisp*/); } /** * LEDATA + FIXUPP - End of records. */ static bool omfWriter_LEDataEnd(POMFWRITER pThis) { if (omfWriter_RecEndWithCrc(pThis)) { for (unsigned iFixupp = 0; iFixupp <= pThis->iFixupp; iFixupp++) { uint16_t const cbRec = pThis->aFixupps[iFixupp].cbRec; if (!cbRec) break; if (g_cVerbose >= 3) printf("debug: FIXUPP32 #%u cbRec=%#x\n", iFixupp, cbRec); if ( !omfWriter_RecBegin(pThis, OMF_FIXUPP32) || !omfWriter_RecAddBytes(pThis, pThis->aFixupps[iFixupp].abData, cbRec) || !omfWriter_RecEndWithCrc(pThis)) return false; } pThis->iFixupp = 0; return true; } return false; } /** * LEDATA + FIXUPP - Splits the LEDATA record. */ static bool omfWriter_LEDataSplit(POMFWRITER pThis) { return omfWriter_LEDataEnd(pThis) && omfWriter_LEDataBegin(pThis, pThis->idx, pThis->offSeg); } /** * LEDATA + FIXUPP - Returns available space in current LEDATA record. */ static uint32_t omfWriter_LEDataAvailable(POMFWRITER pThis) { if (pThis->offSeg < pThis->offSegEnd) return pThis->offSegEnd - pThis->offSeg; return 0; } /** * LEDATA + FIXUPP - Splits LEDATA record if less than @a cb bytes available. */ static bool omfWriter_LEDataEnsureSpace(POMFWRITER pThis, uint32_t cb) { if ( omfWriter_LEDataAvailable(pThis) >= cb || omfWriter_LEDataSplit(pThis)) return true; return false; } /** * LEDATA + FIXUPP - Adds data to the LEDATA record, splitting it if needed. */ static bool omfWriter_LEDataAddBytes(POMFWRITER pThis, void const *pvData, size_t cbData) { while (cbData > 0) { uint32_t cbAvail = omfWriter_LEDataAvailable(pThis); if (cbAvail >= cbData) { if (omfWriter_RecAddBytes(pThis, pvData, cbData)) { pThis->offSeg += (uint32_t)cbData; break; } return false; } if (!omfWriter_RecAddBytes(pThis, pvData, cbAvail)) return false; pThis->offSeg += cbAvail; pvData = (uint8_t const *)pvData + cbAvail; cbData -= cbAvail; if (!omfWriter_LEDataSplit(pThis)) return false; } return true; } /** * LEDATA + FIXUPP - Adds a U32 to the LEDATA record, splitting if needed. */ static bool omfWriter_LEDataAddU32(POMFWRITER pThis, uint32_t u32) { if ( omfWriter_LEDataEnsureSpace(pThis, 4) && omfWriter_RecAddU32(pThis, u32)) { pThis->offSeg += 4; return true; } return false; } /** * LEDATA + FIXUPP - Adds a U16 to the LEDATA record, splitting if needed. */ static bool omfWriter_LEDataAddU16(POMFWRITER pThis, uint16_t u16) { if ( omfWriter_LEDataEnsureSpace(pThis, 2) && omfWriter_RecAddU16(pThis, u16)) { pThis->offSeg += 2; return true; } return false; } #if 0 /* unused */ /** * LEDATA + FIXUPP - Adds a byte to the LEDATA record, splitting if needed. */ static bool omfWriter_LEDataAddU8(POMFWRITER pThis, uint8_t b) { if ( omfWriter_LEDataEnsureSpace(pThis, 1) && omfWriter_RecAddU8(pThis, b)) { pThis->offSeg += 1; return true; } return false; } #endif /** * MODEND - End of module, simple variant. */ static bool omfWriter_EndModule(POMFWRITER pThis) { return omfWriter_RecBegin(pThis, OMF_MODEND32) && omfWriter_RecAddU8(pThis, 0) && omfWriter_RecEndWithCrc(pThis); } /********************************************************************************************************************************* * ELF64/AMD64 -> ELF64/i386 Converter * *********************************************************************************************************************************/ /** AMD64 relocation type names for ELF. */ static const char * const g_apszElfAmd64RelTypes[] = { "R_X86_64_NONE", "R_X86_64_64", "R_X86_64_PC32", "R_X86_64_GOT32", "R_X86_64_PLT32", "R_X86_64_COPY", "R_X86_64_GLOB_DAT", "R_X86_64_JMP_SLOT", "R_X86_64_RELATIVE", "R_X86_64_GOTPCREL", "R_X86_64_32", "R_X86_64_32S", "R_X86_64_16", "R_X86_64_PC16", "R_X86_64_8", "R_X86_64_PC8", "R_X86_64_DTPMOD64", "R_X86_64_DTPOFF64", "R_X86_64_TPOFF64", "R_X86_64_TLSGD", "R_X86_64_TLSLD", "R_X86_64_DTPOFF32", "R_X86_64_GOTTPOFF", "R_X86_64_TPOFF32", }; /** AMD64 relocation type sizes for ELF. */ static uint8_t const g_acbElfAmd64RelTypes[] = { 0, /* R_X86_64_NONE */ 8, /* R_X86_64_64 */ 4, /* R_X86_64_PC32 */ 4, /* R_X86_64_GOT32 */ 4, /* R_X86_64_PLT32 */ 0, /* R_X86_64_COPY */ 0, /* R_X86_64_GLOB_DAT */ 0, /* R_X86_64_JMP_SLOT */ 0, /* R_X86_64_RELATIVE */ 0, /* R_X86_64_GOTPCREL */ 4, /* R_X86_64_32 */ 4, /* R_X86_64_32S */ 2, /* R_X86_64_16 */ 2, /* R_X86_64_PC16 */ 1, /* R_X86_64_8 */ 1, /* R_X86_64_PC8 */ 0, /* R_X86_64_DTPMOD64 */ 0, /* R_X86_64_DTPOFF64 */ 0, /* R_X86_64_TPOFF64 */ 0, /* R_X86_64_TLSGD */ 0, /* R_X86_64_TLSLD */ 0, /* R_X86_64_DTPOFF32 */ 0, /* R_X86_64_GOTTPOFF */ 0, /* R_X86_64_TPOFF32 */ }; /** Macro for getting the size of a AMD64 ELF relocation. */ #define ELF_AMD64_RELOC_SIZE(a_Type) ( (a_Type) < RT_ELEMENTS(g_acbElfAmd64RelTypes) ? g_acbElfAmd64RelTypes[(a_Type)] : 1) typedef struct ELFDETAILS { /** The ELF header. */ Elf64_Ehdr const *pEhdr; /** The section header table. */ Elf64_Shdr const *paShdrs; /** The string table for the section names. */ const char *pchShStrTab; /** The symbol table section number. UINT16_MAX if not found. */ uint16_t iSymSh; /** The string table section number. UINT16_MAX if not found. */ uint16_t iStrSh; /** The symbol table. */ Elf64_Sym const *paSymbols; /** The number of symbols in the symbol table. */ uint32_t cSymbols; /** Pointer to the (symbol) string table if found. */ const char *pchStrTab; /** The string table size. */ size_t cbStrTab; } ELFDETAILS; typedef ELFDETAILS *PELFDETAILS; typedef ELFDETAILS const *PCELFDETAILS; static bool validateElf(const char *pszFile, uint8_t const *pbFile, size_t cbFile, PELFDETAILS pElfStuff) { /* * Initialize the ELF details structure. */ memset(pElfStuff, 0, sizeof(*pElfStuff)); pElfStuff->iSymSh = UINT16_MAX; pElfStuff->iStrSh = UINT16_MAX; /* * Validate the header and our other expectations. */ Elf64_Ehdr const *pEhdr = (Elf64_Ehdr const *)pbFile; pElfStuff->pEhdr = pEhdr; if ( pEhdr->e_ident[EI_CLASS] != ELFCLASS64 || pEhdr->e_ident[EI_DATA] != ELFDATA2LSB || pEhdr->e_ehsize != sizeof(Elf64_Ehdr) || pEhdr->e_shentsize != sizeof(Elf64_Shdr) || pEhdr->e_version != EV_CURRENT ) return error(pszFile, "Unsupported ELF config\n"); if (pEhdr->e_type != ET_REL) return error(pszFile, "Expected relocatable ELF file (e_type=%d)\n", pEhdr->e_type); if (pEhdr->e_machine != EM_X86_64) return error(pszFile, "Expected relocatable ELF file (e_type=%d)\n", pEhdr->e_machine); if (pEhdr->e_phnum != 0) return error(pszFile, "Expected e_phnum to be zero not %u\n", pEhdr->e_phnum); if (pEhdr->e_shnum < 2) return error(pszFile, "Expected e_shnum to be two or higher\n"); if (pEhdr->e_shstrndx >= pEhdr->e_shnum || pEhdr->e_shstrndx == 0) return error(pszFile, "Bad e_shstrndx=%u (e_shnum=%u)\n", pEhdr->e_shstrndx, pEhdr->e_shnum); if ( pEhdr->e_shoff >= cbFile || pEhdr->e_shoff + pEhdr->e_shnum * sizeof(Elf64_Shdr) > cbFile) return error(pszFile, "Section table is outside the file (e_shoff=%#llx, e_shnum=%u, cbFile=%#llx)\n", pEhdr->e_shstrndx, pEhdr->e_shnum, (uint64_t)cbFile); /* * Locate the section name string table. * We assume it's okay as we only reference it in verbose mode. */ Elf64_Shdr const *paShdrs = (Elf64_Shdr const *)&pbFile[pEhdr->e_shoff]; pElfStuff->paShdrs = paShdrs; Elf64_Xword const cbShStrTab = paShdrs[pEhdr->e_shstrndx].sh_size; if ( paShdrs[pEhdr->e_shstrndx].sh_offset > cbFile || cbShStrTab > cbFile || paShdrs[pEhdr->e_shstrndx].sh_offset + cbShStrTab > cbFile) return error(pszFile, "Section string table is outside the file (sh_offset=%#" ELF_FMT_X64 " sh_size=%#" ELF_FMT_X64 " cbFile=%#" ELF_FMT_X64 ")\n", paShdrs[pEhdr->e_shstrndx].sh_offset, paShdrs[pEhdr->e_shstrndx].sh_size, (Elf64_Xword)cbFile); const char *pchShStrTab = (const char *)&pbFile[paShdrs[pEhdr->e_shstrndx].sh_offset]; pElfStuff->pchShStrTab = pchShStrTab; /* * Work the section table. */ bool fRet = true; for (uint32_t i = 1; i < pEhdr->e_shnum; i++) { if (paShdrs[i].sh_name >= cbShStrTab) return error(pszFile, "Invalid sh_name value (%#x) for section #%u\n", paShdrs[i].sh_name, i); const char *pszShNm = &pchShStrTab[paShdrs[i].sh_name]; if ( paShdrs[i].sh_offset > cbFile || paShdrs[i].sh_size > cbFile || paShdrs[i].sh_offset + paShdrs[i].sh_size > cbFile) return error(pszFile, "Section #%u '%s' has data outside the file: %#" ELF_FMT_X64 " LB %#" ELF_FMT_X64 " (cbFile=%#" ELF_FMT_X64 ")\n", i, pszShNm, paShdrs[i].sh_offset, paShdrs[i].sh_size, (Elf64_Xword)cbFile); if (g_cVerbose) printf("shdr[%u]: name=%#x '%s' type=%#x flags=%#" ELF_FMT_X64 " addr=%#" ELF_FMT_X64 " off=%#" ELF_FMT_X64 " size=%#" ELF_FMT_X64 "\n" " link=%u info=%#x align=%#" ELF_FMT_X64 " entsize=%#" ELF_FMT_X64 "\n", i, paShdrs[i].sh_name, pszShNm, paShdrs[i].sh_type, paShdrs[i].sh_flags, paShdrs[i].sh_addr, paShdrs[i].sh_offset, paShdrs[i].sh_size, paShdrs[i].sh_link, paShdrs[i].sh_info, paShdrs[i].sh_addralign, paShdrs[i].sh_entsize); if (paShdrs[i].sh_link >= pEhdr->e_shnum) return error(pszFile, "Section #%u '%s' links to a section outside the section table: %#x, max %#x\n", i, pszShNm, paShdrs[i].sh_link, pEhdr->e_shnum); if (!RT_IS_POWER_OF_TWO(paShdrs[i].sh_addralign)) return error(pszFile, "Section #%u '%s' alignment value is not a power of two: %#" ELF_FMT_X64 "\n", i, pszShNm, paShdrs[i].sh_addralign); if (!RT_IS_POWER_OF_TWO(paShdrs[i].sh_addralign)) return error(pszFile, "Section #%u '%s' alignment value is not a power of two: %#" ELF_FMT_X64 "\n", i, pszShNm, paShdrs[i].sh_addralign); if (paShdrs[i].sh_addr != 0) return error(pszFile, "Section #%u '%s' has non-zero address: %#" ELF_FMT_X64 "\n", i, pszShNm, paShdrs[i].sh_addr); if (paShdrs[i].sh_type == SHT_RELA) { if (paShdrs[i].sh_entsize != sizeof(Elf64_Rela)) return error(pszFile, "Expected sh_entsize to be %u not %u for section #%u (%s)\n", (unsigned)sizeof(Elf64_Rela), paShdrs[i].sh_entsize, i, pszShNm); uint32_t const cRelocs = paShdrs[i].sh_size / sizeof(Elf64_Rela); if (cRelocs * sizeof(Elf64_Rela) != paShdrs[i].sh_size) return error(pszFile, "Uneven relocation entry count in #%u (%s): sh_size=%#" ELF_FMT_X64 "\n", i, pszShNm, paShdrs[i].sh_size); if ( paShdrs[i].sh_offset > cbFile || paShdrs[i].sh_size >= cbFile || paShdrs[i].sh_offset + paShdrs[i].sh_size > cbFile) return error(pszFile, "The content of section #%u '%s' is outside the file (%#" ELF_FMT_X64 " LB %#" ELF_FMT_X64 ", cbFile=%#lx)\n", i, pszShNm, paShdrs[i].sh_offset, paShdrs[i].sh_size, (unsigned long)cbFile); if (paShdrs[i].sh_info != i - 1) return error(pszFile, "Expected relocation section #%u (%s) to link to previous section: sh_info=%#u\n", i, pszShNm, (unsigned)paShdrs[i].sh_link); if (paShdrs[paShdrs[i].sh_link].sh_type != SHT_SYMTAB) return error(pszFile, "Expected relocation section #%u (%s) to link to symbol table: sh_link=%#u -> sh_type=%#x\n", i, pszShNm, (unsigned)paShdrs[i].sh_link, (unsigned)paShdrs[paShdrs[i].sh_link].sh_type); uint32_t cSymbols = paShdrs[paShdrs[i].sh_link].sh_size / paShdrs[paShdrs[i].sh_link].sh_entsize; Elf64_Rela const *paRelocs = (Elf64_Rela *)&pbFile[paShdrs[i].sh_offset]; for (uint32_t j = 0; j < cRelocs; j++) { uint8_t const bType = ELF64_R_TYPE(paRelocs[j].r_info); if (RT_UNLIKELY(bType >= R_X86_64_COUNT)) fRet = error(pszFile, "%#018" ELF_FMT_X64 " %#018" ELF_FMT_X64 ": unknown fix up %#x (%+" ELF_FMT_D64 ")\n", paRelocs[j].r_offset, paRelocs[j].r_info, bType, paRelocs[j].r_addend); if (RT_UNLIKELY( paRelocs[j].r_offset > paShdrs[i - 1].sh_size || paRelocs[j].r_offset + ELF_AMD64_RELOC_SIZE(ELF64_R_TYPE(paRelocs[j].r_info)) > paShdrs[i - 1].sh_size)) fRet = error(pszFile, "%#018" ELF_FMT_X64 " %#018" ELF_FMT_X64 ": out of bounds (sh_size %" ELF_FMT_X64 ")\n", paRelocs[j].r_offset, paRelocs[j].r_info, paShdrs[i - 1].sh_size); uint32_t const iSymbol = ELF64_R_SYM(paRelocs[j].r_info); if (RT_UNLIKELY(iSymbol >= cSymbols)) fRet = error(pszFile, "%#018" ELF_FMT_X64 " %#018" ELF_FMT_X64 ": symbol index (%#x) out of bounds (%#x)\n", paRelocs[j].r_offset, paRelocs[j].r_info, iSymbol, cSymbols); } } else if (paShdrs[i].sh_type == SHT_REL) fRet = error(pszFile, "Section #%u '%s': Unexpected SHT_REL section\n", i, pszShNm); else if (paShdrs[i].sh_type == SHT_SYMTAB) { if (paShdrs[i].sh_entsize != sizeof(Elf64_Sym)) fRet = error(pszFile, "Section #%u '%s': Unsupported symbol table entry size in : #%u (expected #%u)\n", i, pszShNm, paShdrs[i].sh_entsize, sizeof(Elf64_Sym)); Elf64_Xword const cSymbols = paShdrs[i].sh_size / paShdrs[i].sh_entsize; if (cSymbols * paShdrs[i].sh_entsize != paShdrs[i].sh_size) fRet = error(pszFile, "Section #%u '%s': Size not a multiple of entry size: %#" ELF_FMT_X64 " %% %#" ELF_FMT_X64 " = %#" ELF_FMT_X64 "\n", i, pszShNm, paShdrs[i].sh_size, paShdrs[i].sh_entsize, paShdrs[i].sh_size % paShdrs[i].sh_entsize); if (cSymbols > UINT32_MAX) fRet = error(pszFile, "Section #%u '%s': too many symbols: %" ELF_FMT_X64 "\n", i, pszShNm, paShdrs[i].sh_size, cSymbols); if (pElfStuff->iSymSh == UINT16_MAX) { pElfStuff->iSymSh = (uint16_t)i; pElfStuff->paSymbols = (Elf64_Sym const *)&pbFile[paShdrs[i].sh_offset]; pElfStuff->cSymbols = cSymbols; if (paShdrs[i].sh_link != 0) { /* Note! The symbol string table section header may not have been validated yet! */ Elf64_Shdr const *pStrTabShdr = &paShdrs[paShdrs[i].sh_link]; pElfStuff->iStrSh = paShdrs[i].sh_link; pElfStuff->pchStrTab = (const char *)&pbFile[pStrTabShdr->sh_offset]; pElfStuff->cbStrTab = (size_t)pStrTabShdr->sh_size; } else fRet = error(pszFile, "Section #%u '%s': String table link is out of bounds (%#x)\n", i, pszShNm, paShdrs[i].sh_link); } else fRet = error(pszFile, "Section #%u '%s': Found additonal symbol table, previous in #%u\n", i, pszShNm, pElfStuff->iSymSh); } } return fRet; } static bool convertElfSectionsToSegDefsAndGrpDefs(POMFWRITER pThis, PCELFDETAILS pElfStuff) { /* * Do the list of names pass. */ uint16_t idxGrpFlat, idxGrpData; uint16_t idxClassCode, idxClassData, idxClassDwarf; if ( !omfWriter_LNamesBegin(pThis, true /*fAddZeroEntry*/) || !omfWriter_LNamesAddN(pThis, RT_STR_TUPLE("FLAT"), &idxGrpFlat) || !omfWriter_LNamesAddN(pThis, RT_STR_TUPLE("BS3DATA64_GROUP"), &idxGrpData) || !omfWriter_LNamesAddN(pThis, RT_STR_TUPLE("BS3CLASS64CODE"), &idxClassCode) || !omfWriter_LNamesAddN(pThis, RT_STR_TUPLE("FAR_DATA"), &idxClassData) || !omfWriter_LNamesAddN(pThis, RT_STR_TUPLE("DWARF"), &idxClassDwarf) ) return false; bool fHaveData = false; Elf64_Shdr const *pShdr = &pElfStuff->paShdrs[1]; Elf64_Half const cSections = pElfStuff->pEhdr->e_shnum; for (Elf64_Half i = 1; i < cSections; i++, pShdr++) { const char *pszName = &pElfStuff->pchShStrTab[pShdr->sh_name]; if (*pszName == '\0') return error(pThis->pszSrc, "Section #%u has an empty name!\n", i); switch (pShdr->sh_type) { case SHT_PROGBITS: case SHT_NOBITS: /* We drop a few sections we don't want:. */ if ( strcmp(pszName, ".comment") != 0 /* compiler info */ && strcmp(pszName, ".note.GNU-stack") != 0 /* some empty section for hinting the linker/whatever */ && strcmp(pszName, ".eh_frame") != 0 /* unwind / exception info */ ) { pThis->paSegments[i].iSegDef = UINT16_MAX; pThis->paSegments[i].iGrpDef = UINT16_MAX; /* Translate the name and determine group and class. Note! We currently strip sub-sections. */ if ( strcmp(pszName, ".text") == 0 || strncmp(pszName, RT_STR_TUPLE(".text.")) == 0) { pszName = "BS3TEXT64"; pThis->paSegments[i].iGrpNm = idxGrpFlat; pThis->paSegments[i].iClassNm = idxClassCode; } else if ( strcmp(pszName, ".data") == 0 || strncmp(pszName, RT_STR_TUPLE(".data.")) == 0) { pszName = "BS3DATA64"; pThis->paSegments[i].iGrpNm = idxGrpData; pThis->paSegments[i].iClassNm = idxClassData; } else if (strcmp(pszName, ".bss") == 0) { pszName = "BS3BSS64"; pThis->paSegments[i].iGrpNm = idxGrpData; pThis->paSegments[i].iClassNm = idxClassData; } else if ( strcmp(pszName, ".rodata") == 0 || strncmp(pszName, RT_STR_TUPLE(".rodata.")) == 0) { pszName = "BS3DATA64CONST"; pThis->paSegments[i].iGrpNm = idxGrpData; pThis->paSegments[i].iClassNm = idxClassData; } else if (strncmp(pszName, RT_STR_TUPLE(".debug_")) == 0) { pThis->paSegments[i].iGrpNm = UINT16_MAX; pThis->paSegments[i].iClassNm = idxClassDwarf; } else { pThis->paSegments[i].iGrpNm = idxGrpData; pThis->paSegments[i].iClassNm = idxClassData; error(pThis->pszSrc, "Unknown data (?) segment: '%s'\n", pszName); } /* Save the name. */ pThis->paSegments[i].pszName = strdup(pszName); if (!pThis->paSegments[i].pszName) return error(pThis->pszSrc, "Out of memory!\n"); /* Add the section name. */ if (!omfWriter_LNamesAdd(pThis, pThis->paSegments[i].pszName, &pThis->paSegments[i].iSegNm)) return false; fHaveData |= pThis->paSegments[i].iGrpNm == idxGrpData; break; } RT_FALL_THRU(); default: pThis->paSegments[i].iSegDef = UINT16_MAX; pThis->paSegments[i].iGrpDef = UINT16_MAX; pThis->paSegments[i].iSegNm = UINT16_MAX; pThis->paSegments[i].iGrpNm = UINT16_MAX; pThis->paSegments[i].iClassNm = UINT16_MAX; pThis->paSegments[i].pszName = NULL; break; } } if (!omfWriter_LNamesEnd(pThis)) return false; /* * Emit segment definitions. */ uint16_t iSegDef = 1; /* Start counting at 1. */ pShdr = &pElfStuff->paShdrs[1]; for (Elf64_Half i = 1; i < cSections; i++, pShdr++) { if (pThis->paSegments[i].iSegNm == UINT16_MAX) continue; uint8_t bSegAttr = 0; /* The A field. */ switch (pShdr->sh_addralign) { case 0: case 1: bSegAttr |= 1 << 5; break; case 2: bSegAttr |= 2 << 5; break; case 4: bSegAttr |= 5 << 5; break; case 8: case 16: bSegAttr |= 3 << 5; break; case 32: case 64: case 128: case 256: bSegAttr |= 4 << 5; break; default: bSegAttr |= 6 << 5; /* page aligned, pharlabs extension. */ break; } /* The C field. */ bSegAttr |= 2 << 2; /* public */ /* The B field. We don't have 4GB segments, so leave it as zero. */ /* The D field shall be set as we're doing USE32. */ bSegAttr |= 1; /* Done. */ if (!omfWriter_SegDef(pThis, bSegAttr, (uint32_t)pShdr->sh_size, pThis->paSegments[i].iSegNm, pThis->paSegments[i].iClassNm)) return false; pThis->paSegments[i].iSegDef = iSegDef++; } /* * Flat group definition (#1) - special, no members. */ uint16_t iGrpDef = 1; if ( !omfWriter_GrpDefBegin(pThis, idxGrpFlat) || !omfWriter_GrpDefEnd(pThis)) return false; for (uint16_t i = 0; i < cSections; i++) if (pThis->paSegments[i].iGrpNm == idxGrpFlat) pThis->paSegments[i].iGrpDef = iGrpDef; pThis->idxGrpFlat = iGrpDef++; /* * Data group definition (#2). */ /** @todo do we need to consider missing segments and ordering? */ uint16_t cGrpNms = 0; uint16_t aiGrpNms[2] = { 0, 0 }; /* Shut up, GCC. */ if (fHaveData) aiGrpNms[cGrpNms++] = idxGrpData; for (uint32_t iGrpNm = 0; iGrpNm < cGrpNms; iGrpNm++) { if (!omfWriter_GrpDefBegin(pThis, aiGrpNms[iGrpNm])) return false; for (uint16_t i = 0; i < cSections; i++) if (pThis->paSegments[i].iGrpNm == aiGrpNms[iGrpNm]) { pThis->paSegments[i].iGrpDef = iGrpDef; if (!omfWriter_GrpDefAddSegDef(pThis, pThis->paSegments[i].iSegDef)) return false; } if (!omfWriter_GrpDefEnd(pThis)) return false; iGrpDef++; } return true; } static bool convertElfSymbolsToPubDefsAndExtDefs(POMFWRITER pThis, PCELFDETAILS pElfStuff) { if (!pElfStuff->cSymbols) return true; /* * Process the symbols the first. */ uint32_t cAbsSyms = 0; uint32_t cExtSyms = 0; uint32_t cPubSyms = 0; for (uint32_t iSeg = 0; iSeg < pThis->cSegments; iSeg++) pThis->paSegments[iSeg].cPubDefs = 0; uint32_t const cSections = pElfStuff->pEhdr->e_shnum; uint32_t const cSymbols = pElfStuff->cSymbols; Elf64_Sym const * const paSymbols = pElfStuff->paSymbols; for (uint32_t iSym = 0; iSym < cSymbols; iSym++) { const uint8_t bBind = ELF64_ST_BIND(paSymbols[iSym].st_info); const uint8_t bType = ELF64_ST_TYPE(paSymbols[iSym].st_info); const char *pszSymName = &pElfStuff->pchStrTab[paSymbols[iSym].st_name]; if ( *pszSymName == '\0' && bType == STT_SECTION && paSymbols[iSym].st_shndx < cSections) pszSymName = &pElfStuff->pchShStrTab[pElfStuff->paShdrs[paSymbols[iSym].st_shndx].sh_name]; pThis->paSymbols[iSym].enmType = OMFSYMTYPE_IGNORED; pThis->paSymbols[iSym].idx = UINT16_MAX; pThis->paSymbols[iSym].idxSegDef = UINT16_MAX; pThis->paSymbols[iSym].idxGrpDef = UINT16_MAX; uint32_t const idxSection = paSymbols[iSym].st_shndx; if (idxSection == SHN_UNDEF) { if (bBind == STB_GLOBAL) { pThis->paSymbols[iSym].enmType = OMFSYMTYPE_EXTDEF; cExtSyms++; if (*pszSymName == '\0') return error(pThis->pszSrc, "External symbol #%u (%s) has an empty name.\n", iSym, pszSymName); } else if (bBind != STB_LOCAL || iSym != 0) /* Entry zero is usually a dummy. */ return error(pThis->pszSrc, "Unsupported or invalid bind type %#x for undefined symbol #%u (%s)\n", bBind, iSym, pszSymName); } else if (idxSection < cSections) { pThis->paSymbols[iSym].idxSegDef = pThis->paSegments[idxSection].iSegDef; pThis->paSymbols[iSym].idxGrpDef = pThis->paSegments[idxSection].iGrpDef; if (bBind == STB_GLOBAL) { pThis->paSymbols[iSym].enmType = OMFSYMTYPE_PUBDEF; pThis->paSegments[idxSection].cPubDefs++; cPubSyms++; if (bType == STT_SECTION) return error(pThis->pszSrc, "Don't know how to export STT_SECTION symbol #%u (%s)\n", iSym, pszSymName); if (*pszSymName == '\0') return error(pThis->pszSrc, "Public symbol #%u (%s) has an empty name.\n", iSym, pszSymName); } else if (bType == STT_SECTION) pThis->paSymbols[iSym].enmType = OMFSYMTYPE_SEGDEF; else pThis->paSymbols[iSym].enmType = OMFSYMTYPE_INTERNAL; } else if (idxSection == SHN_ABS) { if (bType != STT_FILE) { if (bBind == STB_GLOBAL) { pThis->paSymbols[iSym].enmType = OMFSYMTYPE_PUBDEF; pThis->paSymbols[iSym].idxSegDef = 0; pThis->paSymbols[iSym].idxGrpDef = 0; cAbsSyms++; if (*pszSymName == '\0') return error(pThis->pszSrc, "Public absolute symbol #%u (%s) has an empty name.\n", iSym, pszSymName); } else return error(pThis->pszSrc, "Unsupported or invalid bind type %#x for absolute symbol #%u (%s)\n", bBind, iSym, pszSymName); } } else if (idxSection == SHN_COMMON) return error(pThis->pszSrc, "Symbol #%u (%s) is in the unsupported 'common' section.\n", iSym, pszSymName); else return error(pThis->pszSrc, "Unsupported or invalid section number %#x for symbol #%u (%s)\n", idxSection, iSym, pszSymName); } /* * Emit the PUBDEFs the first time around (see order of records in TIS spec). */ uint16_t idxPubDef = 1; if (cPubSyms) { for (uint32_t iSeg = 0; iSeg < pThis->cSegments; iSeg++) if (pThis->paSegments[iSeg].cPubDefs > 0) { uint16_t const idxSegDef = pThis->paSegments[iSeg].iSegDef; if (!omfWriter_PubDefBegin(pThis, pThis->paSegments[iSeg].iGrpDef, idxSegDef)) return false; for (uint16_t iSym = 0; iSym < cSymbols; iSym++) if ( pThis->paSymbols[iSym].idxSegDef == idxSegDef && pThis->paSymbols[iSym].enmType == OMFSYMTYPE_PUBDEF) { /* Underscore prefix all names not already underscored/mangled. */ const char *pszName = &pElfStuff->pchStrTab[paSymbols[iSym].st_name]; if (!omfWriter_PubDefAdd(pThis, paSymbols[iSym].st_value, pszName, pszName[0] != '_')) return false; pThis->paSymbols[iSym].idx = idxPubDef++; } if (!omfWriter_PubDefEnd(pThis)) return false; } } if (cAbsSyms > 0) { if (!omfWriter_PubDefBegin(pThis, 0, 0)) return false; for (uint16_t iSym = 0; iSym < cSymbols; iSym++) if ( pThis->paSymbols[iSym].idxSegDef == 0 && pThis->paSymbols[iSym].enmType == OMFSYMTYPE_PUBDEF) { /* Underscore prefix all names not already underscored/mangled. */ const char *pszName = &pElfStuff->pchStrTab[paSymbols[iSym].st_name]; if (!omfWriter_PubDefAdd(pThis, paSymbols[iSym].st_value, pszName, pszName[0] != '_')) return false; pThis->paSymbols[iSym].idx = idxPubDef++; } if (!omfWriter_PubDefEnd(pThis)) return false; } /* * Go over the symbol table and emit external definition records. */ if (!omfWriter_ExtDefBegin(pThis)) return false; uint16_t idxExtDef = 1; for (uint16_t iSym = 0; iSym < cSymbols; iSym++) if (pThis->paSymbols[iSym].enmType == OMFSYMTYPE_EXTDEF) { /* Underscore prefix all names not already underscored/mangled. */ const char *pszName = &pElfStuff->pchStrTab[paSymbols[iSym].st_name]; if (!omfWriter_ExtDefAdd(pThis, pszName, *pszName != '_')) return false; pThis->paSymbols[iSym].idx = idxExtDef++; } if (!omfWriter_ExtDefEnd(pThis)) return false; return true; } /** * @callback_method_impl{FNRTSORTCMP, For Elf64_Rela tables.} */ static DECLCALLBACK(int) convertElfCompareRelA(void const *pvElement1, void const *pvElement2, void *pvUser) { Elf64_Rela const *pReloc1 = (Elf64_Rela const *)pvElement1; Elf64_Rela const *pReloc2 = (Elf64_Rela const *)pvElement2; if (pReloc1->r_offset < pReloc2->r_offset) return -1; if (pReloc1->r_offset > pReloc2->r_offset) return 1; RT_NOREF_PV(pvUser); return 0; } static bool convertElfSectionsToLeDataAndFixupps(POMFWRITER pThis, PCELFDETAILS pElfStuff, uint8_t const *pbFile, size_t cbFile) { Elf64_Sym const *paSymbols = pElfStuff->paSymbols; Elf64_Shdr const *paShdrs = pElfStuff->paShdrs; bool fRet = true; RT_NOREF_PV(cbFile); for (uint32_t i = 1; i < pThis->cSegments; i++) { if (pThis->paSegments[i].iSegDef == UINT16_MAX) continue; const char *pszSegNm = &pElfStuff->pchShStrTab[paShdrs[i].sh_name]; bool const fRelocs = i + 1 < pThis->cSegments && paShdrs[i + 1].sh_type == SHT_RELA; uint32_t cRelocs = fRelocs ? paShdrs[i + 1].sh_size / sizeof(Elf64_Rela) : 0; Elf64_Rela const *paRelocs = fRelocs ? (Elf64_Rela *)&pbFile[paShdrs[i + 1].sh_offset] : NULL; Elf64_Xword cbVirtData = paShdrs[i].sh_size; Elf64_Xword cbData = paShdrs[i].sh_type == SHT_NOBITS ? 0 : cbVirtData; uint8_t const *pbData = &pbFile[paShdrs[i].sh_offset]; uint32_t off = 0; /* We sort fixups by r_offset in order to more easily split them into chunks. */ RTSortShell((void *)paRelocs, cRelocs, sizeof(paRelocs[0]), convertElfCompareRelA, NULL); /* The OMF record size requires us to split larger sections up. To make life simple, we fill zeros for unitialized (BSS) stuff. */ const uint32_t cbMaxData = RT_MIN(OMF_MAX_RECORD_PAYLOAD - 1 - (pThis->paSegments[i].iSegDef >= 128) - 4 - 1, _1K); while (cbVirtData > 0) { /* Figure out how many bytes to put out in this chunk. Must make sure fixups doesn't cross chunk boundraries. ASSUMES sorted relocs. */ uint32_t cChunkRelocs = cRelocs; uint32_t cbChunk = cbVirtData; uint32_t offEnd = off + cbChunk; if (cbChunk > cbMaxData) { cbChunk = cbMaxData; offEnd = off + cbChunk; cChunkRelocs = 0; /* Quickly determin the reloc range. */ while ( cChunkRelocs < cRelocs && paRelocs[cChunkRelocs].r_offset < offEnd) cChunkRelocs++; /* Ensure final reloc doesn't go beyond chunk. */ while ( cChunkRelocs > 0 && paRelocs[cChunkRelocs - 1].r_offset + ELF_AMD64_RELOC_SIZE(ELF64_R_TYPE(paRelocs[cChunkRelocs - 1].r_info)) > offEnd) { uint32_t cbDrop = offEnd - paRelocs[cChunkRelocs - 1].r_offset; cbChunk -= cbDrop; offEnd -= cbDrop; cChunkRelocs--; } if (!cbVirtData) return error(pThis->pszSrc, "Wtf? cbVirtData is zero!\n"); } if (g_cVerbose >= 2) printf("debug: LEDATA off=%#x cb=%#x cRelocs=%#x sect=#%u segdef=%#x grpdef=%#x '%s'\n", off, cbChunk, cRelocs, i, pThis->paSegments[i].iSegDef, pThis->paSegments[i].iGrpDef, pszSegNm); /* * We stash the bytes into the OMF writer record buffer, receiving a * pointer to the start of it so we can make adjustments if necessary. */ uint8_t *pbCopy; if (!omfWriter_LEDataBeginEx(pThis, pThis->paSegments[i].iSegDef, off, cbChunk, cbData, pbData, &pbCopy)) return false; /* * Convert fiuxps. */ for (uint32_t iReloc = 0; iReloc < cChunkRelocs; iReloc++) { /* Get the OMF and ELF data for the symbol the reloc references. */ uint32_t const uType = ELF64_R_TYPE(paRelocs[iReloc].r_info); uint32_t const iSymbol = ELF64_R_SYM(paRelocs[iReloc].r_info); Elf64_Sym const * const pElfSym = &paSymbols[iSymbol]; POMFSYMBOL const pOmfSym = &pThis->paSymbols[iSymbol]; const char * const pszSymName = &pElfStuff->pchStrTab[pElfSym->st_name]; /* Calc fixup location in the pending chunk and setup a flexible pointer to it. */ uint16_t offDataRec = (uint16_t)(paRelocs[iReloc].r_offset - off); RTPTRUNION uLoc; uLoc.pu8 = &pbCopy[offDataRec]; /* OMF fixup data initialized with typical defaults. */ bool fSelfRel = true; uint8_t bLocation = OMF_FIX_LOC_32BIT_OFFSET; uint8_t bFrame = OMF_FIX_F_GRPDEF; uint16_t idxFrame = pThis->idxGrpFlat; uint8_t bTarget; uint16_t idxTarget; bool fTargetDisp; uint32_t offTargetDisp; switch (pOmfSym->enmType) { case OMFSYMTYPE_INTERNAL: case OMFSYMTYPE_PUBDEF: bTarget = OMF_FIX_T_SEGDEF; idxTarget = pOmfSym->idxSegDef; fTargetDisp = true; offTargetDisp = pElfSym->st_value; break; case OMFSYMTYPE_SEGDEF: bTarget = OMF_FIX_T_SEGDEF_NO_DISP; idxTarget = pOmfSym->idxSegDef; fTargetDisp = false; offTargetDisp = 0; break; case OMFSYMTYPE_EXTDEF: bTarget = OMF_FIX_T_EXTDEF_NO_DISP; idxTarget = pOmfSym->idx; fTargetDisp = false; offTargetDisp = 0; break; default: return error(pThis->pszSrc, "Relocation in segment #%u '%s' references ignored or invalid symbol (%s)\n", i, pszSegNm, pszSymName); } /* Do COFF relocation type conversion. */ switch (uType) { case R_X86_64_64: { int64_t iAddend = paRelocs[iReloc].r_addend; if (iAddend > _1G || iAddend < -_1G) fRet = error(pThis->pszSrc, "R_X86_64_64 with large addend (%" ELF_FMT_D64 ") at %#x in segment #%u '%s'\n", iAddend, paRelocs[iReloc].r_offset, i, pszSegNm); *uLoc.pu64 = iAddend; fSelfRel = false; break; } case R_X86_64_32: case R_X86_64_32S: /* signed, unsigned, whatever. */ fSelfRel = false; RT_FALL_THRU(); case R_X86_64_PC32: case R_X86_64_PLT32: /* binutils commit 451875b4f976a527395e9303224c7881b65e12ed feature/regression. */ { /* defaults are ok, just handle the addend. */ int32_t iAddend = paRelocs[iReloc].r_addend; if (iAddend != paRelocs[iReloc].r_addend) fRet = error(pThis->pszSrc, "R_X86_64_PC32 with large addend (%d) at %#x in segment #%u '%s'\n", iAddend, paRelocs[iReloc].r_offset, i, pszSegNm); if (fSelfRel) *uLoc.pu32 = iAddend + 4; else *uLoc.pu32 = iAddend; break; } case R_X86_64_NONE: continue; /* Ignore this one */ case R_X86_64_GOT32: case R_X86_64_COPY: case R_X86_64_GLOB_DAT: case R_X86_64_JMP_SLOT: case R_X86_64_RELATIVE: case R_X86_64_GOTPCREL: case R_X86_64_16: case R_X86_64_PC16: case R_X86_64_8: case R_X86_64_PC8: case R_X86_64_DTPMOD64: case R_X86_64_DTPOFF64: case R_X86_64_TPOFF64: case R_X86_64_TLSGD: case R_X86_64_TLSLD: case R_X86_64_DTPOFF32: case R_X86_64_GOTTPOFF: case R_X86_64_TPOFF32: default: return error(pThis->pszSrc, "Unsupported fixup type %#x (%s) at rva=%#x in section #%u '%s' against '%s'\n", uType, g_apszElfAmd64RelTypes[uType], paRelocs[iReloc].r_offset, i, pszSegNm, pszSymName); } /* Add the fixup. */ if (idxFrame == UINT16_MAX) error(pThis->pszSrc, "idxFrame=UINT16_MAX for %s type=%s\n", pszSymName, g_apszElfAmd64RelTypes[uType]); fRet = omfWriter_LEDataAddFixup(pThis, offDataRec, fSelfRel, bLocation, bFrame, idxFrame, bTarget, idxTarget, fTargetDisp, offTargetDisp) && fRet; } /* * Write the LEDATA and associated FIXUPPs. */ if (!omfWriter_LEDataEnd(pThis)) return false; /* * Advance. */ paRelocs += cChunkRelocs; cRelocs -= cChunkRelocs; if (cbData > cbChunk) { cbData -= cbChunk; pbData += cbChunk; } else cbData = 0; off += cbChunk; cbVirtData -= cbChunk; } } return fRet; } static bool convertElfToOmf(const char *pszFile, uint8_t const *pbFile, size_t cbFile, FILE *pDst) { /* * Validate the source file a little. */ ELFDETAILS ElfStuff; if (!validateElf(pszFile, pbFile, cbFile, &ElfStuff)) return false; /* * Instantiate the OMF writer. */ POMFWRITER pThis = omfWriter_Create(pszFile, ElfStuff.pEhdr->e_shnum, ElfStuff.cSymbols, pDst); if (!pThis) return false; /* * Write the OMF object file. */ if (omfWriter_BeginModule(pThis, pszFile)) { if ( convertElfSectionsToSegDefsAndGrpDefs(pThis, &ElfStuff) && convertElfSymbolsToPubDefsAndExtDefs(pThis, &ElfStuff) && omfWriter_LinkPassSeparator(pThis) && convertElfSectionsToLeDataAndFixupps(pThis, &ElfStuff, pbFile, cbFile) && omfWriter_EndModule(pThis) ) { omfWriter_Destroy(pThis); return true; } } omfWriter_Destroy(pThis); return false; } /********************************************************************************************************************************* * COFF -> OMF Converter * *********************************************************************************************************************************/ /** AMD64 relocation type names for (Microsoft) COFF. */ static const char * const g_apszCoffAmd64RelTypes[] = { "ABSOLUTE", "ADDR64", "ADDR32", "ADDR32NB", "REL32", "REL32_1", "REL32_2", "REL32_3", "REL32_4", "REL32_5", "SECTION", "SECREL", "SECREL7", "TOKEN", "SREL32", "PAIR", "SSPAN32" }; /** AMD64 relocation type sizes for (Microsoft) COFF. */ static uint8_t const g_acbCoffAmd64RelTypes[] = { 8, /* ABSOLUTE */ 8, /* ADDR64 */ 4, /* ADDR32 */ 4, /* ADDR32NB */ 4, /* REL32 */ 4, /* REL32_1 */ 4, /* REL32_2 */ 4, /* REL32_3 */ 4, /* REL32_4 */ 4, /* REL32_5 */ 2, /* SECTION */ 4, /* SECREL */ 1, /* SECREL7 */ 0, /* TOKEN */ 4, /* SREL32 */ 0, /* PAIR */ 4, /* SSPAN32 */ }; /** Macro for getting the size of a AMD64 COFF relocation. */ #define COFF_AMD64_RELOC_SIZE(a_Type) ( (a_Type) < RT_ELEMENTS(g_acbCoffAmd64RelTypes) ? g_acbCoffAmd64RelTypes[(a_Type)] : 1) static const char *coffGetSymbolName(PCIMAGE_SYMBOL pSym, const char *pchStrTab, uint32_t cbStrTab, char pszShortName[16]) { if (pSym->N.Name.Short != 0) { memcpy(pszShortName, pSym->N.ShortName, 8); pszShortName[8] = '\0'; return pszShortName; } if (pSym->N.Name.Long < cbStrTab) { uint32_t const cbLeft = cbStrTab - pSym->N.Name.Long; const char *pszRet = pchStrTab + pSym->N.Name.Long; if (memchr(pszRet, '\0', cbLeft) != NULL) return pszRet; } error("", "Invalid string table index %#x!\n", pSym->N.Name.Long); return "Invalid Symbol Table Entry"; } static bool validateCoff(const char *pszFile, uint8_t const *pbFile, size_t cbFile) { /* * Validate the header and our other expectations. */ PIMAGE_FILE_HEADER pHdr = (PIMAGE_FILE_HEADER)pbFile; if (pHdr->Machine != IMAGE_FILE_MACHINE_AMD64) return error(pszFile, "Expected IMAGE_FILE_MACHINE_AMD64 not %#x\n", pHdr->Machine); if (pHdr->SizeOfOptionalHeader != 0) return error(pszFile, "Expected SizeOfOptionalHeader to be zero, not %#x\n", pHdr->SizeOfOptionalHeader); if (pHdr->NumberOfSections == 0) return error(pszFile, "Expected NumberOfSections to be non-zero\n"); uint32_t const cbHeaders = pHdr->NumberOfSections * sizeof(IMAGE_SECTION_HEADER) + sizeof(*pHdr); if (cbHeaders > cbFile) return error(pszFile, "Section table goes beyond the end of the of the file (cSections=%#x)\n", pHdr->NumberOfSections); if (pHdr->NumberOfSymbols) { if ( pHdr->PointerToSymbolTable >= cbFile || pHdr->NumberOfSymbols * (uint64_t)IMAGE_SIZE_OF_SYMBOL > cbFile) return error(pszFile, "Symbol table goes beyond the end of the of the file (cSyms=%#x, offFile=%#x)\n", pHdr->NumberOfSymbols, pHdr->PointerToSymbolTable); } return true; } static bool convertCoffSectionsToSegDefsAndGrpDefs(POMFWRITER pThis, PCIMAGE_SECTION_HEADER paShdrs, uint16_t cSections) { /* * Do the list of names pass. */ uint16_t idxGrpFlat, idxGrpData; uint16_t idxClassCode, idxClassData, idxClassDebugSymbols, idxClassDebugTypes; if ( !omfWriter_LNamesBegin(pThis, true /*fAddZeroEntry*/) || !omfWriter_LNamesAddN(pThis, RT_STR_TUPLE("FLAT"), &idxGrpFlat) || !omfWriter_LNamesAddN(pThis, RT_STR_TUPLE("BS3DATA64_GROUP"), &idxGrpData) || !omfWriter_LNamesAddN(pThis, RT_STR_TUPLE("BS3CLASS64CODE"), &idxClassCode) || !omfWriter_LNamesAddN(pThis, RT_STR_TUPLE("FAR_DATA"), &idxClassData) || !omfWriter_LNamesAddN(pThis, RT_STR_TUPLE("DEBSYM"), &idxClassDebugSymbols) || !omfWriter_LNamesAddN(pThis, RT_STR_TUPLE("DEBTYP"), &idxClassDebugTypes) ) return false; bool fHaveData = false; for (uint16_t i = 0; i < cSections; i++) { /* Copy the name and terminate it. */ char szName[32]; memcpy(szName, paShdrs[i].Name, sizeof(paShdrs[i].Name)); unsigned cchName = sizeof(paShdrs[i].Name); while (cchName > 0 && RT_C_IS_SPACE(szName[cchName - 1])) cchName--; if (cchName == 0) return error(pThis->pszSrc, "Section #%u has an empty name!\n", i); szName[cchName] = '\0'; if ( (paShdrs[i].Characteristics & (IMAGE_SCN_LNK_REMOVE | IMAGE_SCN_LNK_INFO)) || strcmp(szName, ".pdata") == 0 /* Exception stuff, I think, so discard it. */ || strcmp(szName, ".xdata") == 0 /* Ditto. */ ) { pThis->paSegments[i].iSegDef = UINT16_MAX; pThis->paSegments[i].iGrpDef = UINT16_MAX; pThis->paSegments[i].iSegNm = UINT16_MAX; pThis->paSegments[i].iGrpNm = UINT16_MAX; pThis->paSegments[i].iClassNm = UINT16_MAX; pThis->paSegments[i].pszName = NULL; } else { /* Translate the name, group and class. */ if ( strcmp(szName, ".text") == 0 || strcmp(szName, ".text$mn") == 0 /* Seen first in VC++ 14.1 (could be older). */) { strcpy(szName, "BS3TEXT64"); pThis->paSegments[i].iGrpNm = idxGrpFlat; pThis->paSegments[i].iClassNm = idxClassCode; } else if (strcmp(szName, ".data") == 0) { strcpy(szName, "BS3DATA64"); pThis->paSegments[i].iGrpNm = idxGrpData; pThis->paSegments[i].iClassNm = idxClassData; } else if (strcmp(szName, ".bss") == 0) { strcpy(szName, "BS3BSS64"); pThis->paSegments[i].iGrpNm = idxGrpData; pThis->paSegments[i].iClassNm = idxClassData; } else if (strcmp(szName, ".rdata") == 0) { strcpy(szName, "BS3DATA64CONST"); pThis->paSegments[i].iGrpNm = idxGrpData; pThis->paSegments[i].iClassNm = idxClassData; } else if (strcmp(szName, ".debug$S") == 0) { strcpy(szName, "$$SYMBOLS"); pThis->paSegments[i].iGrpNm = UINT16_MAX; pThis->paSegments[i].iClassNm = idxClassDebugSymbols; } else if (strcmp(szName, ".debug$T") == 0) { strcpy(szName, "$$TYPES"); pThis->paSegments[i].iGrpNm = UINT16_MAX; pThis->paSegments[i].iClassNm = idxClassDebugTypes; } else if (paShdrs[i].Characteristics & (IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_CNT_CODE)) { pThis->paSegments[i].iGrpNm = idxGrpFlat; pThis->paSegments[i].iClassNm = idxClassCode; error(pThis->pszSrc, "Unknown code segment: '%s'\n", szName); } else { pThis->paSegments[i].iGrpNm = idxGrpData; pThis->paSegments[i].iClassNm = idxClassData; error(pThis->pszSrc, "Unknown data (?) segment: '%s'\n", szName); } /* Save the name. */ pThis->paSegments[i].pszName = strdup(szName); if (!pThis->paSegments[i].pszName) return error(pThis->pszSrc, "Out of memory!\n"); /* Add the section name. */ if (!omfWriter_LNamesAdd(pThis, pThis->paSegments[i].pszName, &pThis->paSegments[i].iSegNm)) return false; fHaveData |= pThis->paSegments[i].iGrpNm == idxGrpData; } } if (!omfWriter_LNamesEnd(pThis)) return false; /* * Emit segment definitions. */ uint16_t iSegDef = 1; /* Start counting at 1. */ for (uint16_t i = 0; i < cSections; i++) { if (pThis->paSegments[i].iSegDef == UINT16_MAX) continue; uint8_t bSegAttr = 0; /* The A field. */ switch (paShdrs[i].Characteristics & IMAGE_SCN_ALIGN_MASK) { default: case IMAGE_SCN_ALIGN_1BYTES: bSegAttr |= 1 << 5; break; case IMAGE_SCN_ALIGN_2BYTES: bSegAttr |= 2 << 5; break; case IMAGE_SCN_ALIGN_4BYTES: bSegAttr |= 5 << 5; break; case IMAGE_SCN_ALIGN_8BYTES: case IMAGE_SCN_ALIGN_16BYTES: bSegAttr |= 3 << 5; break; case IMAGE_SCN_ALIGN_32BYTES: case IMAGE_SCN_ALIGN_64BYTES: case IMAGE_SCN_ALIGN_128BYTES: case IMAGE_SCN_ALIGN_256BYTES: bSegAttr |= 4 << 5; break; case IMAGE_SCN_ALIGN_512BYTES: case IMAGE_SCN_ALIGN_1024BYTES: case IMAGE_SCN_ALIGN_2048BYTES: case IMAGE_SCN_ALIGN_4096BYTES: case IMAGE_SCN_ALIGN_8192BYTES: bSegAttr |= 6 << 5; /* page aligned, pharlabs extension. */ break; } /* The C field. */ bSegAttr |= 2 << 2; /* public */ /* The B field. We don't have 4GB segments, so leave it as zero. */ /* The D field shall be set as we're doing USE32. */ bSegAttr |= 1; /* Done. */ if (!omfWriter_SegDef(pThis, bSegAttr, paShdrs[i].SizeOfRawData, pThis->paSegments[i].iSegNm, pThis->paSegments[i].iClassNm)) return false; pThis->paSegments[i].iSegDef = iSegDef++; } /* * Flat group definition (#1) - special, no members. */ uint16_t iGrpDef = 1; if ( !omfWriter_GrpDefBegin(pThis, idxGrpFlat) || !omfWriter_GrpDefEnd(pThis)) return false; for (uint16_t i = 0; i < cSections; i++) if (pThis->paSegments[i].iGrpNm == idxGrpFlat) pThis->paSegments[i].iGrpDef = iGrpDef; pThis->idxGrpFlat = iGrpDef++; /* * Data group definition (#2). */ /** @todo do we need to consider missing segments and ordering? */ uint16_t cGrpNms = 0; uint16_t aiGrpNms[2] = { 0, 0 }; /* Shut up, GCC. */ if (fHaveData) aiGrpNms[cGrpNms++] = idxGrpData; for (uint32_t iGrpNm = 0; iGrpNm < cGrpNms; iGrpNm++) { if (!omfWriter_GrpDefBegin(pThis, aiGrpNms[iGrpNm])) return false; for (uint16_t i = 0; i < cSections; i++) if (pThis->paSegments[i].iGrpNm == aiGrpNms[iGrpNm]) { pThis->paSegments[i].iGrpDef = iGrpDef; if (!omfWriter_GrpDefAddSegDef(pThis, pThis->paSegments[i].iSegDef)) return false; } if (!omfWriter_GrpDefEnd(pThis)) return false; iGrpDef++; } return true; } /** * This is for matching STATIC symbols with value 0 against the section name, * to see if it's a section reference or symbol at offset 0 reference. * * @returns true / false. * @param pszSymbol The symbol name. * @param pachSectName8 The section name (8-bytes). */ static bool isCoffSymbolMatchingSectionName(const char *pszSymbol, uint8_t const pachSectName8[8]) { uint32_t off = 0; char ch; while (off < 8 && (ch = pszSymbol[off]) != '\0') { if (ch != pachSectName8[off]) return false; off++; } while (off < 8) { if (!RT_C_IS_SPACE((ch = pachSectName8[off]))) return ch == '\0'; off++; } return true; } static bool convertCoffSymbolsToPubDefsAndExtDefs(POMFWRITER pThis, PCIMAGE_SYMBOL paSymbols, uint16_t cSymbols, const char *pchStrTab, PCIMAGE_SECTION_HEADER paShdrs) { if (!cSymbols) return true; uint32_t const cbStrTab = *(uint32_t const *)pchStrTab; char szShort[16]; /* * Process the symbols the first. */ uint32_t iSymImageBase = UINT32_MAX; uint32_t cAbsSyms = 0; uint32_t cExtSyms = 0; uint32_t cPubSyms = 0; for (uint32_t iSeg = 0; iSeg < pThis->cSegments; iSeg++) pThis->paSegments[iSeg].cPubDefs = 0; for (uint16_t iSym = 0; iSym < cSymbols; iSym++) { const char *pszSymName = coffGetSymbolName(&paSymbols[iSym], pchStrTab, cbStrTab, szShort); pThis->paSymbols[iSym].enmType = OMFSYMTYPE_IGNORED; pThis->paSymbols[iSym].idx = UINT16_MAX; pThis->paSymbols[iSym].idxSegDef = UINT16_MAX; pThis->paSymbols[iSym].idxGrpDef = UINT16_MAX; int16_t const idxSection = paSymbols[iSym].SectionNumber; if ( (idxSection >= 1 && idxSection <= (int32_t)pThis->cSegments) || idxSection == IMAGE_SYM_ABSOLUTE) { switch (paSymbols[iSym].StorageClass) { case IMAGE_SYM_CLASS_EXTERNAL: if (idxSection != IMAGE_SYM_ABSOLUTE) { if (pThis->paSegments[idxSection - 1].iSegDef != UINT16_MAX) { pThis->paSymbols[iSym].enmType = OMFSYMTYPE_PUBDEF; pThis->paSymbols[iSym].idxSegDef = pThis->paSegments[idxSection - 1].iSegDef; pThis->paSymbols[iSym].idxGrpDef = pThis->paSegments[idxSection - 1].iGrpDef; pThis->paSegments[idxSection - 1].cPubDefs++; cPubSyms++; } } else { pThis->paSymbols[iSym].enmType = OMFSYMTYPE_PUBDEF; pThis->paSymbols[iSym].idxSegDef = 0; pThis->paSymbols[iSym].idxGrpDef = 0; cAbsSyms++; } break; case IMAGE_SYM_CLASS_STATIC: if ( paSymbols[iSym].Value == 0 && idxSection != IMAGE_SYM_ABSOLUTE && isCoffSymbolMatchingSectionName(pszSymName, paShdrs[idxSection - 1].Name) ) { pThis->paSymbols[iSym].enmType = OMFSYMTYPE_SEGDEF; pThis->paSymbols[iSym].idxSegDef = pThis->paSegments[idxSection - 1].iSegDef; pThis->paSymbols[iSym].idxGrpDef = pThis->paSegments[idxSection - 1].iGrpDef; break; } RT_FALL_THRU(); case IMAGE_SYM_CLASS_END_OF_FUNCTION: case IMAGE_SYM_CLASS_AUTOMATIC: case IMAGE_SYM_CLASS_REGISTER: case IMAGE_SYM_CLASS_LABEL: case IMAGE_SYM_CLASS_MEMBER_OF_STRUCT: case IMAGE_SYM_CLASS_ARGUMENT: case IMAGE_SYM_CLASS_STRUCT_TAG: case IMAGE_SYM_CLASS_MEMBER_OF_UNION: case IMAGE_SYM_CLASS_UNION_TAG: case IMAGE_SYM_CLASS_TYPE_DEFINITION: case IMAGE_SYM_CLASS_ENUM_TAG: case IMAGE_SYM_CLASS_MEMBER_OF_ENUM: case IMAGE_SYM_CLASS_REGISTER_PARAM: case IMAGE_SYM_CLASS_BIT_FIELD: case IMAGE_SYM_CLASS_BLOCK: case IMAGE_SYM_CLASS_FUNCTION: case IMAGE_SYM_CLASS_END_OF_STRUCT: case IMAGE_SYM_CLASS_FILE: pThis->paSymbols[iSym].enmType = OMFSYMTYPE_INTERNAL; if (idxSection != IMAGE_SYM_ABSOLUTE) { pThis->paSymbols[iSym].idxSegDef = pThis->paSegments[idxSection - 1].iSegDef; pThis->paSymbols[iSym].idxGrpDef = pThis->paSegments[idxSection - 1].iGrpDef; } else { pThis->paSymbols[iSym].idxSegDef = 0; pThis->paSymbols[iSym].idxGrpDef = 0; } break; case IMAGE_SYM_CLASS_SECTION: case IMAGE_SYM_CLASS_EXTERNAL_DEF: case IMAGE_SYM_CLASS_NULL: case IMAGE_SYM_CLASS_UNDEFINED_LABEL: case IMAGE_SYM_CLASS_UNDEFINED_STATIC: case IMAGE_SYM_CLASS_CLR_TOKEN: case IMAGE_SYM_CLASS_FAR_EXTERNAL: case IMAGE_SYM_CLASS_WEAK_EXTERNAL: return error(pThis->pszSrc, "Unsupported storage class value %#x for symbol #%u (%s)\n", paSymbols[iSym].StorageClass, iSym, pszSymName); default: return error(pThis->pszSrc, "Unknown storage class value %#x for symbol #%u (%s)\n", paSymbols[iSym].StorageClass, iSym, pszSymName); } } else if (idxSection == IMAGE_SYM_UNDEFINED) { if ( paSymbols[iSym].StorageClass == IMAGE_SYM_CLASS_EXTERNAL || paSymbols[iSym].StorageClass == IMAGE_SYM_CLASS_EXTERNAL_DEF) { pThis->paSymbols[iSym].enmType = OMFSYMTYPE_EXTDEF; cExtSyms++; if (iSymImageBase == UINT32_MAX && strcmp(pszSymName, "__ImageBase") == 0) iSymImageBase = iSym; } else return error(pThis->pszSrc, "Unknown/unknown storage class value %#x for undefined symbol #%u (%s)\n", paSymbols[iSym].StorageClass, iSym, pszSymName); } else if (idxSection != IMAGE_SYM_DEBUG) return error(pThis->pszSrc, "Invalid section number %#x for symbol #%u (%s)\n", idxSection, iSym, pszSymName); /* Skip AUX symbols. */ uint8_t cAuxSyms = paSymbols[iSym].NumberOfAuxSymbols; while (cAuxSyms-- > 0) { iSym++; pThis->paSymbols[iSym].enmType = OMFSYMTYPE_INVALID; pThis->paSymbols[iSym].idx = UINT16_MAX; } } /* * Emit the PUBDEFs the first time around (see order of records in TIS spec). */ uint16_t idxPubDef = 1; if (cPubSyms) { for (uint32_t iSeg = 0; iSeg < pThis->cSegments; iSeg++) if (pThis->paSegments[iSeg].cPubDefs > 0) { uint16_t const idxSegDef = pThis->paSegments[iSeg].iSegDef; if (!omfWriter_PubDefBegin(pThis, pThis->paSegments[iSeg].iGrpDef, idxSegDef)) return false; for (uint16_t iSym = 0; iSym < cSymbols; iSym++) if ( pThis->paSymbols[iSym].idxSegDef == idxSegDef && pThis->paSymbols[iSym].enmType == OMFSYMTYPE_PUBDEF) { /* Underscore prefix all symbols not already underscored or mangled. */ const char *pszName = coffGetSymbolName(&paSymbols[iSym], pchStrTab, cbStrTab, szShort); if (!omfWriter_PubDefAdd(pThis, paSymbols[iSym].Value, pszName, pszName[0] != '_' && pszName[0] != '?')) return false; pThis->paSymbols[iSym].idx = idxPubDef++; } if (!omfWriter_PubDefEnd(pThis)) return false; } } if (cAbsSyms > 0) { if (!omfWriter_PubDefBegin(pThis, 0, 0)) return false; for (uint16_t iSym = 0; iSym < cSymbols; iSym++) if ( pThis->paSymbols[iSym].idxSegDef == 0 && pThis->paSymbols[iSym].enmType == OMFSYMTYPE_PUBDEF) { /* Underscore prefix all symbols not already underscored or mangled. */ const char *pszName = coffGetSymbolName(&paSymbols[iSym], pchStrTab, cbStrTab, szShort); if (!omfWriter_PubDefAdd(pThis, paSymbols[iSym].Value, pszName, pszName[0] != '_' && pszName[0] != '?') ) return false; pThis->paSymbols[iSym].idx = idxPubDef++; } if (!omfWriter_PubDefEnd(pThis)) return false; } /* * Go over the symbol table and emit external definition records. */ if (!omfWriter_ExtDefBegin(pThis)) return false; uint16_t idxExtDef = 1; for (uint16_t iSym = 0; iSym < cSymbols; iSym++) if (pThis->paSymbols[iSym].enmType == OMFSYMTYPE_EXTDEF) { /* Underscore prefix all symbols not already underscored or mangled. */ const char *pszName = coffGetSymbolName(&paSymbols[iSym], pchStrTab, cbStrTab, szShort); if (!omfWriter_ExtDefAdd(pThis, pszName, pszName[0] != '_' && pszName[0] != '?')) return false; pThis->paSymbols[iSym].idx = idxExtDef++; } /* Always add an __ImageBase reference, in case we need it to deal with ADDR32NB fixups. */ /** @todo maybe we don't actually need this and could use FLAT instead? */ if (iSymImageBase != UINT32_MAX) pThis->idxExtImageBase = pThis->paSymbols[iSymImageBase].idx; else if (omfWriter_ExtDefAdd(pThis, "__ImageBase", false /*fPrependUnderscore*/)) pThis->idxExtImageBase = idxExtDef; else return false; if (!omfWriter_ExtDefEnd(pThis)) return false; return true; } static bool convertCoffSectionsToLeDataAndFixupps(POMFWRITER pThis, uint8_t const *pbFile, size_t cbFile, PCIMAGE_SECTION_HEADER paShdrs, uint16_t cSections, PCIMAGE_SYMBOL paSymbols, uint16_t cSymbols, const char *pchStrTab) { RT_NOREF_PV(cbFile); RT_NOREF_PV(cSections); RT_NOREF_PV(cSymbols); uint32_t const cbStrTab = *(uint32_t const *)pchStrTab; bool fRet = true; for (uint32_t i = 0; i < pThis->cSegments; i++) { if (pThis->paSegments[i].iSegDef == UINT16_MAX) continue; char szShortName[16]; const char *pszSegNm = pThis->paSegments[i].pszName; uint16_t cRelocs = paShdrs[i].NumberOfRelocations; PCIMAGE_RELOCATION paRelocs = (PCIMAGE_RELOCATION)&pbFile[paShdrs[i].PointerToRelocations]; uint32_t cbVirtData = paShdrs[i].SizeOfRawData; uint32_t cbData = paShdrs[i].Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA ? 0 : cbVirtData; uint8_t const *pbData = &pbFile[paShdrs[i].PointerToRawData]; uint32_t off = 0; /* Check that the relocations are sorted and within the section. */ for (uint32_t iReloc = 1; iReloc < cRelocs; iReloc++) if (paRelocs[iReloc - 1].u.VirtualAddress >= paRelocs[iReloc].u.VirtualAddress) return error(pThis->pszSrc, "Section #%u (%s) relocations aren't sorted\n", i, pszSegNm); if ( cRelocs > 0 && paRelocs[cRelocs - 1].u.VirtualAddress - paShdrs[i].VirtualAddress + COFF_AMD64_RELOC_SIZE(paRelocs[cRelocs - 1].Type) > cbVirtData) return error(pThis->pszSrc, "Section #%u (%s) relocations beyond section data! cbVirtData=%#x RvaFix=%#x RVASeg=%#x type=%#x\n", i, pszSegNm, cbVirtData, paRelocs[cRelocs - 1].u.VirtualAddress, paShdrs[i].VirtualAddress, paRelocs[cRelocs - 1].Type); /* The OMF record size requires us to split larger sections up. To make life simple, we fill zeros for unitialized (BSS) stuff. */ const uint32_t cbMaxData = RT_MIN(OMF_MAX_RECORD_PAYLOAD - 1 - (pThis->paSegments[i].iSegDef >= 128) - 4 - 1, _1K); while (cbVirtData > 0) { /* Figure out how many bytes to put out in this chunk. Must make sure fixups doesn't cross chunk boundraries. ASSUMES sorted relocs. */ uint32_t cChunkRelocs = cRelocs; uint32_t cbChunk = cbVirtData; uint32_t uRvaEnd = paShdrs[i].VirtualAddress + off + cbChunk; if (cbChunk > cbMaxData) { cbChunk = cbMaxData; uRvaEnd = paShdrs[i].VirtualAddress + off + cbChunk; cChunkRelocs = 0; /* Quickly determin the reloc range. */ while ( cChunkRelocs < cRelocs && paRelocs[cChunkRelocs].u.VirtualAddress < uRvaEnd) cChunkRelocs++; /* Ensure final reloc doesn't go beyond chunk. */ while ( cChunkRelocs > 0 && paRelocs[cChunkRelocs - 1].u.VirtualAddress + COFF_AMD64_RELOC_SIZE(paRelocs[cChunkRelocs - 1].Type) > uRvaEnd) { uint32_t cbDrop = uRvaEnd - paRelocs[cChunkRelocs - 1].u.VirtualAddress; cbChunk -= cbDrop; uRvaEnd -= cbDrop; cChunkRelocs--; } if (!cbVirtData) return error(pThis->pszSrc, "Wtf? cbVirtData is zero!\n"); } /* * We stash the bytes into the OMF writer record buffer, receiving a * pointer to the start of it so we can make adjustments if necessary. */ uint8_t *pbCopy; if (!omfWriter_LEDataBeginEx(pThis, pThis->paSegments[i].iSegDef, off, cbChunk, cbData, pbData, &pbCopy)) return false; /* * Convert fiuxps. */ uint32_t const uRvaChunk = paShdrs[i].VirtualAddress + off; for (uint32_t iReloc = 0; iReloc < cChunkRelocs; iReloc++) { /* Get the OMF and COFF data for the symbol the reloc references. */ if (paRelocs[iReloc].SymbolTableIndex >= pThis->cSymbols) return error(pThis->pszSrc, "Relocation symtab index (%#x) is out of range in segment #%u '%s'\n", paRelocs[iReloc].SymbolTableIndex, i, pszSegNm); PCIMAGE_SYMBOL pCoffSym = &paSymbols[paRelocs[iReloc].SymbolTableIndex]; POMFSYMBOL pOmfSym = &pThis->paSymbols[paRelocs[iReloc].SymbolTableIndex]; /* Calc fixup location in the pending chunk and setup a flexible pointer to it. */ uint16_t offDataRec = (uint16_t)(paRelocs[iReloc].u.VirtualAddress - uRvaChunk); RTPTRUNION uLoc; uLoc.pu8 = &pbCopy[offDataRec]; /* OMF fixup data initialized with typical defaults. */ bool fSelfRel = true; uint8_t bLocation = OMF_FIX_LOC_32BIT_OFFSET; uint8_t bFrame = OMF_FIX_F_GRPDEF; uint16_t idxFrame = pThis->idxGrpFlat; uint8_t bTarget; uint16_t idxTarget; bool fTargetDisp; uint32_t offTargetDisp; switch (pOmfSym->enmType) { case OMFSYMTYPE_INTERNAL: case OMFSYMTYPE_PUBDEF: bTarget = OMF_FIX_T_SEGDEF; idxTarget = pOmfSym->idxSegDef; fTargetDisp = true; offTargetDisp = pCoffSym->Value; break; case OMFSYMTYPE_SEGDEF: bTarget = OMF_FIX_T_SEGDEF_NO_DISP; idxTarget = pOmfSym->idxSegDef; fTargetDisp = false; offTargetDisp = 0; break; case OMFSYMTYPE_EXTDEF: bTarget = OMF_FIX_T_EXTDEF_NO_DISP; idxTarget = pOmfSym->idx; fTargetDisp = false; offTargetDisp = 0; break; default: return error(pThis->pszSrc, "Relocation in segment #%u '%s' references ignored or invalid symbol (%s)\n", i, pszSegNm, coffGetSymbolName(pCoffSym, pchStrTab, cbStrTab, szShortName)); } /* Do COFF relocation type conversion. */ switch (paRelocs[iReloc].Type) { case IMAGE_REL_AMD64_ADDR64: { uint64_t uAddend = *uLoc.pu64; if (uAddend > _1G) fRet = error(pThis->pszSrc, "ADDR64 with large addend (%#llx) at %#x in segment #%u '%s'\n", uAddend, paRelocs[iReloc].u.VirtualAddress, i, pszSegNm); fSelfRel = false; break; } case IMAGE_REL_AMD64_REL32_1: case IMAGE_REL_AMD64_REL32_2: case IMAGE_REL_AMD64_REL32_3: case IMAGE_REL_AMD64_REL32_4: case IMAGE_REL_AMD64_REL32_5: /** @todo Check whether OMF read addends from the data or relies on the * displacement. Also, check what it's relative to. */ *uLoc.pu32 -= paRelocs[iReloc].Type - IMAGE_REL_AMD64_REL32; break; case IMAGE_REL_AMD64_ADDR32: fSelfRel = false; break; case IMAGE_REL_AMD64_ADDR32NB: fSelfRel = false; bFrame = OMF_FIX_F_EXTDEF; idxFrame = pThis->idxExtImageBase; break; case IMAGE_REL_AMD64_REL32: /* defaults are ok. */ break; case IMAGE_REL_AMD64_SECTION: bLocation = OMF_FIX_LOC_16BIT_SEGMENT; RT_FALL_THRU(); case IMAGE_REL_AMD64_SECREL: fSelfRel = false; if (pOmfSym->enmType == OMFSYMTYPE_EXTDEF) { bFrame = OMF_FIX_F_EXTDEF; idxFrame = pOmfSym->idx; } else { bFrame = OMF_FIX_F_SEGDEF; idxFrame = pOmfSym->idxSegDef; } break; case IMAGE_REL_AMD64_ABSOLUTE: continue; /* Ignore it like the PECOFF.DOC says we should. */ case IMAGE_REL_AMD64_SECREL7: default: return error(pThis->pszSrc, "Unsupported fixup type %#x (%s) at rva=%#x in section #%u '%-8.8s'\n", paRelocs[iReloc].Type, paRelocs[iReloc].Type < RT_ELEMENTS(g_apszCoffAmd64RelTypes) ? g_apszCoffAmd64RelTypes[paRelocs[iReloc].Type] : "unknown", paRelocs[iReloc].u.VirtualAddress, i, paShdrs[i].Name); } /* Add the fixup. */ if (idxFrame == UINT16_MAX) error(pThis->pszSrc, "idxFrame=UINT16_MAX for %s type=%s\n", coffGetSymbolName(pCoffSym, pchStrTab, cbStrTab, szShortName), g_apszCoffAmd64RelTypes[paRelocs[iReloc].Type]); fRet = omfWriter_LEDataAddFixup(pThis, offDataRec, fSelfRel, bLocation, bFrame, idxFrame, bTarget, idxTarget, fTargetDisp, offTargetDisp) && fRet; } /* * Write the LEDATA and associated FIXUPPs. */ if (!omfWriter_LEDataEnd(pThis)) return false; /* * Advance. */ paRelocs += cChunkRelocs; cRelocs -= cChunkRelocs; if (cbData > cbChunk) { cbData -= cbChunk; pbData += cbChunk; } else cbData = 0; off += cbChunk; cbVirtData -= cbChunk; } } return fRet; } static bool convertCoffToOmf(const char *pszFile, uint8_t const *pbFile, size_t cbFile, FILE *pDst) { /* * Validate the source file a little. */ if (!validateCoff(pszFile, pbFile, cbFile)) return false; /* * Instantiate the OMF writer. */ PIMAGE_FILE_HEADER pHdr = (PIMAGE_FILE_HEADER)pbFile; POMFWRITER pThis = omfWriter_Create(pszFile, pHdr->NumberOfSections, pHdr->NumberOfSymbols, pDst); if (!pThis) return false; /* * Write the OMF object file. */ if (omfWriter_BeginModule(pThis, pszFile)) { PCIMAGE_SECTION_HEADER paShdrs = (PCIMAGE_SECTION_HEADER)(pHdr + 1); PCIMAGE_SYMBOL paSymTab = (PCIMAGE_SYMBOL)&pbFile[pHdr->PointerToSymbolTable]; const char *pchStrTab = (const char *)&paSymTab[pHdr->NumberOfSymbols]; if ( convertCoffSectionsToSegDefsAndGrpDefs(pThis, paShdrs, pHdr->NumberOfSections) && convertCoffSymbolsToPubDefsAndExtDefs(pThis, paSymTab, pHdr->NumberOfSymbols, pchStrTab, paShdrs) && omfWriter_LinkPassSeparator(pThis) && convertCoffSectionsToLeDataAndFixupps(pThis, pbFile, cbFile, paShdrs, pHdr->NumberOfSections, paSymTab, pHdr->NumberOfSymbols, pchStrTab) && omfWriter_EndModule(pThis) ) { omfWriter_Destroy(pThis); return true; } } omfWriter_Destroy(pThis); return false; } /********************************************************************************************************************************* * Mach-O/AMD64 -> OMF/i386 Converter * *********************************************************************************************************************************/ //#define MACHO_TO_OMF_CONVERSION #ifdef MACHO_TO_OMF_CONVERSION /** AMD64 relocation type names for Mach-O. */ static const char * const g_apszMachOAmd64RelTypes[] = { "X86_64_RELOC_UNSIGNED", "X86_64_RELOC_SIGNED", "X86_64_RELOC_BRANCH", "X86_64_RELOC_GOT_LOAD", "X86_64_RELOC_GOT", "X86_64_RELOC_SUBTRACTOR", "X86_64_RELOC_SIGNED_1", "X86_64_RELOC_SIGNED_2", "X86_64_RELOC_SIGNED_4" }; /** AMD64 relocation type sizes for Mach-O. */ static uint8_t const g_acbMachOAmd64RelTypes[] = { 8, /* X86_64_RELOC_UNSIGNED */ 4, /* X86_64_RELOC_SIGNED */ 4, /* X86_64_RELOC_BRANCH */ 4, /* X86_64_RELOC_GOT_LOAD */ 4, /* X86_64_RELOC_GOT */ 8, /* X86_64_RELOC_SUBTRACTOR */ 4, /* X86_64_RELOC_SIGNED_1 */ 4, /* X86_64_RELOC_SIGNED_2 */ 4, /* X86_64_RELOC_SIGNED_4 */ }; /** Macro for getting the size of a AMD64 Mach-O relocation. */ #define MACHO_AMD64_RELOC_SIZE(a_Type) ( (a_Type) < RT_ELEMENTS(g_acbMachOAmd64RelTypes) ? g_acbMachOAmd64RelTypes[(a_Type)] : 1) typedef struct MACHODETAILS { /** The ELF header. */ Elf64_Ehdr const *pEhdr; /** The section header table. */ Elf64_Shdr const *paShdrs; /** The string table for the section names. */ const char *pchShStrTab; /** The symbol table section number. UINT16_MAX if not found. */ uint16_t iSymSh; /** The string table section number. UINT16_MAX if not found. */ uint16_t iStrSh; /** The symbol table. */ Elf64_Sym const *paSymbols; /** The number of symbols in the symbol table. */ uint32_t cSymbols; /** Pointer to the (symbol) string table if found. */ const char *pchStrTab; /** The string table size. */ size_t cbStrTab; } MACHODETAILS; typedef MACHODETAILS *PMACHODETAILS; typedef MACHODETAILS const *PCMACHODETAILS; static bool validateMacho(const char *pszFile, uint8_t const *pbFile, size_t cbFile, PMACHODETAILS pMachOStuff) { /* * Initialize the Mach-O details structure. */ memset(pMachOStuff, 0, sizeof(*pMachOStuff)); pMachOStuff->iSymSh = UINT16_MAX; pMachOStuff->iStrSh = UINT16_MAX; /* * Validate the header and our other expectations. */ Elf64_Ehdr const *pEhdr = (Elf64_Ehdr const *)pbFile; pMachOStuff->pEhdr = pEhdr; if ( pEhdr->e_ident[EI_CLASS] != ELFCLASS64 || pEhdr->e_ident[EI_DATA] != ELFDATA2LSB || pEhdr->e_ehsize != sizeof(Elf64_Ehdr) || pEhdr->e_shentsize != sizeof(Elf64_Shdr) || pEhdr->e_version != EV_CURRENT ) return error(pszFile, "Unsupported ELF config\n"); if (pEhdr->e_type != ET_REL) return error(pszFile, "Expected relocatable ELF file (e_type=%d)\n", pEhdr->e_type); if (pEhdr->e_machine != EM_X86_64) return error(pszFile, "Expected relocatable ELF file (e_type=%d)\n", pEhdr->e_machine); if (pEhdr->e_phnum != 0) return error(pszFile, "Expected e_phnum to be zero not %u\n", pEhdr->e_phnum); if (pEhdr->e_shnum < 2) return error(pszFile, "Expected e_shnum to be two or higher\n"); if (pEhdr->e_shstrndx >= pEhdr->e_shnum || pEhdr->e_shstrndx == 0) return error(pszFile, "Bad e_shstrndx=%u (e_shnum=%u)\n", pEhdr->e_shstrndx, pEhdr->e_shnum); if ( pEhdr->e_shoff >= cbFile || pEhdr->e_shoff + pEhdr->e_shnum * sizeof(Elf64_Shdr) > cbFile) return error(pszFile, "Section table is outside the file (e_shoff=%#llx, e_shnum=%u, cbFile=%#llx)\n", pEhdr->e_shstrndx, pEhdr->e_shnum, (uint64_t)cbFile); /* * Locate the section name string table. * We assume it's okay as we only reference it in verbose mode. */ Elf64_Shdr const *paShdrs = (Elf64_Shdr const *)&pbFile[pEhdr->e_shoff]; pMachOStuff->paShdrs = paShdrs; Elf64_Xword const cbShStrTab = paShdrs[pEhdr->e_shstrndx].sh_size; if ( paShdrs[pEhdr->e_shstrndx].sh_offset > cbFile || cbShStrTab > cbFile || paShdrs[pEhdr->e_shstrndx].sh_offset + cbShStrTab > cbFile) return error(pszFile, "Section string table is outside the file (sh_offset=%#" ELF_FMT_X64 " sh_size=%#" ELF_FMT_X64 " cbFile=%#" ELF_FMT_X64 ")\n", paShdrs[pEhdr->e_shstrndx].sh_offset, paShdrs[pEhdr->e_shstrndx].sh_size, (Elf64_Xword)cbFile); const char *pchShStrTab = (const char *)&pbFile[paShdrs[pEhdr->e_shstrndx].sh_offset]; pMachOStuff->pchShStrTab = pchShStrTab; /* * Work the section table. */ bool fRet = true; for (uint32_t i = 1; i < pEhdr->e_shnum; i++) { if (paShdrs[i].sh_name >= cbShStrTab) return error(pszFile, "Invalid sh_name value (%#x) for section #%u\n", paShdrs[i].sh_name, i); const char *pszShNm = &pchShStrTab[paShdrs[i].sh_name]; if ( paShdrs[i].sh_offset > cbFile || paShdrs[i].sh_size > cbFile || paShdrs[i].sh_offset + paShdrs[i].sh_size > cbFile) return error(pszFile, "Section #%u '%s' has data outside the file: %#" ELF_FMT_X64 " LB %#" ELF_FMT_X64 " (cbFile=%#" ELF_FMT_X64 ")\n", i, pszShNm, paShdrs[i].sh_offset, paShdrs[i].sh_size, (Elf64_Xword)cbFile); if (g_cVerbose) printf("shdr[%u]: name=%#x '%s' type=%#x flags=%#" ELF_FMT_X64 " addr=%#" ELF_FMT_X64 " off=%#" ELF_FMT_X64 " size=%#" ELF_FMT_X64 "\n" " link=%u info=%#x align=%#" ELF_FMT_X64 " entsize=%#" ELF_FMT_X64 "\n", i, paShdrs[i].sh_name, pszShNm, paShdrs[i].sh_type, paShdrs[i].sh_flags, paShdrs[i].sh_addr, paShdrs[i].sh_offset, paShdrs[i].sh_size, paShdrs[i].sh_link, paShdrs[i].sh_info, paShdrs[i].sh_addralign, paShdrs[i].sh_entsize); if (paShdrs[i].sh_link >= pEhdr->e_shnum) return error(pszFile, "Section #%u '%s' links to a section outside the section table: %#x, max %#x\n", i, pszShNm, paShdrs[i].sh_link, pEhdr->e_shnum); if (!RT_IS_POWER_OF_TWO(paShdrs[i].sh_addralign)) return error(pszFile, "Section #%u '%s' alignment value is not a power of two: %#" ELF_FMT_X64 "\n", i, pszShNm, paShdrs[i].sh_addralign); if (!RT_IS_POWER_OF_TWO(paShdrs[i].sh_addralign)) return error(pszFile, "Section #%u '%s' alignment value is not a power of two: %#" ELF_FMT_X64 "\n", i, pszShNm, paShdrs[i].sh_addralign); if (paShdrs[i].sh_addr != 0) return error(pszFile, "Section #%u '%s' has non-zero address: %#" ELF_FMT_X64 "\n", i, pszShNm, paShdrs[i].sh_addr); if (paShdrs[i].sh_type == SHT_RELA) { if (paShdrs[i].sh_entsize != sizeof(Elf64_Rela)) return error(pszFile, "Expected sh_entsize to be %u not %u for section #%u (%s)\n", (unsigned)sizeof(Elf64_Rela), paShdrs[i].sh_entsize, i, pszShNm); uint32_t const cRelocs = paShdrs[i].sh_size / sizeof(Elf64_Rela); if (cRelocs * sizeof(Elf64_Rela) != paShdrs[i].sh_size) return error(pszFile, "Uneven relocation entry count in #%u (%s): sh_size=%#" ELF_FMT_X64 "\n", i, pszShNm, paShdrs[i].sh_size); if ( paShdrs[i].sh_offset > cbFile || paShdrs[i].sh_size >= cbFile || paShdrs[i].sh_offset + paShdrs[i].sh_size > cbFile) return error(pszFile, "The content of section #%u '%s' is outside the file (%#" ELF_FMT_X64 " LB %#" ELF_FMT_X64 ", cbFile=%#lx)\n", i, pszShNm, paShdrs[i].sh_offset, paShdrs[i].sh_size, (unsigned long)cbFile); if (paShdrs[i].sh_info != i - 1) return error(pszFile, "Expected relocation section #%u (%s) to link to previous section: sh_info=%#u\n", i, pszShNm, (unsigned)paShdrs[i].sh_link); if (paShdrs[paShdrs[i].sh_link].sh_type != SHT_SYMTAB) return error(pszFile, "Expected relocation section #%u (%s) to link to symbol table: sh_link=%#u -> sh_type=%#x\n", i, pszShNm, (unsigned)paShdrs[i].sh_link, (unsigned)paShdrs[paShdrs[i].sh_link].sh_type); uint32_t cSymbols = paShdrs[paShdrs[i].sh_link].sh_size / paShdrs[paShdrs[i].sh_link].sh_entsize; Elf64_Rela const *paRelocs = (Elf64_Rela *)&pbFile[paShdrs[i].sh_offset]; for (uint32_t j = 0; j < cRelocs; j++) { uint8_t const bType = ELF64_R_TYPE(paRelocs[j].r_info); if (RT_UNLIKELY(bType >= R_X86_64_COUNT)) fRet = error(pszFile, "%#018" ELF_FMT_X64 " %#018" ELF_FMT_X64 ": unknown fix up %#x (%+" ELF_FMT_D64 ")\n", paRelocs[j].r_offset, paRelocs[j].r_info, bType, paRelocs[j].r_addend); if (RT_UNLIKELY( j > 1 && paRelocs[j].r_offset <= paRelocs[j - 1].r_offset && paRelocs[j].r_offset + ELF_AMD64_RELOC_SIZE(ELF64_R_TYPE(paRelocs[j].r_info)) < paRelocs[j - 1].r_offset )) fRet = error(pszFile, "%#018" ELF_FMT_X64 " %#018" ELF_FMT_X64 ": out of offset order (prev %" ELF_FMT_X64 ")\n", paRelocs[j].r_offset, paRelocs[j].r_info, paRelocs[j - 1].r_offset); uint32_t const iSymbol = ELF64_R_SYM(paRelocs[j].r_info); if (RT_UNLIKELY(iSymbol >= cSymbols)) fRet = error(pszFile, "%#018" ELF_FMT_X64 " %#018" ELF_FMT_X64 ": symbol index (%#x) out of bounds (%#x)\n", paRelocs[j].r_offset, paRelocs[j].r_info, iSymbol, cSymbols); } if (RT_UNLIKELY( cRelocs > 0 && fRet && ( paRelocs[cRelocs - 1].r_offset > paShdrs[i - 1].sh_size || paRelocs[cRelocs - 1].r_offset + ELF_AMD64_RELOC_SIZE(ELF64_R_TYPE(paRelocs[cRelocs-1].r_info)) > paShdrs[i - 1].sh_size ))) fRet = error(pszFile, "%#018" ELF_FMT_X64 " %#018" ELF_FMT_X64 ": out of bounds (sh_size %" ELF_FMT_X64 ")\n", paRelocs[cRelocs - 1].r_offset, paRelocs[cRelocs - 1].r_info, paShdrs[i - 1].sh_size); } else if (paShdrs[i].sh_type == SHT_REL) fRet = error(pszFile, "Section #%u '%s': Unexpected SHT_REL section\n", i, pszShNm); else if (paShdrs[i].sh_type == SHT_SYMTAB) { if (paShdrs[i].sh_entsize != sizeof(Elf64_Sym)) fRet = error(pszFile, "Section #%u '%s': Unsupported symbol table entry size in : #%u (expected #%u)\n", i, pszShNm, paShdrs[i].sh_entsize, sizeof(Elf64_Sym)); Elf64_Xword const cSymbols = paShdrs[i].sh_size / paShdrs[i].sh_entsize; if (cSymbols * paShdrs[i].sh_entsize != paShdrs[i].sh_size) fRet = error(pszFile, "Section #%u '%s': Size not a multiple of entry size: %#" ELF_FMT_X64 " %% %#" ELF_FMT_X64 " = %#" ELF_FMT_X64 "\n", i, pszShNm, paShdrs[i].sh_size, paShdrs[i].sh_entsize, paShdrs[i].sh_size % paShdrs[i].sh_entsize); if (cSymbols > UINT32_MAX) fRet = error(pszFile, "Section #%u '%s': too many symbols: %" ELF_FMT_X64 "\n", i, pszShNm, paShdrs[i].sh_size, cSymbols); if (pMachOStuff->iSymSh == UINT16_MAX) { pMachOStuff->iSymSh = (uint16_t)i; pMachOStuff->paSymbols = (Elf64_Sym const *)&pbFile[paShdrs[i].sh_offset]; pMachOStuff->cSymbols = cSymbols; if (paShdrs[i].sh_link != 0) { /* Note! The symbol string table section header may not have been validated yet! */ Elf64_Shdr const *pStrTabShdr = &paShdrs[paShdrs[i].sh_link]; pMachOStuff->iStrSh = paShdrs[i].sh_link; pMachOStuff->pchStrTab = (const char *)&pbFile[pStrTabShdr->sh_offset]; pMachOStuff->cbStrTab = (size_t)pStrTabShdr->sh_size; } else fRet = error(pszFile, "Section #%u '%s': String table link is out of bounds (%#x)\n", i, pszShNm, paShdrs[i].sh_link); } else fRet = error(pszFile, "Section #%u '%s': Found additonal symbol table, previous in #%u\n", i, pszShNm, pMachOStuff->iSymSh); } } return fRet; } static bool convertMachoSectionsToSegDefsAndGrpDefs(POMFWRITER pThis, PCMACHODETAILS pMachOStuff) { /* * Do the list of names pass. */ uint16_t idxGrpFlat, idxGrpData; uint16_t idxClassCode, idxClassData, idxClassDwarf; if ( !omfWriter_LNamesBegin(pThis, true /*fAddZeroEntry*/) || !omfWriter_LNamesAddN(pThis, RT_STR_TUPLE("FLAT"), &idxGrpFlat) || !omfWriter_LNamesAddN(pThis, RT_STR_TUPLE("BS3DATA64_GROUP"), &idxGrpData) || !omfWriter_LNamesAddN(pThis, RT_STR_TUPLE("BS3CLASS64CODE"), &idxClassCode) || !omfWriter_LNamesAddN(pThis, RT_STR_TUPLE("FAR_DATA"), &idxClassData) || !omfWriter_LNamesAddN(pThis, RT_STR_TUPLE("DWARF"), &idxClassDwarf) ) return false; bool fHaveData = false; Elf64_Shdr const *pShdr = &pMachOStuff->paShdrs[1]; Elf64_Half const cSections = pMachOStuff->pEhdr->e_shnum; for (Elf64_Half i = 1; i < cSections; i++, pShdr++) { const char *pszName = &pMachOStuff->pchShStrTab[pShdr->sh_name]; if (*pszName == '\0') return error(pThis->pszSrc, "Section #%u has an empty name!\n", i); switch (pShdr->sh_type) { case SHT_PROGBITS: case SHT_NOBITS: /* We drop a few sections we don't want:. */ if ( strcmp(pszName, ".comment") != 0 /* compiler info */ && strcmp(pszName, ".note.GNU-stack") != 0 /* some empty section for hinting the linker/whatever */ && strcmp(pszName, ".eh_frame") != 0 /* unwind / exception info */ ) { pThis->paSegments[i].iSegDef = UINT16_MAX; pThis->paSegments[i].iGrpDef = UINT16_MAX; /* Translate the name and determine group and class. Note! We currently strip sub-sections. */ if ( strcmp(pszName, ".text") == 0 || strncmp(pszName, RT_STR_TUPLE(".text.")) == 0) { pszName = "BS3TEXT64"; pThis->paSegments[i].iGrpNm = idxGrpFlat; pThis->paSegments[i].iClassNm = idxClassCode; } else if ( strcmp(pszName, ".data") == 0 || strncmp(pszName, RT_STR_TUPLE(".data.")) == 0) { pszName = "BS3DATA64"; pThis->paSegments[i].iGrpNm = idxGrpData; pThis->paSegments[i].iClassNm = idxClassData; } else if (strcmp(pszName, ".bss") == 0) { pszName = "BS3BSS64"; pThis->paSegments[i].iGrpNm = idxGrpData; pThis->paSegments[i].iClassNm = idxClassData; } else if ( strcmp(pszName, ".rodata") == 0 || strncmp(pszName, RT_STR_TUPLE(".rodata.")) == 0) { pszName = "BS3DATA64CONST"; pThis->paSegments[i].iGrpNm = idxGrpData; pThis->paSegments[i].iClassNm = idxClassData; } else if (strncmp(pszName, RT_STR_TUPLE(".debug_")) == 0) { pThis->paSegments[i].iGrpNm = UINT16_MAX; pThis->paSegments[i].iClassNm = idxClassDwarf; } else { pThis->paSegments[i].iGrpNm = idxGrpData; pThis->paSegments[i].iClassNm = idxClassData; error(pThis->pszSrc, "Unknown data (?) segment: '%s'\n", pszName); } /* Save the name. */ pThis->paSegments[i].pszName = strdup(pszName); if (!pThis->paSegments[i].pszName) return error(pThis->pszSrc, "Out of memory!\n"); /* Add the section name. */ if (!omfWriter_LNamesAdd(pThis, pThis->paSegments[i].pszName, &pThis->paSegments[i].iSegNm)) return false; fHaveData |= pThis->paSegments[i].iGrpDef == idxGrpData; break; } RT_FALL_THRU(); default: pThis->paSegments[i].iSegDef = UINT16_MAX; pThis->paSegments[i].iGrpDef = UINT16_MAX; pThis->paSegments[i].iSegNm = UINT16_MAX; pThis->paSegments[i].iGrpNm = UINT16_MAX; pThis->paSegments[i].iClassNm = UINT16_MAX; pThis->paSegments[i].pszName = NULL; break; } } if (!omfWriter_LNamesEnd(pThis)) return false; /* * Emit segment definitions. */ uint16_t iSegDef = 1; /* Start counting at 1. */ pShdr = &pMachOStuff->paShdrs[1]; for (Elf64_Half i = 1; i < cSections; i++, pShdr++) { if (pThis->paSegments[i].iSegNm == UINT16_MAX) continue; uint8_t bSegAttr = 0; /* The A field. */ switch (pShdr->sh_addralign) { case 0: case 1: bSegAttr |= 1 << 5; break; case 2: bSegAttr |= 2 << 5; break; case 4: bSegAttr |= 5 << 5; break; case 8: case 16: bSegAttr |= 3 << 5; break; case 32: case 64: case 128: case 256: bSegAttr |= 4 << 5; break; default: bSegAttr |= 6 << 5; /* page aligned, pharlabs extension. */ break; } /* The C field. */ bSegAttr |= 2 << 2; /* public */ /* The B field. We don't have 4GB segments, so leave it as zero. */ /* The D field shall be set as we're doing USE32. */ bSegAttr |= 1; /* Done. */ if (!omfWriter_SegDef(pThis, bSegAttr, (uint32_t)pShdr->sh_size, pThis->paSegments[i].iSegNm, pThis->paSegments[i].iClassNm)) return false; pThis->paSegments[i].iSegDef = iSegDef++; } /* * Flat group definition (#1) - special, no members. */ uint16_t iGrpDef = 1; if ( !omfWriter_GrpDefBegin(pThis, idxGrpFlat) || !omfWriter_GrpDefEnd(pThis)) return false; for (uint16_t i = 0; i < cSections; i++) if (pThis->paSegments[i].iGrpNm == idxGrpFlat) pThis->paSegments[i].iGrpDef = iGrpDef; pThis->idxGrpFlat = iGrpDef++; /* * Data group definition (#2). */ /** @todo do we need to consider missing segments and ordering? */ uint16_t cGrpNms = 0; uint16_t aiGrpNms[2] = { 0, 0 }; /* Shut up, GCC. */ if (fHaveData) aiGrpNms[cGrpNms++] = idxGrpData; for (uint32_t iGrpNm = 0; iGrpNm < cGrpNms; iGrpNm++) { if (!omfWriter_GrpDefBegin(pThis, aiGrpNms[iGrpNm])) return false; for (uint16_t i = 0; i < cSections; i++) if (pThis->paSegments[i].iGrpNm == aiGrpNms[iGrpNm]) { pThis->paSegments[i].iGrpDef = iGrpDef; if (!omfWriter_GrpDefAddSegDef(pThis, pThis->paSegments[i].iSegDef)) return false; } if (!omfWriter_GrpDefEnd(pThis)) return false; iGrpDef++; } return true; } static bool convertMachOSymbolsToPubDefsAndExtDefs(POMFWRITER pThis, PCMACHODETAILS pMachOStuff) { if (!pMachOStuff->cSymbols) return true; /* * Process the symbols the first. */ uint32_t cAbsSyms = 0; uint32_t cExtSyms = 0; uint32_t cPubSyms = 0; for (uint32_t iSeg = 0; iSeg < pThis->cSegments; iSeg++) pThis->paSegments[iSeg].cPubDefs = 0; uint32_t const cSections = pMachOStuff->pEhdr->e_shnum; uint32_t const cSymbols = pMachOStuff->cSymbols; Elf64_Sym const * const paSymbols = pMachOStuff->paSymbols; for (uint32_t iSym = 0; iSym < cSymbols; iSym++) { const uint8_t bBind = ELF64_ST_BIND(paSymbols[iSym].st_info); const uint8_t bType = ELF64_ST_TYPE(paSymbols[iSym].st_info); const char *pszSymName = &pMachOStuff->pchStrTab[paSymbols[iSym].st_name]; if ( *pszSymName == '\0' && bType == STT_SECTION && paSymbols[iSym].st_shndx < cSections) pszSymName = &pMachOStuff->pchShStrTab[pMachOStuff->paShdrs[paSymbols[iSym].st_shndx].sh_name]; pThis->paSymbols[iSym].enmType = OMFSYMTYPE_IGNORED; pThis->paSymbols[iSym].idx = UINT16_MAX; pThis->paSymbols[iSym].idxSegDef = UINT16_MAX; pThis->paSymbols[iSym].idxGrpDef = UINT16_MAX; uint32_t const idxSection = paSymbols[iSym].st_shndx; if (idxSection == SHN_UNDEF) { if (bBind == STB_GLOBAL) { pThis->paSymbols[iSym].enmType = OMFSYMTYPE_EXTDEF; cExtSyms++; if (*pszSymName == '\0') return error(pThis->pszSrc, "External symbol #%u (%s) has an empty name.\n", iSym, pszSymName); } else if (bBind != STB_LOCAL || iSym != 0) /* Entry zero is usually a dummy. */ return error(pThis->pszSrc, "Unsupported or invalid bind type %#x for undefined symbol #%u (%s)\n", bBind, iSym, pszSymName); } else if (idxSection < cSections) { pThis->paSymbols[iSym].idxSegDef = pThis->paSegments[idxSection].iSegDef; pThis->paSymbols[iSym].idxGrpDef = pThis->paSegments[idxSection].iGrpDef; if (bBind == STB_GLOBAL) { pThis->paSymbols[iSym].enmType = OMFSYMTYPE_PUBDEF; pThis->paSegments[idxSection].cPubDefs++; cPubSyms++; if (bType == STT_SECTION) return error(pThis->pszSrc, "Don't know how to export STT_SECTION symbol #%u (%s)\n", iSym, pszSymName); if (*pszSymName == '\0') return error(pThis->pszSrc, "Public symbol #%u (%s) has an empty name.\n", iSym, pszSymName); } else if (bType == STT_SECTION) pThis->paSymbols[iSym].enmType = OMFSYMTYPE_SEGDEF; else pThis->paSymbols[iSym].enmType = OMFSYMTYPE_INTERNAL; } else if (idxSection == SHN_ABS) { if (bType != STT_FILE) { if (bBind == STB_GLOBAL) { pThis->paSymbols[iSym].enmType = OMFSYMTYPE_PUBDEF; pThis->paSymbols[iSym].idxSegDef = 0; pThis->paSymbols[iSym].idxGrpDef = 0; cAbsSyms++; if (*pszSymName == '\0') return error(pThis->pszSrc, "Public absolute symbol #%u (%s) has an empty name.\n", iSym, pszSymName); } else return error(pThis->pszSrc, "Unsupported or invalid bind type %#x for absolute symbol #%u (%s)\n", bBind, iSym, pszSymName); } } else return error(pThis->pszSrc, "Unsupported or invalid section number %#x for symbol #%u (%s)\n", idxSection, iSym, pszSymName); } /* * Emit the PUBDEFs the first time around (see order of records in TIS spec). * Note! We expect the os x compiler to always underscore symbols, so unlike the * other 64-bit converters we don't need to check for underscores and add them. */ uint16_t idxPubDef = 1; if (cPubSyms) { for (uint32_t iSeg = 0; iSeg < pThis->cSegments; iSeg++) if (pThis->paSegments[iSeg].cPubDefs > 0) { uint16_t const idxSegDef = pThis->paSegments[iSeg].iSegDef; if (!omfWriter_PubDefBegin(pThis, pThis->paSegments[iSeg].iGrpDef, idxSegDef)) return false; for (uint16_t iSym = 0; iSym < cSymbols; iSym++) if ( pThis->paSymbols[iSym].idxSegDef == idxSegDef && pThis->paSymbols[iSym].enmType == OMFSYMTYPE_PUBDEF) { const char *pszName = &pMachOStuff->pchStrTab[paSymbols[iSym].st_name]; if (!omfWriter_PubDefAdd(pThis, paSymbols[iSym].st_value, pszName, false /*fPrependUnderscore*/)) return false; pThis->paSymbols[iSym].idx = idxPubDef++; } if (!omfWriter_PubDefEnd(pThis)) return false; } } if (cAbsSyms > 0) { if (!omfWriter_PubDefBegin(pThis, 0, 0)) return false; for (uint16_t iSym = 0; iSym < cSymbols; iSym++) if ( pThis->paSymbols[iSym].idxSegDef == 0 && pThis->paSymbols[iSym].enmType == OMFSYMTYPE_PUBDEF) { const char *pszName = &pMachOStuff->pchStrTab[paSymbols[iSym].st_name]; if (!omfWriter_PubDefAdd(pThis, paSymbols[iSym].st_value, pszName, false /*fPrependUnderscore*/)) return false; pThis->paSymbols[iSym].idx = idxPubDef++; } if (!omfWriter_PubDefEnd(pThis)) return false; } /* * Go over the symbol table and emit external definition records. */ if (!omfWriter_ExtDefBegin(pThis)) return false; uint16_t idxExtDef = 1; for (uint16_t iSym = 0; iSym < cSymbols; iSym++) if (pThis->paSymbols[iSym].enmType == OMFSYMTYPE_EXTDEF) { const char *pszName = &pMachOStuff->pchStrTab[paSymbols[iSym].st_name]; if (!omfWriter_ExtDefAdd(pThis, pszName, false /*fPrependUnderscore*/)) return false; pThis->paSymbols[iSym].idx = idxExtDef++; } if (!omfWriter_ExtDefEnd(pThis)) return false; return true; } static bool convertMachOSectionsToLeDataAndFixupps(POMFWRITER pThis, PCMACHODETAILS pMachOStuff, uint8_t const *pbFile, size_t cbFile) { Elf64_Sym const *paSymbols = pMachOStuff->paSymbols; Elf64_Shdr const *paShdrs = pMachOStuff->paShdrs; bool fRet = true; for (uint32_t i = 1; i < pThis->cSegments; i++) { if (pThis->paSegments[i].iSegDef == UINT16_MAX) continue; const char *pszSegNm = &pMachOStuff->pchShStrTab[paShdrs[i].sh_name]; bool const fRelocs = i + 1 < pThis->cSegments && paShdrs[i + 1].sh_type == SHT_RELA; uint32_t cRelocs = fRelocs ? paShdrs[i + 1].sh_size / sizeof(Elf64_Rela) : 0; Elf64_Rela const *paRelocs = fRelocs ? (Elf64_Rela *)&pbFile[paShdrs[i + 1].sh_offset] : NULL; Elf64_Xword cbVirtData = paShdrs[i].sh_size; Elf64_Xword cbData = paShdrs[i].sh_type == SHT_NOBITS ? 0 : cbVirtData; uint8_t const *pbData = &pbFile[paShdrs[i].sh_offset]; uint32_t off = 0; /* The OMF record size requires us to split larger sections up. To make life simple, we fill zeros for unitialized (BSS) stuff. */ const uint32_t cbMaxData = RT_MIN(OMF_MAX_RECORD_PAYLOAD - 1 - (pThis->paSegments[i].iSegDef >= 128) - 4 - 1, _1K); while (cbVirtData > 0) { /* Figure out how many bytes to put out in this chunk. Must make sure fixups doesn't cross chunk boundraries. ASSUMES sorted relocs. */ uint32_t cChunkRelocs = cRelocs; uint32_t cbChunk = cbVirtData; uint32_t offEnd = off + cbChunk; if (cbChunk > cbMaxData) { cbChunk = cbMaxData; offEnd = off + cbChunk; cChunkRelocs = 0; /* Quickly determin the reloc range. */ while ( cChunkRelocs < cRelocs && paRelocs[cChunkRelocs].r_offset < offEnd) cChunkRelocs++; /* Ensure final reloc doesn't go beyond chunk. */ while ( cChunkRelocs > 0 && paRelocs[cChunkRelocs - 1].r_offset + ELF_AMD64_RELOC_SIZE(ELF64_R_TYPE(paRelocs[cChunkRelocs - 1].r_info)) > offEnd) { uint32_t cbDrop = offEnd - paRelocs[cChunkRelocs - 1].r_offset; cbChunk -= cbDrop; offEnd -= cbDrop; cChunkRelocs--; } if (!cbVirtData) return error(pThis->pszSrc, "Wtf? cbVirtData is zero!\n"); } /* * We stash the bytes into the OMF writer record buffer, receiving a * pointer to the start of it so we can make adjustments if necessary. */ uint8_t *pbCopy; if (!omfWriter_LEDataBeginEx(pThis, pThis->paSegments[i].iSegDef, off, cbChunk, cbData, pbData, &pbCopy)) return false; /* * Convert fiuxps. */ for (uint32_t iReloc = 0; iReloc < cChunkRelocs; iReloc++) { /* Get the OMF and ELF data for the symbol the reloc references. */ uint32_t const uType = ELF64_R_TYPE(paRelocs[iReloc].r_info); uint32_t const iSymbol = ELF64_R_SYM(paRelocs[iReloc].r_info); Elf64_Sym const * const pElfSym = &paSymbols[iSymbol]; POMFSYMBOL const pOmfSym = &pThis->paSymbols[iSymbol]; const char * const pszSymName = &pMachOStuff->pchStrTab[pElfSym->st_name]; /* Calc fixup location in the pending chunk and setup a flexible pointer to it. */ uint16_t offDataRec = (uint16_t)(paRelocs[iReloc].r_offset - off); RTPTRUNION uLoc; uLoc.pu8 = &pbCopy[offDataRec]; /* OMF fixup data initialized with typical defaults. */ bool fSelfRel = true; uint8_t bLocation = OMF_FIX_LOC_32BIT_OFFSET; uint8_t bFrame = OMF_FIX_F_GRPDEF; uint16_t idxFrame = pThis->idxGrpFlat; uint8_t bTarget; uint16_t idxTarget; bool fTargetDisp; uint32_t offTargetDisp; switch (pOmfSym->enmType) { case OMFSYMTYPE_INTERNAL: case OMFSYMTYPE_PUBDEF: bTarget = OMF_FIX_T_SEGDEF; idxTarget = pOmfSym->idxSegDef; fTargetDisp = true; offTargetDisp = pElfSym->st_value; break; case OMFSYMTYPE_SEGDEF: bTarget = OMF_FIX_T_SEGDEF_NO_DISP; idxTarget = pOmfSym->idxSegDef; fTargetDisp = false; offTargetDisp = 0; break; case OMFSYMTYPE_EXTDEF: bTarget = OMF_FIX_T_EXTDEF_NO_DISP; idxTarget = pOmfSym->idx; fTargetDisp = false; offTargetDisp = 0; break; default: return error(pThis->pszSrc, "Relocation in segment #%u '%s' references ignored or invalid symbol (%s)\n", i, pszSegNm, pszSymName); } /* Do COFF relocation type conversion. */ switch (uType) { case R_X86_64_64: { int64_t iAddend = paRelocs[iReloc].r_addend; if (iAddend > _1G || iAddend < -_1G) fRet = error(pThis->pszSrc, "R_X86_64_64 with large addend (%" ELF_FMT_D64 ") at %#x in segment #%u '%s'\n", iAddend, paRelocs[iReloc].r_offset, i, pszSegNm); *uLoc.pu64 = iAddend; fSelfRel = false; break; } case R_X86_64_32: case R_X86_64_32S: /* signed, unsigned, whatever. */ fSelfRel = false; RT_FALL_THRU(); case R_X86_64_PC32: { /* defaults are ok, just handle the addend. */ int32_t iAddend = paRelocs[iReloc].r_addend; if (iAddend != paRelocs[iReloc].r_addend) fRet = error(pThis->pszSrc, "R_X86_64_PC32 with large addend (%d) at %#x in segment #%u '%s'\n", iAddend, paRelocs[iReloc].r_offset, i, pszSegNm); *uLoc.pu32 = iAddend; break; } case R_X86_64_NONE: continue; /* Ignore this one */ case R_X86_64_GOT32: case R_X86_64_PLT32: case R_X86_64_COPY: case R_X86_64_GLOB_DAT: case R_X86_64_JMP_SLOT: case R_X86_64_RELATIVE: case R_X86_64_GOTPCREL: case R_X86_64_16: case R_X86_64_PC16: case R_X86_64_8: case R_X86_64_PC8: case R_X86_64_DTPMOD64: case R_X86_64_DTPOFF64: case R_X86_64_TPOFF64: case R_X86_64_TLSGD: case R_X86_64_TLSLD: case R_X86_64_DTPOFF32: case R_X86_64_GOTTPOFF: case R_X86_64_TPOFF32: default: return error(pThis->pszSrc, "Unsupported fixup type %#x (%s) at rva=%#x in section #%u '%s' against '%s'\n", uType, g_apszElfAmd64RelTypes[uType], paRelocs[iReloc].r_offset, i, pszSegNm, pszSymName); } /* Add the fixup. */ if (idxFrame == UINT16_MAX) error(pThis->pszSrc, "idxFrame=UINT16_MAX for %s type=%s\n", pszSymName, g_apszElfAmd64RelTypes[uType]); fRet = omfWriter_LEDataAddFixup(pThis, offDataRec, fSelfRel, bLocation, bFrame, idxFrame, bTarget, idxTarget, fTargetDisp, offTargetDisp) && fRet; } /* * Write the LEDATA and associated FIXUPPs. */ if (!omfWriter_LEDataEnd(pThis)) return false; /* * Advance. */ paRelocs += cChunkRelocs; cRelocs -= cChunkRelocs; if (cbData > cbChunk) { cbData -= cbChunk; pbData += cbChunk; } else cbData = 0; off += cbChunk; cbVirtData -= cbChunk; } } return fRet; } static bool convertMachoToOmf(const char *pszFile, uint8_t const *pbFile, size_t cbFile, FILE *pDst) { /* * Validate the source file a little. */ MACHODETAILS MachOStuff; if (!validateMachO(pszFile, pbFile, cbFile, &MachOStuff)) return false; /* * Instantiate the OMF writer. */ POMFWRITER pThis = omfWriter_Create(pszFile, MachOStuff.pEhdr->e_shnum, MachOStuff.cSymbols, pDst); if (!pThis) return false; /* * Write the OMF object file. */ if (omfWriter_BeginModule(pThis, pszFile)) { Elf64_Ehdr const *pEhdr = (Elf64_Ehdr const *)pbFile; if ( convertMachOSectionsToSegDefsAndGrpDefs(pThis, &MachOStuff) && convertMachOSymbolsToPubDefsAndExtDefs(pThis, &MachOStuff) && omfWriter_LinkPassSeparator(pThis) && convertMachOSectionsToLeDataAndFixupps(pThis, &MachOStuff, pbFile, cbFile) && omfWriter_EndModule(pThis) ) { omfWriter_Destroy(pThis); return true; } } omfWriter_Destroy(pThis); return false; } #endif /* !MACHO_TO_OMF_CONVERSION */ /********************************************************************************************************************************* * OMF Converter/Tweaker * *********************************************************************************************************************************/ /** Watcom intrinsics we need to modify so we can mix 32-bit and 16-bit * code, since the 16 and 32 bit compilers share several names. * The names are length prefixed. */ static const char * const g_apszExtDefRenames[] = { "\x05" "__I4D", "\x05" "__I4M", "\x05" "__I8D", "\x06" "__I8DQ", "\x07" "__I8DQE", "\x06" "__I8DR", "\x07" "__I8DRE", "\x06" "__I8LS", "\x05" "__I8M", "\x06" "__I8ME", "\x06" "__I8RS", "\x05" "__PIA", "\x05" "__PIS", "\x05" "__PTC", "\x05" "__PTS", "\x05" "__U4D", "\x05" "__U4M", "\x05" "__U8D", "\x06" "__U8DQ", "\x07" "__U8DQE", "\x06" "__U8DR", "\x07" "__U8DRE", "\x06" "__U8LS", "\x05" "__U8M", "\x06" "__U8ME", "\x06" "__U8RS", }; /** * Segment definition. */ typedef struct OMFSEGDEF { uint32_t cbSeg; uint8_t bSegAttr; uint16_t idxName; uint16_t idxClass; uint16_t idxOverlay; uint8_t cchName; uint8_t cchClass; uint8_t cchOverlay; const char *pchName; const char *pchClass; const char *pchOverlay; bool fUse32; bool f32bitRec; } OMFSEGDEF; typedef OMFSEGDEF *POMFSEGDEF; /** * Group definition. */ typedef struct OMFGRPDEF { const char *pchName; uint16_t idxName; uint8_t cchName; uint16_t cSegDefs; uint16_t *paidxSegDefs; } OMFGRPDEF; typedef OMFGRPDEF *POMFGRPDEF; /** * Records line number information for a file in a segment (for CV8 debug info). */ typedef struct OMFFILELINES { /** The source info offset. */ uint32_t offSrcInfo; /** Number of line/offset pairs. */ uint32_t cPairs; /** Number of pairs allocated. */ uint32_t cPairsAlloc; /** Table with line number and offset pairs, ordered by offset. */ PRTCV8LINEPAIR paPairs; } OMFFILEINES; typedef OMFFILEINES *POMFFILEINES; /** * Records line number information for a segment (for CV8 debug info). */ typedef struct OMFSEGLINES { /** Number of files. */ uint32_t cFiles; /** Number of bytes we need. */ uint32_t cb; /** The segment index. */ uint16_t idxSeg; /** The group index for this segment. Initially OMF_REPLACE_GRP_XXX values, * later convertOmfWriteDebugGrpDefs replaces them with actual values. */ uint16_t idxGrp; /** File table. */ POMFFILEINES paFiles; } OMFSEGLINES; typedef OMFSEGLINES *POMFSEGLINES; /** @name OMF_REPLACE_GRP_XXX - Special OMFSEGLINES::idxGrp values. * @{ */ #define OMF_REPLACE_GRP_CGROUP16 UINT16_C(0xffe0) #define OMF_REPLACE_GRP_RMCODE UINT16_C(0xffe1) #define OMF_REPLACE_GRP_X0CODE UINT16_C(0xffe2) #define OMF_REPLACE_GRP_X1CODE UINT16_C(0xffe3) /** @} */ /** * OMF details allocation that needs to be freed when done. */ typedef struct OMFDETAILSALLOC { /** Pointer to the next allocation. */ struct OMFDETAILSALLOC *pNext; /** The allocated bytes. */ RT_FLEXIBLE_ARRAY_EXTENSION uint8_t abData[RT_FLEXIBLE_ARRAY]; } OMFDETAILSALLOC; typedef OMFDETAILSALLOC *POMFDETAILSALLOC; /** * OMF conversion details. * * Keeps information relevant to the conversion and CV8 debug info. */ typedef struct OMFDETAILS { /** The input file name. */ const char *pszFile; /** Set if it has line numbers. */ bool fLineNumbers; /** Set if we think this may be a 32-bit OMF file. */ bool fProbably32bit; /** Set if this module may need mangling. */ bool fMayNeedMangling; /** The LNAME index of '$$SYMBOLS' or UINT16_MAX it not found. */ uint16_t iSymbolsNm; /** The LNAME index of 'DEBSYM' or UINT16_MAX it not found. */ uint16_t iDebSymNm; /** The '$$SYMBOLS' segment index. */ uint16_t iSymbolsSeg; /** Number of SEGDEFs records. */ uint16_t cSegDefs; /** Number of GRPDEFs records. */ uint16_t cGrpDefs; /** Number of listed names. */ uint16_t cLNames; /** Segment defintions. */ POMFSEGDEF paSegDefs; /** Group defintions. */ POMFGRPDEF paGrpDefs; /** Name list. Points to the size repfix. */ char **papchLNames; /** Code groups we need to keep an eye on for line number fixup purposes. */ struct OMFLINEGROUPS { /** The name. */ const char *pszName; /** The primary class name. */ const char *pszClass1; /** The secondary class name. */ const char *pszClass2; /** The main segment name, NULL if not applicable (CGROUP16). */ const char *pszSeg; /** The name length. */ uint8_t cchName; /** The primary class name length. */ uint8_t cchClass1; /** The secondary class name length. */ uint8_t cchClass2; /** Whether this group is needed. */ bool fNeeded; /** The group index (UINT16_MAX if not found). */ uint16_t idxGroup; /** The group name. */ uint16_t idxName; /** The OMF_REPLACE_GRP_XXX value. */ uint16_t idxReplaceGrp; } aGroups[4]; /** CV8: Filename string table size. */ uint32_t cbStrTab; /** CV8: Filename string table allocation size (always multiple of dword, * zero initialized). */ uint32_t cbStrTabAlloc; /** CV8: Filename String table. */ char *pchStrTab; /** CV8: Elements in the source info table. */ uint16_t cSrcInfo; /** CV8: Source info table. */ PRTCV8SRCINFO paSrcInfo; /** Number of entries in the paSegLines table. */ uint32_t cSegLines; /** Segment line numbers, indexed by segment number. */ POMFSEGLINES paSegLines; /** List of allocations that needs freeing. */ POMFDETAILSALLOC pAllocHead; } OMFDETAILS; typedef OMFDETAILS *POMFDETAILS; typedef OMFDETAILS const *PCOMFDETAILS; /** Grows a table to a given size (a_cNewEntries). */ #define OMF_GROW_TABLE_EX_RET_ERR(a_EntryType, a_paTable, a_cEntries, a_cNewEntries) \ do\ { \ size_t cbOld = (a_cEntries) * sizeof(a_EntryType); \ size_t cbNew = (a_cNewEntries) * sizeof(a_EntryType); \ void *pvNew = realloc(a_paTable, cbNew); \ if (pvNew) \ { \ memset((uint8_t *)pvNew + cbOld, 0, cbNew - cbOld); \ (a_paTable) = (a_EntryType *)pvNew; \ } \ else return error("???", "Out of memory!\n"); \ } while (0) /** Grows a table. */ #define OMF_GROW_TABLE_RET_ERR(a_EntryType, a_paTable, a_cEntries, a_cEvery) \ if ((a_cEntries) % (a_cEvery) != 0) { /* likely */ } \ else do\ { \ size_t cbOld = (a_cEntries) * sizeof(a_EntryType); \ size_t cbNew = cbOld + (a_cEvery) * sizeof(a_EntryType); \ void *pvNew = realloc(a_paTable, cbNew); \ if (pvNew) \ { \ memset((uint8_t *)pvNew + cbOld, 0, (a_cEvery) * sizeof(a_EntryType)); \ (a_paTable) = (a_EntryType *)pvNew; \ } \ else return error("???", "Out of memory!\n"); \ } while (0) #define OMF_EXPLODE_LNAME(a_pOmfStuff, a_idxName, a_pchName, a_cchName, a_Name) \ do { \ if ((a_idxName) < (a_pOmfStuff)->cLNames) \ { \ a_cchName = (uint8_t)*(a_pOmfStuff)->papchLNames[(a_idxName)]; \ a_pchName = (a_pOmfStuff)->papchLNames[(a_idxName)] + 1; \ } \ else return error((a_pOmfStuff)->pszFile, "Invalid LNAME reference %#x in " #a_Name "!\n", a_idxName); \ } while (0) /** * Allocates memory that will be freed when we're done converting. * * @returns Pointer tot he memory. * @param pOmfStuff The OMF details data. * @param cbNeeded The amount of memory required. */ static void *omfDetails_Alloc(POMFDETAILS pOmfStuff, size_t cbNeeded) { POMFDETAILSALLOC pAlloc = (POMFDETAILSALLOC)malloc(RT_UOFFSETOF_DYN(OMFDETAILSALLOC, abData[cbNeeded])); if (pAlloc) { pAlloc->pNext = pOmfStuff->pAllocHead; pOmfStuff->pAllocHead = pAlloc; return &pAlloc->abData[0]; } return NULL; } /** * Adds a line number to the CV8 debug info. * * @returns success indicator. * @param pOmfStuff Where to collect CV8 debug info. * @param cchSrcFile The length of the source file name. * @param pchSrcFile The source file name, not terminated. * @param poffFile Where to return the source file information table * offset (for use in the line number tables). */ static bool collectOmfAddFile(POMFDETAILS pOmfStuff, uint8_t cchSrcFile, const char *pchSrcFile, uint32_t *poffFile) { /* * Do lookup first. */ uint32_t i = pOmfStuff->cSrcInfo; while (i-- > 0) { const char *pszCur = &pOmfStuff->pchStrTab[pOmfStuff->paSrcInfo[i].offSourceName]; if ( strncmp(pszCur, pchSrcFile, cchSrcFile) == 0 && pszCur[cchSrcFile] == '\0') { *poffFile = i * sizeof(pOmfStuff->paSrcInfo[0]); return true; } } /* * Add it to the string table (dword aligned and zero padded). */ uint32_t offSrcTab = pOmfStuff->cbStrTab; if (offSrcTab + cchSrcFile + 1 > pOmfStuff->cbStrTabAlloc) { uint32_t cbNew = (offSrcTab == 0) + offSrcTab + cchSrcFile + 1; cbNew = RT_ALIGN(cbNew, 256); void *pvNew = realloc(pOmfStuff->pchStrTab, cbNew); if (!pvNew) return error("???", "out of memory"); pOmfStuff->pchStrTab = (char *)pvNew; pOmfStuff->cbStrTabAlloc = cbNew; memset(&pOmfStuff->pchStrTab[offSrcTab], 0, cbNew - offSrcTab); if (!offSrcTab) offSrcTab++; } memcpy(&pOmfStuff->pchStrTab[offSrcTab], pchSrcFile, cchSrcFile); pOmfStuff->pchStrTab[offSrcTab + cchSrcFile] = '\0'; pOmfStuff->cbStrTab = offSrcTab + cchSrcFile + 1; /* * Add it to the filename info table. */ if ((pOmfStuff->cSrcInfo % 8) == 0) { void *pvNew = realloc(pOmfStuff->paSrcInfo, sizeof(pOmfStuff->paSrcInfo[0]) * (pOmfStuff->cSrcInfo + 8)); if (!pvNew) return error("???", "out of memory"); pOmfStuff->paSrcInfo = (PRTCV8SRCINFO)pvNew; } PRTCV8SRCINFO pSrcInfo = &pOmfStuff->paSrcInfo[pOmfStuff->cSrcInfo++]; pSrcInfo->offSourceName = offSrcTab; pSrcInfo->uDigestType = RTCV8SRCINFO_DIGEST_TYPE_MD5; memset(&pSrcInfo->Digest, 0, sizeof(pSrcInfo->Digest)); *poffFile = (uint32_t)((uintptr_t)pSrcInfo - (uintptr_t)pOmfStuff->paSrcInfo); return true; } /** * Adds a line number to the CV8 debug info. * * @returns success indicator. * @param pOmfStuff Where to collect CV8 debug info. * @param idxSeg The segment index. * @param off The segment offset. * @param uLine The line number. * @param offSrcInfo The source file info table offset. */ static bool collectOmfAddLine(POMFDETAILS pOmfStuff, uint16_t idxSeg, uint32_t off, uint16_t uLine, uint32_t offSrcInfo) { /* * Get/add the segment line structure. */ if (idxSeg >= pOmfStuff->cSegLines) { OMF_GROW_TABLE_EX_RET_ERR(OMFSEGLINES, pOmfStuff->paSegLines, pOmfStuff->cSegLines, idxSeg + 1); for (uint32_t i = pOmfStuff->cSegLines; i <= idxSeg; i++) { pOmfStuff->paSegLines[i].idxSeg = i; pOmfStuff->paSegLines[i].idxGrp = UINT16_MAX; pOmfStuff->paSegLines[i].cb = sizeof(RTCV8LINESHDR); } pOmfStuff->cSegLines = idxSeg + 1; } POMFSEGLINES pSegLines = &pOmfStuff->paSegLines[idxSeg]; /* * Get/add the file structure with the segment. */ POMFFILEINES pFileLines = NULL; uint32_t i = pSegLines->cFiles; while (i-- > 0) if (pSegLines->paFiles[i].offSrcInfo == offSrcInfo) { pFileLines = &pSegLines->paFiles[i]; break; } if (!pFileLines) { i = pSegLines->cFiles; OMF_GROW_TABLE_RET_ERR(OMFFILEINES, pSegLines->paFiles, pSegLines->cFiles, 4); pSegLines->cFiles = i + 1; pSegLines->cb += sizeof(RTCV8LINESSRCMAP); pFileLines = &pSegLines->paFiles[i]; pFileLines->offSrcInfo = offSrcInfo; pFileLines->cPairs = 0; pFileLines->cPairsAlloc = 0; pFileLines->paPairs = NULL; /* * Check for segment group requirements the first time a segment is used. */ if (i == 0) { if (idxSeg >= pOmfStuff->cSegDefs) return error("???", "collectOmfAddLine: idxSeg=%#x is out of bounds (%#x)!\n", idxSeg, pOmfStuff->cSegDefs); POMFSEGDEF pSegDef = &pOmfStuff->paSegDefs[idxSeg]; unsigned j = RT_ELEMENTS(pOmfStuff->aGroups); while (j-- > 0) if ( ( pSegDef->cchClass == pOmfStuff->aGroups[j].cchClass1 && memcmp(pSegDef->pchClass, pOmfStuff->aGroups[j].pszClass1, pSegDef->cchClass) == 0) || ( pSegDef->cchClass == pOmfStuff->aGroups[j].cchClass2 && memcmp(pSegDef->pchClass, pOmfStuff->aGroups[j].pszClass2, pSegDef->cchClass) == 0)) { pOmfStuff->aGroups[j].fNeeded = true; pSegLines->idxGrp = pOmfStuff->aGroups[j].idxReplaceGrp; break; } } } /* * Add the line number (sorted, duplicates removed). */ if (pFileLines->cPairs + 1 > pFileLines->cPairsAlloc) { void *pvNew = realloc(pFileLines->paPairs, (pFileLines->cPairsAlloc + 16) * sizeof(pFileLines->paPairs[0])); if (!pvNew) return error("???", "out of memory"); pFileLines->paPairs = (PRTCV8LINEPAIR)pvNew; pFileLines->cPairsAlloc += 16; } i = pFileLines->cPairs; while (i > 0 && ( off < pFileLines->paPairs[i - 1].offSection || ( off == pFileLines->paPairs[i - 1].offSection && uLine < pFileLines->paPairs[i - 1].uLineNumber)) ) i--; if ( i == pFileLines->cPairs || off != pFileLines->paPairs[i].offSection || uLine != pFileLines->paPairs[i].uLineNumber) { if (i < pFileLines->cPairs) memmove(&pFileLines->paPairs[i + 1], &pFileLines->paPairs[i], (pFileLines->cPairs - i) * sizeof(pFileLines->paPairs)); pFileLines->paPairs[i].offSection = off; pFileLines->paPairs[i].uLineNumber = uLine; pFileLines->paPairs[i].fEndOfStatement = true; pFileLines->cPairs++; pSegLines->cb += sizeof(pFileLines->paPairs[0]); } return true; } /** * Parses OMF file gathering line numbers (for CV8 debug info) and checking out * external defintions for mangling work (compiler instrinsics). * * @returns success indicator. * @param pszFile The name of the OMF file. * @param pbFile The file content. * @param cbFile The size of the file content. * @param pOmfStuff Where to collect CV8 debug info and anything else we * find out about the OMF file. */ static bool collectOmfDetails(const char *pszFile, uint8_t const *pbFile, size_t cbFile, POMFDETAILS pOmfStuff) { uint32_t cExtDefs = 0; uint32_t cPubDefs = 0; uint32_t off = 0; uint8_t cchSrcFile = 0; const char *pchSrcFile = NULL; uint32_t offSrcInfo = UINT32_MAX; memset(pOmfStuff, 0, sizeof(*pOmfStuff)); pOmfStuff->pszFile = pszFile; pOmfStuff->iDebSymNm = UINT16_MAX; pOmfStuff->iSymbolsNm = UINT16_MAX; pOmfStuff->iSymbolsSeg = UINT16_MAX; /* Dummy entries. */ OMF_GROW_TABLE_RET_ERR(char *, pOmfStuff->papchLNames, pOmfStuff->cLNames, 16); pOmfStuff->papchLNames[0] = (char *)""; pOmfStuff->cLNames = 1; OMF_GROW_TABLE_RET_ERR(OMFSEGDEF, pOmfStuff->paSegDefs, pOmfStuff->cSegDefs, 16); pOmfStuff->cSegDefs = 1; OMF_GROW_TABLE_RET_ERR(OMFGRPDEF, pOmfStuff->paGrpDefs, pOmfStuff->cGrpDefs, 16); pOmfStuff->cGrpDefs = 1; /* Groups we seek. */ #define OMF_INIT_WANTED_GROUP(a_idx, a_szName, a_szClass1, a_szClass2, a_pszSeg, a_idxReplace) \ pOmfStuff->aGroups[a_idx].pszName = a_szName; \ pOmfStuff->aGroups[a_idx].cchName = sizeof(a_szName) - 1; \ pOmfStuff->aGroups[a_idx].pszClass1 = a_szClass1; \ pOmfStuff->aGroups[a_idx].cchClass1 = sizeof(a_szClass1) - 1; \ pOmfStuff->aGroups[a_idx].pszClass2 = a_szClass2; \ pOmfStuff->aGroups[a_idx].cchClass2 = sizeof(a_szClass2) - 1; \ pOmfStuff->aGroups[a_idx].pszSeg = a_pszSeg; \ pOmfStuff->aGroups[a_idx].fNeeded = false; \ pOmfStuff->aGroups[a_idx].idxGroup = UINT16_MAX; \ pOmfStuff->aGroups[a_idx].idxName = UINT16_MAX; \ pOmfStuff->aGroups[a_idx].idxReplaceGrp = a_idxReplace OMF_INIT_WANTED_GROUP(0, "CGROUP16", "BS3CLASS16CODE", "CODE", NULL, OMF_REPLACE_GRP_CGROUP16); OMF_INIT_WANTED_GROUP(1, "BS3GROUPRMTEXT16", "BS3CLASS16RMCODE", "", "BS3RMTEXT16", OMF_REPLACE_GRP_RMCODE); OMF_INIT_WANTED_GROUP(2, "BS3GROUPX0TEXT16", "BS3CLASS16X0CODE", "", "BS3X0TEXT16", OMF_REPLACE_GRP_X0CODE); OMF_INIT_WANTED_GROUP(3, "BS3GROUPX1TEXT16", "BS3CLASS16X1CODE", "", "BS3X1TEXT16", OMF_REPLACE_GRP_X1CODE); /* * Process the OMF records. */ while (off + 3 < cbFile) { uint8_t bRecType = pbFile[off]; uint16_t cbRec = RT_MAKE_U16(pbFile[off + 1], pbFile[off + 2]); if (g_cVerbose > 2) printf( "%#07x: type=%#04x len=%#06x\n", off, bRecType, cbRec); if (off + cbRec > cbFile) return error(pszFile, "Invalid record length at %#x: %#x (cbFile=%#lx)\n", off, cbRec, (unsigned long)cbFile); uint32_t offRec = 0; uint8_t const *pbRec = &pbFile[off + 3]; #define OMF_CHECK_RET(a_cbReq, a_Name) /* Not taking the checksum into account, so we're good with 1 or 2 byte fields. */ \ if (offRec + (a_cbReq) <= cbRec) {/*likely*/} \ else return error(pszFile, "Malformed " #a_Name "! off=%#x offRec=%#x cbRec=%#x cbNeeded=%#x line=%d\n", \ off, offRec, cbRec, (a_cbReq), __LINE__) #define OMF_READ_IDX(a_idx, a_Name) \ do { \ OMF_CHECK_RET(2, a_Name); \ a_idx = pbRec[offRec++]; \ if ((a_idx) & 0x80) \ a_idx = (((a_idx) & 0x7f) << 8) | pbRec[offRec++]; \ } while (0) #define OMF_READ_U16(a_u16, a_Name) \ do { \ OMF_CHECK_RET(4, a_Name); \ a_u16 = RT_MAKE_U16(pbRec[offRec], pbRec[offRec + 1]); \ offRec += 2; \ } while (0) #define OMF_READ_U32(a_u32, a_Name) \ do { \ OMF_CHECK_RET(4, a_Name); \ a_u32 = RT_MAKE_U32_FROM_U8(pbRec[offRec], pbRec[offRec + 1], pbRec[offRec + 2], pbRec[offRec + 3]); \ offRec += 4; \ } while (0) switch (bRecType) { /* * Record LNAME records, scanning for FLAT. */ case OMF_LNAMES: while (offRec + 1 < cbRec) { uint8_t cch = pbRec[offRec]; if (offRec + 1 + cch >= cbRec) return error(pszFile, "Invalid LNAME string length at %#x+3+%#x: %#x (cbFile=%#lx)\n", off, offRec, cch, (unsigned long)cbFile); if (g_cVerbose > 2) printf(" LNAME[%u]: %-*.*s\n", pOmfStuff->cLNames, cch, cch, &pbRec[offRec + 1]); OMF_GROW_TABLE_RET_ERR(char *, pOmfStuff->papchLNames, pOmfStuff->cLNames, 16); pOmfStuff->papchLNames[pOmfStuff->cLNames] = (char *)&pbRec[offRec]; if (IS_OMF_STR_EQUAL_EX(cch, &pbRec[offRec + 1], "FLAT")) pOmfStuff->fProbably32bit = true; if (IS_OMF_STR_EQUAL_EX(cch, &pbRec[offRec + 1], "DEBSYM")) pOmfStuff->iDebSymNm = pOmfStuff->cLNames; if (IS_OMF_STR_EQUAL_EX(cch, &pbRec[offRec + 1], "$$SYMBOLS")) pOmfStuff->iSymbolsNm = pOmfStuff->cLNames; unsigned j = RT_ELEMENTS(pOmfStuff->aGroups); while (j-- > 0) if ( cch == pOmfStuff->aGroups[j].cchName && memcmp(&pbRec[offRec + 1], pOmfStuff->aGroups[j].pszName, pOmfStuff->aGroups[j].cchName) == 0) { pOmfStuff->aGroups[j].idxName = pOmfStuff->cLNames; break; } pOmfStuff->cLNames++; offRec += cch + 1; } break; /* * Display external definitions if -v is specified, also check if anything needs mangling. */ case OMF_EXTDEF: while (offRec + 1 < cbRec) { uint8_t cch = pbRec[offRec++]; OMF_CHECK_RET(cch, EXTDEF); char *pchName = (char *)&pbRec[offRec]; offRec += cch; uint16_t idxType; OMF_READ_IDX(idxType, EXTDEF); if (g_cVerbose > 2) printf(" EXTDEF [%u]: %-*.*s type=%#x\n", cExtDefs, cch, cch, pchName, idxType); else if (g_cVerbose > 0) printf(" U %-*.*s\n", cch, cch, pchName); /* Look for g_apszExtDefRenames entries that requires changing. */ if ( !pOmfStuff->fMayNeedMangling && cch >= 5 && cch <= 7 && pchName[0] == '_' && pchName[1] == '_' && ( pchName[2] == 'U' || pchName[2] == 'I' || pchName[2] == 'P') && ( pchName[3] == '4' || pchName[3] == '8' || pchName[3] == 'I' || pchName[3] == 'T') ) { pOmfStuff->fMayNeedMangling = true; } } break; /* * Display public names if -v is specified. */ case OMF_PUBDEF32: case OMF_LPUBDEF32: pOmfStuff->fProbably32bit = true; RT_FALL_THRU(); case OMF_PUBDEF16: case OMF_LPUBDEF16: if (g_cVerbose > 0) { char const chType = bRecType == OMF_PUBDEF16 || bRecType == OMF_PUBDEF32 ? 'T' : 't'; const char *pszRec = "LPUBDEF"; if (chType == 'T') pszRec++; uint16_t idxGrp; OMF_READ_IDX(idxGrp, [L]PUBDEF); uint16_t idxSeg; OMF_READ_IDX(idxSeg, [L]PUBDEF); uint16_t uFrameBase = 0; if (idxSeg == 0) { OMF_CHECK_RET(2, [L]PUBDEF); uFrameBase = RT_MAKE_U16(pbRec[offRec], pbRec[offRec + 1]); offRec += 2; } if (g_cVerbose > 2) printf(" %s: idxGrp=%#x idxSeg=%#x uFrameBase=%#x\n", pszRec, idxGrp, idxSeg, uFrameBase); uint16_t const uSeg = idxSeg ? idxSeg : uFrameBase; while (offRec + 1 < cbRec) { uint8_t cch = pbRec[offRec++]; OMF_CHECK_RET(cch, [L]PUBDEF); const char *pchName = (const char *)&pbRec[offRec]; offRec += cch; uint32_t offSeg; if (bRecType & OMF_REC32) { OMF_CHECK_RET(4, [L]PUBDEF); offSeg = RT_MAKE_U32_FROM_U8(pbRec[offRec], pbRec[offRec + 1], pbRec[offRec + 2], pbRec[offRec + 3]); offRec += 4; } else { OMF_CHECK_RET(2, [L]PUBDEF); offSeg = RT_MAKE_U16(pbRec[offRec], pbRec[offRec + 1]); offRec += 2; } uint16_t idxType; OMF_READ_IDX(idxType, [L]PUBDEF); if (g_cVerbose > 2) printf(" %s[%u]: off=%#010x type=%#x %-*.*s\n", pszRec, cPubDefs, offSeg, idxType, cch, cch, pchName); else if (g_cVerbose > 0) printf("%04x:%08x %c %-*.*s\n", uSeg, offSeg, chType, cch, cch, pchName); } } break; /* * Must count segment definitions to figure the index of our segment. */ case OMF_SEGDEF16: case OMF_SEGDEF32: { OMF_GROW_TABLE_RET_ERR(OMFSEGDEF, pOmfStuff->paSegDefs, pOmfStuff->cSegDefs, 16); POMFSEGDEF pSegDef = &pOmfStuff->paSegDefs[pOmfStuff->cSegDefs++]; OMF_CHECK_RET(1 + (bRecType == OMF_SEGDEF16 ? 2 : 4) + 1 + 1 + 1, SEGDEF); pSegDef->f32bitRec = bRecType == OMF_SEGDEF32; pSegDef->bSegAttr = pbRec[offRec++]; pSegDef->fUse32 = pSegDef->bSegAttr & 1; if ((pSegDef->bSegAttr >> 5) == 0) { /* A=0: skip frame number of offset. */ OMF_CHECK_RET(3, SEGDEF); offRec += 3; } if (bRecType == OMF_SEGDEF16) OMF_READ_U16(pSegDef->cbSeg, SEGDEF16); else OMF_READ_U32(pSegDef->cbSeg, SEGDEF32); OMF_READ_IDX(pSegDef->idxName, SEGDEF); OMF_READ_IDX(pSegDef->idxClass, SEGDEF); OMF_READ_IDX(pSegDef->idxOverlay, SEGDEF); OMF_EXPLODE_LNAME(pOmfStuff, pSegDef->idxName, pSegDef->pchName, pSegDef->cchName, SEGDEF); OMF_EXPLODE_LNAME(pOmfStuff, pSegDef->idxClass, pSegDef->pchClass, pSegDef->cchClass, SEGDEF); OMF_EXPLODE_LNAME(pOmfStuff, pSegDef->idxOverlay, pSegDef->pchOverlay, pSegDef->cchOverlay, SEGDEF); break; } /* * Must count segment definitions to figure the index of our group. */ case OMF_GRPDEF: { OMF_GROW_TABLE_RET_ERR(OMFGRPDEF, pOmfStuff->paGrpDefs, pOmfStuff->cGrpDefs, 8); POMFGRPDEF pGrpDef = &pOmfStuff->paGrpDefs[pOmfStuff->cGrpDefs]; OMF_READ_IDX(pGrpDef->idxName, GRPDEF); OMF_EXPLODE_LNAME(pOmfStuff, pGrpDef->idxName, pGrpDef->pchName, pGrpDef->cchName, GRPDEF); unsigned j = RT_ELEMENTS(pOmfStuff->aGroups); while (j-- > 0) if (pGrpDef->idxName == pOmfStuff->aGroups[j].idxName) { pOmfStuff->aGroups[j].idxGroup = pOmfStuff->cGrpDefs; break; } pGrpDef->cSegDefs = 0; pGrpDef->paidxSegDefs = NULL; while (offRec + 2 + 1 <= cbRec) { if (pbRec[offRec] != 0xff) return error(pszFile, "Unsupported GRPDEF member type: %#x\n", pbRec[offRec]); offRec++; OMF_GROW_TABLE_RET_ERR(uint16_t, pGrpDef->paidxSegDefs, pGrpDef->cSegDefs, 16); OMF_READ_IDX(pGrpDef->paidxSegDefs[pGrpDef->cSegDefs], GRPDEF); pGrpDef->cSegDefs++; } pOmfStuff->cGrpDefs++; break; } /* * Gather file names. */ case OMF_THEADR: /* watcom */ cchSrcFile = pbRec[offRec++]; OMF_CHECK_RET(cchSrcFile, OMF_THEADR); pchSrcFile = (const char *)&pbRec[offRec]; if (!collectOmfAddFile(pOmfStuff, cchSrcFile, pchSrcFile, &offSrcInfo)) return false; break; case OMF_COMENT: { OMF_CHECK_RET(2, COMENT); offRec++; /* skip the type (flags) */ uint8_t bClass = pbRec[offRec++]; if (bClass == OMF_CCLS_BORLAND_SRC_FILE) /* nasm */ { OMF_CHECK_RET(1+1+4, BORLAND_SRC_FILE); offRec++; /* skip unknown byte */ cchSrcFile = pbRec[offRec++]; OMF_CHECK_RET(cchSrcFile + 4, BORLAND_SRC_FILE); pchSrcFile = (const char *)&pbRec[offRec]; offRec += cchSrcFile; if (offRec + 4 + 1 != cbRec) return error(pszFile, "BAD BORLAND_SRC_FILE record at %#x: %d bytes left\n", off, cbRec - offRec - 4 - 1); if (!collectOmfAddFile(pOmfStuff, cchSrcFile, pchSrcFile, &offSrcInfo)) return false; break; } break; } /* * Line number conversion. */ case OMF_LINNUM16: case OMF_LINNUM32: { uint16_t idxGrp; OMF_READ_IDX(idxGrp, LINNUM); uint16_t idxSeg; OMF_READ_IDX(idxSeg, LINNUM); uint16_t iLine; uint32_t offSeg; if (bRecType == OMF_LINNUM16) while (offRec + 4 < cbRec) { iLine = RT_MAKE_U16(pbRec[offRec + 0], pbRec[offRec + 1]); offSeg = RT_MAKE_U16(pbRec[offRec + 2], pbRec[offRec + 3]); if (!collectOmfAddLine(pOmfStuff, idxSeg, offSeg, iLine, offSrcInfo)) return false; offRec += 4; } else while (offRec + 6 < cbRec) { iLine = RT_MAKE_U16(pbRec[offRec + 0], pbRec[offRec + 1]); offSeg = RT_MAKE_U32_FROM_U8(pbRec[offRec + 2], pbRec[offRec + 3], pbRec[offRec + 4], pbRec[offRec + 5]); if (!collectOmfAddLine(pOmfStuff, idxSeg, offSeg, iLine, offSrcInfo)) return false; offRec += 6; } if (offRec + 1 != cbRec) return error(pszFile, "BAD LINNUM record at %#x: %d bytes left\n", off, cbRec - offRec - 1); break; } } /* advance */ off += cbRec + 3; } return true; #undef OMF_READ_IDX #undef OMF_CHECK_RET } /** * Adds a LNAMES entry (returns existing). * * @returns success indicator. * @param pOmfStuff The OMF stuff. * @param pszName The name to add. * @param pidxName Where to return the name index. */ static bool omfDetails_AddLName(POMFDETAILS pOmfStuff, const char *pszName, uint16_t *pidxName) { size_t const cchName = strlen(pszName); /* * Check if we've already got the name. */ for (unsigned iName = 1; iName < pOmfStuff->cLNames; iName++) if ( (unsigned char)pOmfStuff->papchLNames[iName][0] == cchName && memcmp(pOmfStuff->papchLNames[iName] + 1, pszName, cchName) == 0) { *pidxName = iName; return true; } /* * Not found, append it. */ char *pszCopy = (char *)omfDetails_Alloc(pOmfStuff, cchName + 2); if (!pszCopy) return false; *(unsigned char *)&pszCopy[0] = (unsigned char)cchName; memcpy(pszCopy + 1, pszName, cchName + 1); OMF_GROW_TABLE_RET_ERR(char *, pOmfStuff->papchLNames, pOmfStuff->cLNames, 16); pOmfStuff->papchLNames[pOmfStuff->cLNames] = (char *)pszCopy; *pidxName = pOmfStuff->cLNames; pOmfStuff->cLNames++; return true; } /** * Adds a SEGDEF (always adds a new one). * * @returns success indicator. * @param pOmfStuff The OMF stuff. * @param bSegAttr The OMF segment attributes. * @param cbSeg The segment size. * @param idxSegName The LNAMES index of the segment name. * @param idxSegClas The LNAMES index of the segment class. * @param idxOverlay The LNAMES index of the overlay name; pass 1. * @param fRec32 Set if SEGDEF32 should be emitted, clear for SEGDEF16. * @param pidxSeg Where to return the segment index. */ static bool omfDetails_AddSegDef(POMFDETAILS pOmfStuff, uint8_t bSegAttr, uint32_t cbSeg, uint16_t idxSegName, uint16_t idxSegClass, uint16_t idxOverlay, bool fRec32, uint16_t *pidxSeg) { Assert(cbSeg <= UINT16_MAX || fRec32); Assert(idxSegName < pOmfStuff->cLNames); Assert(idxSegClass < pOmfStuff->cLNames); OMF_GROW_TABLE_RET_ERR(OMFSEGDEF, pOmfStuff->paSegDefs, pOmfStuff->cSegDefs, 16); POMFSEGDEF pSegDef = &pOmfStuff->paSegDefs[pOmfStuff->cSegDefs]; pSegDef->bSegAttr = bSegAttr; pSegDef->fUse32 = bSegAttr & 1; pSegDef->f32bitRec = fRec32; pSegDef->cbSeg = cbSeg; pSegDef->idxName = idxSegName; pSegDef->idxClass = idxSegClass; pSegDef->idxOverlay = idxOverlay; OMF_EXPLODE_LNAME(pOmfStuff, pSegDef->idxName, pSegDef->pchName, pSegDef->cchName, SEGDEF); OMF_EXPLODE_LNAME(pOmfStuff, pSegDef->idxClass, pSegDef->pchClass, pSegDef->cchClass, SEGDEF); OMF_EXPLODE_LNAME(pOmfStuff, pSegDef->idxOverlay, pSegDef->pchOverlay, pSegDef->cchOverlay, SEGDEF); *pidxSeg = pOmfStuff->cSegDefs; pOmfStuff->cSegDefs++; return true; } /** * Adds a SEGDEF if not found. * * @returns success indicator. * @param pOmfStuff The OMF stuff. * @param bSegAttr The OMF segment attributes. * @param cbSeg The segment size. * @param idxSegName The LNAMES index of the segment name. * @param idxSegClas The LNAMES index of the segment class. * @param idxOverlay The LNAMES index of the overlay name; pass 1. * @param fRec32 Set if SEGDEF32 should be emitted, clear for SEGDEF16. * @param pidxSeg Where to return the segment index. */ static bool omfDetails_AddSegDefIfNeeded(POMFDETAILS pOmfStuff, uint8_t bSegAttr, uint32_t cbSeg, uint16_t idxSegName, uint16_t idxSegClass, uint16_t idxOverlay, bool fRec32, uint16_t *pidxSeg) { /* Search for name */ for (unsigned iSegDef = 1; iSegDef < pOmfStuff->cSegDefs; iSegDef++) { POMFSEGDEF pSegDef = &pOmfStuff->paSegDefs[iSegDef]; if (pSegDef->idxName == idxSegName) { if ( pSegDef->bSegAttr != bSegAttr || pSegDef->f32bitRec != fRec32 || pSegDef->idxName != idxSegName || pSegDef->idxClass != idxSegClass || pSegDef->idxOverlay != idxOverlay) return error(pOmfStuff->pszFile, "Existing SEGDEF differs: bSegAttr=%#x vs %#x, f32bitRec=%d vs %d, idxName=%#x vs %#x, idxClass=%#x vs %#x, idxOverlay=%#x vs %#x\n", pSegDef->bSegAttr, bSegAttr, pSegDef->f32bitRec, fRec32, pSegDef->idxName, idxSegName, pSegDef->idxClass, idxSegClass, pSegDef->idxOverlay, idxOverlay); *pidxSeg = iSegDef; return true; } } return omfDetails_AddSegDef(pOmfStuff, bSegAttr, cbSeg, idxSegName, idxSegClass, idxOverlay, fRec32, pidxSeg); } #if 0 /* unused */ /** * Looks up a GRPDEF in the . * * @returns Index (0..32K) if found, UINT16_MAX if not found. * @param pOmfStuff The OMF stuff. * @param pchName The name to look up. * @param cchName The length of the name. */ static uint16_t omfDetails_GrpDefLookupN(POMFDETAILS pOmfStuff, const char *pchName, size_t cchName) { unsigned iGrpDef = pOmfStuff->cGrpDefs; while (iGrpDef-- > 0) { if ( pOmfStuff->paGrpDefs[iGrpDef].cchName == cchName && memcmp(pOmfStuff->paGrpDefs[iGrpDef].pchName, pchName, cchName) == 0) return iGrpDef; } return UINT16_MAX; } #endif /** * Adds an empty GRPDEF (always adds a new one). * * @returns success indicator. * @param pOmfStuff The OMF stuff. * @param idxGrpName The LNAMES index of the group name. * @param pidxGrp Where to return the group index. */ static bool omfDetails_AddGrpDef(POMFDETAILS pOmfStuff, uint16_t idxGrpName, uint16_t *pidxGrp) { Assert(idxGrpName < pOmfStuff->cLNames); OMF_GROW_TABLE_RET_ERR(OMFGRPDEF, pOmfStuff->paGrpDefs, pOmfStuff->cGrpDefs, 8); POMFGRPDEF pGrpDef = &pOmfStuff->paGrpDefs[pOmfStuff->cGrpDefs]; pGrpDef->idxName = idxGrpName; pGrpDef->cSegDefs = 0; pGrpDef->paidxSegDefs = NULL; *pidxGrp = pOmfStuff->cGrpDefs; pOmfStuff->cGrpDefs++; return true; } /** * Adds a segment to an existing GRPDEF. * * @returns success indicator. * @param pOmfStuff The OMF stuff. * @param idxGrp The GRPDEF index of the group to append a member to. * @param idxSeg The SEGDEF index of the segment name. */ static bool omfDetails_AddSegToGrpDef(POMFDETAILS pOmfStuff, uint16_t idxGrp, uint16_t idxSeg) { Assert(idxGrp < pOmfStuff->cGrpDefs && idxGrp > 0); Assert(idxSeg < pOmfStuff->cSegDefs && idxSeg > 0); POMFGRPDEF pGrpDef = &pOmfStuff->paGrpDefs[idxGrp]; OMF_GROW_TABLE_RET_ERR(uint16_t, pGrpDef->paidxSegDefs, pGrpDef->cSegDefs, 16); pGrpDef->paidxSegDefs[pGrpDef->cSegDefs] = idxSeg; pGrpDef->cSegDefs++; return true; } /** * Marks 16-bit code segment groups that is used in the object file as needed. * * @param pOmfStuff The OMF stuff. */ static void convertOmfLookForNeededGroups(POMFDETAILS pOmfStuff) { /* * Consult the groups in question. We mark the groups which segments are * included in the segment definitions as needed. */ unsigned i = RT_ELEMENTS(pOmfStuff->aGroups); while (i-- > 0) if (pOmfStuff->aGroups[i].pszSeg) { const char * const pszSegNm = pOmfStuff->aGroups[i].pszSeg; size_t const cchSegNm = strlen(pszSegNm); for (unsigned iSegDef = 0; iSegDef < pOmfStuff->cSegDefs; iSegDef++) if ( pOmfStuff->paSegDefs[iSegDef].cchName == cchSegNm && memcmp(pOmfStuff->paSegDefs[iSegDef].pchName, pszSegNm, cchSegNm) == 0) { pOmfStuff->aGroups[i].fNeeded = true; break; } } } /** * Adds necessary group and segment definitions. * * @returns success indicator. * @param pOmfStuff The OMF stuff. */ static bool convertOmfAddNeededGrpDefs(POMFDETAILS pOmfStuff) { /* * Process the groups. */ unsigned j = RT_ELEMENTS(pOmfStuff->aGroups); while (j-- > 0) if (pOmfStuff->aGroups[j].fNeeded) { if (pOmfStuff->aGroups[j].idxName == UINT16_MAX) { Assert(pOmfStuff->aGroups[j].idxGroup == UINT16_MAX); if (!omfDetails_AddLName(pOmfStuff, pOmfStuff->aGroups[j].pszName, &pOmfStuff->aGroups[j].idxName)) return false; } if (pOmfStuff->aGroups[j].idxGroup == UINT16_MAX) { if (!omfDetails_AddGrpDef(pOmfStuff, pOmfStuff->aGroups[j].idxName, &pOmfStuff->aGroups[j].idxGroup)) return false; if (pOmfStuff->aGroups[j].pszSeg) { /* We need the segment class name. */ uint16_t idxSegClass; if (!omfDetails_AddLName(pOmfStuff, pOmfStuff->aGroups[j].pszClass1, &idxSegClass)) return false; /* Prep segment name buffer. */ size_t cchSegNm = strlen(pOmfStuff->aGroups[j].pszSeg); char szSegNm[256+16]; Assert(cchSegNm < 256); memcpy(szSegNm, pOmfStuff->aGroups[j].pszSeg, cchSegNm); /* Add the three segments. */ static RTSTRTUPLE const s_aSuffixes[3] = { {RT_STR_TUPLE("_START")}, {RT_STR_TUPLE("")}, {RT_STR_TUPLE("_END")}, }; for (unsigned iSuffix = 0; iSuffix < RT_ELEMENTS(s_aSuffixes); iSuffix++) { uint16_t idxSegNm; memcpy(&szSegNm[cchSegNm], s_aSuffixes[iSuffix].psz, s_aSuffixes[iSuffix].cch + 1); if (!omfDetails_AddLName(pOmfStuff, szSegNm, &idxSegNm)) return false; uint8_t const fAlign = iSuffix == 1 ? OMF_SEG_ATTR_ALIGN_BYTE : OMF_SEG_ATTR_ALIGN_PARA; uint16_t idxSeg; if (!omfDetails_AddSegDefIfNeeded(pOmfStuff, fAlign | OMF_SEG_ATTR_COMB_PUBLIC | OMF_SEG_ATTR_USE16, 0, idxSegNm, idxSegClass, 1, false /*fRec*/, &idxSeg)) return false; if (!omfDetails_AddSegToGrpDef(pOmfStuff, pOmfStuff->aGroups[j].idxGroup, idxSeg)) return false; } } } } /* * Replace group references in the segment lines table. */ j = RT_ELEMENTS(pOmfStuff->aGroups); while (j-- > 0) if (pOmfStuff->aGroups[j].fNeeded) for (unsigned i = 0; i < pOmfStuff->cSegLines; i++) if (pOmfStuff->paSegLines[i].idxGrp == pOmfStuff->aGroups[j].idxReplaceGrp) pOmfStuff->paSegLines[i].idxGrp = pOmfStuff->aGroups[j].idxGroup; return true; } /** * Adds the debug segment definitions (names too) to the OMF state. * * @returns success indicator. * @param pOmfStuff The OMF stuff with CV8 line number info. */ static bool convertOmfAddDebugSegDefs(POMFDETAILS pOmfStuff) { if ( pOmfStuff->cSegLines == 0 || pOmfStuff->iSymbolsSeg != UINT16_MAX) return true; /* * Add the names we need. */ if ( pOmfStuff->iSymbolsNm == UINT16_MAX && !omfDetails_AddLName(pOmfStuff, "$$SYMBOLS", &pOmfStuff->iSymbolsNm)) return false; if ( pOmfStuff->iDebSymNm == UINT16_MAX && !omfDetails_AddLName(pOmfStuff, "DEBSYM", &pOmfStuff->iDebSymNm)) return false; /* * Add the segment definition. */ uint8_t bSegAttr = 0; bSegAttr |= 5 << 5; /* A: dword alignment */ bSegAttr |= 0 << 2; /* C: private */ bSegAttr |= 0 << 1; /* B: not big */ bSegAttr |= 1; /* D: use32 */ /* calc the segment size. */ uint32_t cbSeg = 4; /* dword 4 */ cbSeg += 4 + 4 + RT_ALIGN_32(pOmfStuff->cbStrTab, 4); cbSeg += 4 + 4 + pOmfStuff->cSrcInfo * sizeof(pOmfStuff->paSrcInfo[0]); uint32_t i = pOmfStuff->cSegLines; while (i-- > 0) if (pOmfStuff->paSegLines[i].cFiles > 0) cbSeg += 4 + 4 + pOmfStuff->paSegLines[i].cb; return omfDetails_AddSegDef(pOmfStuff, bSegAttr, cbSeg, pOmfStuff->iSymbolsNm, pOmfStuff->iDebSymNm, 1 /*idxOverlay*/, true /*fRec32*/, &pOmfStuff->iSymbolsSeg); } /** * Writes the debug segment data. * * @returns success indicator. * @param pThis The OMF writer. * @param pOmfStuff The OMF stuff with CV8 line number info. */ static bool convertOmfWriteDebugData(POMFWRITER pThis, POMFDETAILS pOmfStuff) { if (pOmfStuff->cSegLines == 0) return true; Assert(pOmfStuff->iSymbolsSeg != UINT16_MAX); /* Begin and write the CV version signature. */ if ( !omfWriter_LEDataBegin(pThis, pOmfStuff->iSymbolsSeg, 0) || !omfWriter_LEDataAddU32(pThis, RTCVSYMBOLS_SIGNATURE_CV8)) return false; /* * Emit the string table (no fixups). */ uint32_t cbLeft = pOmfStuff->cbStrTab; if ( !omfWriter_LEDataAddU32(pThis, RTCV8SYMBLOCK_TYPE_SRC_STR) || !omfWriter_LEDataAddU32(pThis, cbLeft) || !omfWriter_LEDataAddBytes(pThis, pOmfStuff->pchStrTab, RT_ALIGN_32(cbLeft, 4)) ) /* table is zero padded to nearest dword */ return false; /* * Emit the source file info table (no fixups). */ cbLeft = pOmfStuff->cSrcInfo * sizeof(pOmfStuff->paSrcInfo[0]); if ( !omfWriter_LEDataAddU32(pThis, RTCV8SYMBLOCK_TYPE_SRC_INFO) || !omfWriter_LEDataAddU32(pThis, cbLeft) || !omfWriter_LEDataAddBytes(pThis, pOmfStuff->paSrcInfo, cbLeft) ) return false; /* * Emit the segment line numbers. There are two fixups here at the start * of each chunk. */ POMFSEGLINES pSegLines = pOmfStuff->paSegLines; uint32_t i = pOmfStuff->cSegLines; while (i-- > 0) { if (pSegLines->cFiles) { /* Calc covered area. */ uint32_t cbSectionCovered = 0; uint32_t j = pSegLines->cFiles; while (j-- > 0) { uint32_t offLast = pSegLines->paFiles[j].paPairs[pSegLines->paFiles[j].cPairs - 1].offSection; if (offLast > cbSectionCovered) offLast = cbSectionCovered; } /* For simplicity and debuggability, just split the LEDATA here. */ if ( !omfWriter_LEDataSplit(pThis) || !omfWriter_LEDataAddU32(pThis, RTCV8SYMBLOCK_TYPE_SECT_LINES) || !omfWriter_LEDataAddU32(pThis, pSegLines->cb) || !omfWriter_LEDataAddU32(pThis, 0) /*RTCV8LINESHDR::offSection*/ || !omfWriter_LEDataAddU16(pThis, 0) /*RTCV8LINESHDR::iSection*/ || !omfWriter_LEDataAddU16(pThis, 0) /*RTCV8LINESHDR::u16Padding*/ || !omfWriter_LEDataAddU32(pThis, cbSectionCovered) /*RTCV8LINESHDR::cbSectionCovered*/ ) return false; /* Default to the segment (BS3TEXT32, BS3TEXT64) or the group (CGROUP16, RMGROUP16, etc). The important thing is that we're framing the fixups using a segment or group which ends up in the codeview segment map. */ uint16_t idxFrame = pSegLines->idxSeg; uint8_t bFrame = OMF_FIX_F_SEGDEF; if (pSegLines->idxGrp != UINT16_MAX) { idxFrame = pSegLines->idxGrp; bFrame = OMF_FIX_F_GRPDEF; } /* Fixup #1: segment offset - IMAGE_REL_AMD64_SECREL. */ if (!omfWriter_LEDataAddFixupNoDisp(pThis, 4 + 4 + RT_UOFFSETOF(RTCV8LINESHDR, offSection), OMF_FIX_LOC_32BIT_OFFSET, bFrame, idxFrame, OMF_FIX_T_SEGDEF_NO_DISP, pSegLines->idxSeg)) return false; /* Fixup #2: segment number - IMAGE_REL_AMD64_SECTION. */ if (!omfWriter_LEDataAddFixupNoDisp(pThis, 4 + 4 + RT_UOFFSETOF(RTCV8LINESHDR, iSection), OMF_FIX_LOC_16BIT_SEGMENT, bFrame, idxFrame, OMF_FIX_T_SEGDEF_NO_DISP, pSegLines->idxSeg)) return false; /* Emit data for each source file. */ for (j = 0; j < pSegLines->cFiles; j++) { uint32_t const cbPairs = pSegLines->paFiles[j].cPairs * sizeof(RTCV8LINEPAIR); if ( !omfWriter_LEDataAddU32(pThis, pSegLines->paFiles[j].offSrcInfo) /*RTCV8LINESSRCMAP::offSourceInfo*/ || !omfWriter_LEDataAddU32(pThis, pSegLines->paFiles[j].cPairs) /*RTCV8LINESSRCMAP::cLines*/ || !omfWriter_LEDataAddU32(pThis, cbPairs + sizeof(RTCV8LINESSRCMAP)) /*RTCV8LINESSRCMAP::cb*/ || !omfWriter_LEDataAddBytes(pThis, pSegLines->paFiles[j].paPairs, cbPairs)) return false; } } pSegLines++; } return omfWriter_LEDataEnd(pThis); } /** * Writes out all the segment group definitions. * * @returns success indicator. * @param pThis The OMF writer. * @param pOmfStuff The OMF stuff containing the segment defs. * @param pfFlushState Pointer to the flush state variable. */ static bool convertOmfWriteAllSegDefs(POMFWRITER pThis, POMFDETAILS pOmfStuff, int *pfFlushState) { if (*pfFlushState > 0) { for (unsigned iSegDef = 1; iSegDef < pOmfStuff->cSegDefs; iSegDef++) { if (!(pOmfStuff->paSegDefs[iSegDef].f32bitRec ? omfWriter_SegDef : omfWriter_SegDef16)(pThis, pOmfStuff->paSegDefs[iSegDef].bSegAttr, pOmfStuff->paSegDefs[iSegDef].cbSeg, pOmfStuff->paSegDefs[iSegDef].idxName, pOmfStuff->paSegDefs[iSegDef].idxClass, pOmfStuff->paSegDefs[iSegDef].idxOverlay)) return false; } *pfFlushState = -1; } return true; } /** * Writes out all the segment group definitions. * * @returns success indicator. * @param pThis The OMF writer. * @param pOmfStuff The OMF stuff containing the group defs. * @param pfFlushState Pointer to the flush state variable. */ static bool convertOmfWriteAllGrpDefs(POMFWRITER pThis, POMFDETAILS pOmfStuff, int *pfFlushState) { if (*pfFlushState > 0) { for (unsigned iGrpDef = 1; iGrpDef < pOmfStuff->cGrpDefs; iGrpDef++) { if (!omfWriter_GrpDefBegin(pThis, pOmfStuff->paGrpDefs[iGrpDef].idxName)) return false; for (unsigned iSegDef = 0; iSegDef < pOmfStuff->paGrpDefs[iGrpDef].cSegDefs; iSegDef++) if (!omfWriter_GrpDefAddSegDef(pThis, pOmfStuff->paGrpDefs[iGrpDef].paidxSegDefs[iSegDef])) return false; if (!omfWriter_GrpDefEnd(pThis)) return false; } *pfFlushState = -1; } return true; } /** * This does the actual converting, passthru style. * * It only modifies, removes and inserts stuff it care about, the rest is passed * thru as-is. * * @returns success indicator. * @param pThis The OMF writer. * @param pbFile The original file content. * @param cbFile The size of the original file. * @param pOmfStuff The OMF stuff we've gathered during the first pass, * contains CV8 line number info if we converted anything. * @param fConvertLineNumbers Whether we're converting line numbers and stuff. */ static bool convertOmfPassthru(POMFWRITER pThis, uint8_t const *pbFile, size_t cbFile, POMFDETAILS pOmfStuff, bool fConvertLineNumbers) { int fFlushLNames = 1; int fFlushSegDefs = 1; int fFlushGrpDefs = 1; bool fSeenTheAdr = false; bool fConvertFixupp = false; uint32_t off = 0; while (off + 3 < cbFile) { uint8_t bRecType = pbFile[off]; uint16_t cbRec = RT_MAKE_U16(pbFile[off + 1], pbFile[off + 2]); uint32_t offRec = 0; uint8_t const *pbRec = &pbFile[off + 3]; #define OMF_READ_IDX(a_idx, a_Name) \ do { \ a_idx = pbRec[offRec++]; \ if ((a_idx) & 0x80) \ a_idx = (((a_idx) & 0x7f) << 8) | pbRec[offRec++]; \ } while (0) #define OMF_PEEK_IDX(a_idx, a_offRec) \ do { \ a_idx = pbRec[a_offRec]; \ if ((a_idx) & 0x80) \ a_idx = (((a_idx) & 0x7f) << 8) | pbRec[(a_offRec) + 1]; \ } while (0) /* * Remove/insert switch. will */ bool fSkip = false; switch (bRecType) { /* * Mangle watcom intrinsics if necessary. */ case OMF_EXTDEF: if (pOmfStuff->fMayNeedMangling) { if (!omfWriter_ExtDefBegin(pThis)) return false; while (offRec + 1 < cbRec) { uint8_t cchName = pbRec[offRec++]; char *pchName = (char *)&pbRec[offRec]; offRec += cchName; uint16_t idxType; OMF_READ_IDX(idxType, EXTDEF); /* Look for g_apszExtDefRenames entries that requires changing. */ if ( cchName >= 5 && cchName <= 7 && pchName[0] == '_' && pchName[1] == '_' && ( pchName[2] == 'U' || pchName[2] == 'I' || pchName[2] == 'P') && ( pchName[3] == '4' || pchName[3] == '8' || pchName[3] == 'I' || pchName[3] == 'T') ) { char szName[12]; memcpy(szName, pchName, cchName); szName[cchName] = '\0'; uint32_t i = RT_ELEMENTS(g_apszExtDefRenames); while (i-- > 0) if ( cchName == (uint8_t)g_apszExtDefRenames[i][0] && memcmp(&g_apszExtDefRenames[i][1], szName, cchName) == 0) { szName[0] = pOmfStuff->fProbably32bit ? '?' : '_'; szName[1] = '?'; break; } if (!omfWriter_ExtDefAddN(pThis, szName, cchName, idxType, false /*fPrependUnderscore*/)) return false; } else if (!omfWriter_ExtDefAddN(pThis, pchName, cchName, idxType, false /*fPrependUnderscore*/)) return false; } if (!omfWriter_ExtDefEnd(pThis)) return false; fSkip = true; } break; /* * Remove line number records. */ case OMF_LINNUM16: case OMF_LINNUM32: fSkip = fConvertLineNumbers; break; /* * Remove all but the first OMF_THEADR. */ case OMF_THEADR: fSkip = fSeenTheAdr && fConvertLineNumbers; fSeenTheAdr = true; break; /* * Remove borland source file changes. Also, make sure the group * definitions are written out. */ case OMF_COMENT: if (pbRec[1] == OMF_CCLS_LINK_PASS_SEP) { Assert(fFlushSegDefs <= 0); if ( fFlushGrpDefs > 0 && !convertOmfWriteAllGrpDefs(pThis, pOmfStuff, &fFlushGrpDefs)) return false; } if (fConvertLineNumbers) fSkip = pbRec[1] == OMF_CCLS_BORLAND_SRC_FILE; break; /* * Redo these so the OMF writer is on top of the index thing. */ case OMF_LNAMES: if (fFlushLNames >= 0) { if (!omfWriter_LNamesBegin(pThis, false /*fAddZeroEntry*/)) return false; if (!fFlushLNames) { while (offRec + 1 < cbRec) { uint8_t cch = pbRec[offRec]; const char *pch = (const char *)&pbRec[offRec + 1]; if (!omfWriter_LNamesAddN(pThis, pch, cch, NULL)) return false; offRec += cch + 1; } } else { /* Flush all LNAMES in one go. */ for (unsigned i = 1; i < pOmfStuff->cLNames; i++) if (!omfWriter_LNamesAddN(pThis, pOmfStuff->papchLNames[i] + 1, *pOmfStuff->papchLNames[i], NULL)) return false; fFlushLNames = -1; } if (!omfWriter_LNamesEnd(pThis)) return false; } fSkip = true; break; /* * We may want to flush all the segments when we see the first one. */ case OMF_SEGDEF16: case OMF_SEGDEF32: fSkip = fFlushSegDefs != 0; if (!convertOmfWriteAllSegDefs(pThis, pOmfStuff, &fFlushSegDefs)) return false; break; /* * We may want to flush all the groups when we see the first one. */ case OMF_GRPDEF: fSkip = fFlushGrpDefs != 0; if (!convertOmfWriteAllGrpDefs(pThis, pOmfStuff, &fFlushGrpDefs)) return false; break; /* * Hook LEDATA to flush groups and figure out when to convert FIXUPP records. */ case OMF_LEDATA16: case OMF_LEDATA32: if ( fFlushGrpDefs > 0 && !convertOmfWriteAllGrpDefs(pThis, pOmfStuff, &fFlushGrpDefs)) return false; fConvertFixupp = false; #if 0 if ( g_f16BitWatcomC && bRecType == OMF_LEDATA16) { /* Check if this is a code segment. */ uint16_t idxSeg; OMF_PEEK_IDX(idxSeg, offRec); } #endif break; /* * Convert fixups for 16-bit code segments to groups. * Deals with switch table trouble. */ case OMF_FIXUPP16: if (fConvertFixupp) { /* Gave up on this for now, easier to drop the eyecatcher in the _START segments. */ } break; /* * Upon seeing MODEND we write out the debug info. */ case OMF_MODEND16: case OMF_MODEND32: if (fConvertLineNumbers) if (!convertOmfWriteDebugData(pThis, pOmfStuff)) return false; break; } /* * Pass the record thru, if so was decided. */ if (!fSkip) { if ( omfWriter_RecBegin(pThis, bRecType) && omfWriter_RecAddBytes(pThis, pbRec, cbRec) && omfWriter_RecEnd(pThis, false)) { /* likely */ } else return false; } /* advance */ off += cbRec + 3; } return true; } /** * Converts LINNUMs and compiler intrinsics in an OMF object file. * * Wlink does a cheesy (to use their own term) job of generating the * sstSrcModule subsection. It is limited to one file and cannot deal with line * numbers in different segment. The latter is very annoying in assembly files * that jumps between segments, these a frequent on crash stacks. * * The solution is to convert to the same line number tables that cl.exe /Z7 * generates for our 64-bit C code, we named that format codeview v8, or CV8. * Our code codeview debug info reader can deal with this already because of the * 64-bit code, so Bob's your uncle. * * @returns success indicator. * @param pszFile The name of the file being converted. * @param pbFile The file content. * @param cbFile The size of the file content. * @param pDst The destiation (output) file. */ static bool convertOmfToOmf(const char *pszFile, uint8_t const *pbFile, size_t cbFile, FILE *pDst) { bool const fConvertLineNumbers = true; /* * Collect line number information, names, segment defintions, groups definitions and such. */ OMFDETAILS OmfStuff; if (!collectOmfDetails(pszFile, pbFile, cbFile, &OmfStuff)) return false; /* Mark groups for 16-bit code segments used by this object file as needed so we can reframe fixups to these segments correctly. */ convertOmfLookForNeededGroups(&OmfStuff); /* Add debug segments definitions. */ bool fRc = true; if (fConvertLineNumbers) fRc = convertOmfAddDebugSegDefs(&OmfStuff); /* Add any additional group defintions we may need (for 16-bit code segs). */ if (fRc) fRc = convertOmfAddNeededGrpDefs(&OmfStuff); if (fRc) { /* * Instantiate the OMF writer and do pass-thru modifications. */ POMFWRITER pThis = omfWriter_Create(pszFile, 0, 0, pDst); if (pThis) { fRc = convertOmfPassthru(pThis, pbFile, cbFile, &OmfStuff, fConvertLineNumbers); omfWriter_Destroy(pThis); } else fRc = false; } /* * Cleanup OmfStuff. */ uint32_t i = OmfStuff.cSegLines; while (i-- >0) { uint32_t j = OmfStuff.paSegLines[i].cFiles; while (j-- > 0) free(OmfStuff.paSegLines[i].paFiles[j].paPairs); free(OmfStuff.paSegLines[i].paFiles); } free(OmfStuff.paSegLines); free(OmfStuff.paSrcInfo); free(OmfStuff.pchStrTab); while (OmfStuff.pAllocHead) { POMFDETAILSALLOC pFreeMe = OmfStuff.pAllocHead; OmfStuff.pAllocHead = OmfStuff.pAllocHead->pNext; free(pFreeMe); } return fRc; } /** * Does the convertion using convertelf and convertcoff. * * @returns exit code (0 on success, non-zero on failure) * @param pszFile The file to convert. */ static int convertit(const char *pszFile) { /* Construct the filename for saving the unmodified file. */ char szOrgFile[_4K]; size_t cchFile = strlen(pszFile); if (cchFile + sizeof(".original") > sizeof(szOrgFile)) { error(pszFile, "Filename too long!\n"); return RTEXITCODE_FAILURE; } memcpy(szOrgFile, pszFile, cchFile); memcpy(&szOrgFile[cchFile], ".original", sizeof(".original")); /* Read the whole file. */ void *pvFile; size_t cbFile; if (readfile(pszFile, &pvFile, &cbFile)) { /* * Do format conversions / adjustments. */ bool fRc = false; uint8_t *pbFile = (uint8_t *)pvFile; if ( cbFile > sizeof(Elf64_Ehdr) && pbFile[0] == ELFMAG0 && pbFile[1] == ELFMAG1 && pbFile[2] == ELFMAG2 && pbFile[3] == ELFMAG3) { if (writefile(szOrgFile, pvFile, cbFile)) { FILE *pDst = openfile(pszFile, true /*fWrite*/); if (pDst) { fRc = convertElfToOmf(pszFile, pbFile, cbFile, pDst); fRc = fclose(pDst) == 0 && fRc; } } } else if ( cbFile > sizeof(IMAGE_FILE_HEADER) && RT_MAKE_U16(pbFile[0], pbFile[1]) == IMAGE_FILE_MACHINE_AMD64 && RT_MAKE_U16(pbFile[2], pbFile[3]) * sizeof(IMAGE_SECTION_HEADER) + sizeof(IMAGE_FILE_HEADER) < cbFile && RT_MAKE_U16(pbFile[2], pbFile[3]) > 0) { if (writefile(szOrgFile, pvFile, cbFile)) { FILE *pDst = openfile(pszFile, true /*fWrite*/); if (pDst) { fRc = convertCoffToOmf(pszFile, pbFile, cbFile, pDst); fRc = fclose(pDst) == 0 && fRc; } } } else if ( cbFile >= 8 && pbFile[0] == OMF_THEADR && RT_MAKE_U16(pbFile[1], pbFile[2]) < cbFile) { if (writefile(szOrgFile, pvFile, cbFile)) { FILE *pDst = openfile(pszFile, true /*fWrite*/); if (pDst) { fRc = convertOmfToOmf(pszFile, pbFile, cbFile, pDst); fRc = fclose(pDst) == 0 && fRc; } } } else fprintf(stderr, "error: Don't recognize format of '%s' (%#x %#x %#x %#x, cbFile=%lu)\n", pszFile, pbFile[0], pbFile[1], pbFile[2], pbFile[3], (unsigned long)cbFile); free(pvFile); if (fRc) return 0; } return 1; } int main(int argc, char **argv) { int rcExit = 0; /* * Scan the arguments. */ for (int i = 1; i < argc; i++) { if (argv[i][0] == '-') { const char *pszOpt = &argv[i][1]; if (*pszOpt == '-') { /* Convert long options to short ones. */ pszOpt--; if (!strcmp(pszOpt, "--wcc")) pszOpt = "w"; else if (!strcmp(pszOpt, "--verbose")) pszOpt = "v"; else if (!strcmp(pszOpt, "--version")) pszOpt = "V"; else if (!strcmp(pszOpt, "--help")) pszOpt = "h"; else { fprintf(stderr, "syntax errro: Unknown options '%s'\n", pszOpt); return 2; } } /* Process the list of short options. */ while (*pszOpt) { switch (*pszOpt++) { case 'w': g_f16BitWatcomC = true; break; case 'v': g_cVerbose++; break; case 'V': printf("%s\n", "$Revision: 155244 $"); return 0; case '?': case 'h': printf("usage: %s [options] -o [input2 ... [inputN]]\n", argv[0]); return 0; } } } else { /* * File to convert. Do the job right away. */ rcExit = convertit(argv[i]); if (rcExit != 0) break; } } return rcExit; }