Index: /trunk/src/VBox/Runtime/common/ldr/ldrMachO.cpp =================================================================== --- /trunk/src/VBox/Runtime/common/ldr/ldrMachO.cpp (revision 74646) +++ /trunk/src/VBox/Runtime/common/ldr/ldrMachO.cpp (revision 74647) @@ -51,35 +51,35 @@ * Defined Constants And Macros * *********************************************************************************************************************************/ -/** @def KLDRMODMACHO_STRICT - * Define KLDRMODMACHO_STRICT to enabled strict checks in KLDRMODMACHO. */ -#define KLDRMODMACHO_STRICT 1 - -/** @def KLDRMODMACHO_ASSERT +/** @def RTLDRMODMACHO_STRICT + * Define RTLDRMODMACHO_STRICT to enabled strict checks in RTLDRMODMACHO. */ +#define RTLDRMODMACHO_STRICT 1 + +/** @def RTLDRMODMACHO_ASSERT * Assert that an expression is true when KLDR_STRICT is defined. */ -#ifdef KLDRMODMACHO_STRICT -# define KLDRMODMACHO_ASSERT(expr) Assert(expr) +#ifdef RTLDRMODMACHO_STRICT +# define RTLDRMODMACHO_ASSERT(expr) Assert(expr) #else -# define KLDRMODMACHO_ASSERT(expr) do {} while (0) +# define RTLDRMODMACHO_ASSERT(expr) do {} while (0) #endif -/** @def KLDRMODMACHO_CHECK_RETURN +/** @def RTLDRMODMACHO_CHECK_RETURN * Checks that an expression is true and return if it isn't. * This is a debug aid. */ -#ifdef KLDRMODMACHO_STRICT2 -# define KLDRMODMACHO_CHECK_RETURN(expr, rc) AssertReturn(expr, rc) +#ifdef RTLDRMODMACHO_STRICT2 +# define RTLDRMODMACHO_CHECK_RETURN(expr, rc) AssertReturn(expr, rc) #else -# define KLDRMODMACHO_CHECK_RETURN(expr, rc) do { if (!(expr)) { return (rc); } } while (0) +# define RTLDRMODMACHO_CHECK_RETURN(expr, rc) do { if (!(expr)) { return (rc); } } while (0) #endif -/** @def KLDRMODMACHO_CHECK_RETURN +/** @def RTLDRMODMACHO_CHECK_RETURN * Checks that an expression is true and return if it isn't. * This is a debug aid. */ -#ifdef KLDRMODMACHO_STRICT2 -# define KLDRMODMACHO_FAILED_RETURN(rc) AssertFailedReturn(rc) +#ifdef RTLDRMODMACHO_STRICT2 +# define RTLDRMODMACHO_FAILED_RETURN(rc) AssertFailedReturn(rc) #else -# define KLDRMODMACHO_FAILED_RETURN(rc) return (rc) +# define RTLDRMODMACHO_FAILED_RETURN(rc) return (rc) #endif @@ -91,5 +91,5 @@ * Mach-O section details. */ -typedef struct KLDRMODMACHOSECT +typedef struct RTLDRMODMACHOSECT { /** The size of the section (in bytes). */ @@ -115,5 +115,5 @@ /** Pointer to the Mach-O section structure. */ void *pvMachoSection; -} KLDRMODMACHOSECT, *PKLDRMODMACHOSECT; +} RTLDRMODMACHOSECT, *PRTLDRMODMACHOSECT; /** @@ -122,5 +122,5 @@ * This is corresponds to a kLdr segment, not a Mach-O segment! */ -typedef struct KLDRMODMACHOSEG +typedef struct RTLDRMODMACHOSEG { /** Common segment info. */ @@ -134,7 +134,7 @@ * The array resides in the big memory chunk allocated for * the module handle, so it doesn't need freeing. */ - PKLDRMODMACHOSECT paSections; - -} KLDRMODMACHOSEG, *PKLDRMODMACHOSEG; + PRTLDRMODMACHOSECT paSections; + +} RTLDRMODMACHOSEG, *PRTLDRMODMACHOSEG; /** @@ -142,5 +142,5 @@ * @todo interpret the other MH_* formats. */ -typedef struct KLDRMODMACHO +typedef struct RTLDRMODMACHO { /** Core module structure. */ @@ -209,9 +209,9 @@ uint32_t cSections; /** Pointer to the section array running in parallel to the Mach-O one. */ - PKLDRMODMACHOSECT paSections; + PRTLDRMODMACHOSECT paSections; /** Array of segments parallel to the one in KLDRMOD. */ - KLDRMODMACHOSEG aSegments[1]; -} KLDRMODMACHO, *PKLDRMODMACHO; + RTLDRMODMACHOSEG aSegments[1]; +} RTLDRMODMACHO, *PRTLDRMODMACHO; @@ -231,33 +231,33 @@ uint32_t fOpenFlags, uint32_t *pcSegments, uint32_t *pcSections, uint32_t *pcbStringPool, bool *pfCanLoad, PRTLDRADDR pLinkAddress, uint8_t *puEffFileType, PRTERRINFO pErrInfo); -static int kldrModMachOParseLoadCommands(PKLDRMODMACHO pThis, char *pbStringPool, uint32_t cbStringPool); - -static int kldrModMachOLoadObjSymTab(PKLDRMODMACHO pThis); -static int kldrModMachOLoadFixups(PKLDRMODMACHO pThis, RTFOFF offFixups, uint32_t cFixups, macho_relocation_info_t **ppaFixups); -static int kldrModMachOMapVirginBits(PKLDRMODMACHO pThis); - -static int kldrModMachODoQuerySymbol32Bit(PKLDRMODMACHO pThis, const macho_nlist_32_t *paSyms, uint32_t cSyms, const char *pchStrings, +static int kldrModMachOParseLoadCommands(PRTLDRMODMACHO pThis, char *pbStringPool, uint32_t cbStringPool); + +static int kldrModMachOLoadObjSymTab(PRTLDRMODMACHO pThis); +static int kldrModMachOLoadFixups(PRTLDRMODMACHO pThis, RTFOFF offFixups, uint32_t cFixups, macho_relocation_info_t **ppaFixups); +static int kldrModMachOMapVirginBits(PRTLDRMODMACHO pThis); + +static int kldrModMachODoQuerySymbol32Bit(PRTLDRMODMACHO pThis, const macho_nlist_32_t *paSyms, uint32_t cSyms, const char *pchStrings, uint32_t cchStrings, RTLDRADDR BaseAddress, uint32_t iSymbol, const char *pchSymbol, uint32_t cchSymbol, PRTLDRADDR puValue, uint32_t *pfKind); -static int kldrModMachODoQuerySymbol64Bit(PKLDRMODMACHO pThis, const macho_nlist_64_t *paSyms, uint32_t cSyms, const char *pchStrings, +static int kldrModMachODoQuerySymbol64Bit(PRTLDRMODMACHO pThis, const macho_nlist_64_t *paSyms, uint32_t cSyms, const char *pchStrings, uint32_t cchStrings, RTLDRADDR BaseAddress, uint32_t iSymbol, const char *pchSymbol, uint32_t cchSymbol, PRTLDRADDR puValue, uint32_t *pfKind); -static int kldrModMachODoEnumSymbols32Bit(PKLDRMODMACHO pThis, const macho_nlist_32_t *paSyms, uint32_t cSyms, +static int kldrModMachODoEnumSymbols32Bit(PRTLDRMODMACHO pThis, const macho_nlist_32_t *paSyms, uint32_t cSyms, const char *pchStrings, uint32_t cchStrings, RTLDRADDR BaseAddress, uint32_t fFlags, PFNRTLDRENUMSYMS pfnCallback, void *pvUser); -static int kldrModMachODoEnumSymbols64Bit(PKLDRMODMACHO pThis, const macho_nlist_64_t *paSyms, uint32_t cSyms, +static int kldrModMachODoEnumSymbols64Bit(PRTLDRMODMACHO pThis, const macho_nlist_64_t *paSyms, uint32_t cSyms, const char *pchStrings, uint32_t cchStrings, RTLDRADDR BaseAddress, uint32_t fFlags, PFNRTLDRENUMSYMS pfnCallback, void *pvUser); -static int kldrModMachOObjDoImports(PKLDRMODMACHO pThis, RTLDRADDR BaseAddress, PFNRTLDRIMPORT pfnGetImport, void *pvUser); -static int kldrModMachOObjDoFixups(PKLDRMODMACHO pThis, void *pvMapping, RTLDRADDR NewBaseAddress); -static int kldrModMachOFixupSectionGeneric32Bit(PKLDRMODMACHO pThis, uint8_t *pbSectBits, PKLDRMODMACHOSECT pFixupSect, +static int kldrModMachOObjDoImports(PRTLDRMODMACHO pThis, RTLDRADDR BaseAddress, PFNRTLDRIMPORT pfnGetImport, void *pvUser); +static int kldrModMachOObjDoFixups(PRTLDRMODMACHO pThis, void *pvMapping, RTLDRADDR NewBaseAddress); +static int kldrModMachOFixupSectionGeneric32Bit(PRTLDRMODMACHO pThis, uint8_t *pbSectBits, PRTLDRMODMACHOSECT pFixupSect, macho_nlist_32_t *paSyms, uint32_t cSyms, RTLDRADDR NewBaseAddress); -static int kldrModMachOFixupSectionAMD64(PKLDRMODMACHO pThis, uint8_t *pbSectBits, PKLDRMODMACHOSECT pFixupSect, +static int kldrModMachOFixupSectionAMD64(PRTLDRMODMACHO pThis, uint8_t *pbSectBits, PRTLDRMODMACHOSECT pFixupSect, macho_nlist_64_t *paSyms, uint32_t cSyms, RTLDRADDR NewBaseAddress); -static int kldrModMachOMakeGOT(PKLDRMODMACHO pThis, void *pvBits, RTLDRADDR NewBaseAddress); - -/*static int kldrModMachODoFixups(PKLDRMODMACHO pThis, void *pvMapping, RTLDRADDR NewBaseAddress, RTLDRADDR OldBaseAddress); -static int kldrModMachODoImports(PKLDRMODMACHO pThis, void *pvMapping, PFNRTLDRIMPORT pfnGetImport, void *pvUser);*/ +static int kldrModMachOMakeGOT(PRTLDRMODMACHO pThis, void *pvBits, RTLDRADDR NewBaseAddress); + +/*static int kldrModMachODoFixups(PRTLDRMODMACHO pThis, void *pvMapping, RTLDRADDR NewBaseAddress, RTLDRADDR OldBaseAddress); +static int kldrModMachODoImports(PRTLDRMODMACHO pThis, void *pvMapping, PFNRTLDRIMPORT pfnGetImport, void *pvUser);*/ @@ -268,5 +268,5 @@ */ static int kldrModMachODoCreate(PRTLDRREADER pRdr, RTFOFF offImage, uint32_t fOpenFlags, - PKLDRMODMACHO *ppModMachO, PRTERRINFO pErrInfo) + PRTLDRMODMACHO *ppModMachO, PRTERRINFO pErrInfo) { *ppModMachO = NULL; @@ -357,7 +357,7 @@ * Calc the instance size, allocate and initialize it. */ - size_t const cbModAndSegs = RT_ALIGN_Z(RT_UOFFSETOF_DYN(KLDRMODMACHO, aSegments[cSegments]) - + sizeof(KLDRMODMACHOSECT) * cSections, 16); - PKLDRMODMACHO pThis = (PKLDRMODMACHO)RTMemAlloc(cbModAndSegs + cbStringPool); + size_t const cbModAndSegs = RT_ALIGN_Z(RT_UOFFSETOF_DYN(RTLDRMODMACHO, aSegments[cSegments]) + + sizeof(RTLDRMODMACHOSECT) * cSections, 16); + PRTLDRMODMACHO pThis = (PRTLDRMODMACHO)RTMemAlloc(cbModAndSegs + cbStringPool); if (!pThis) return VERR_NO_MEMORY; @@ -445,5 +445,5 @@ } - /* KLDRMODMACHO */ + /* RTLDRMODMACHO */ pThis->cSegments = cSegments; pThis->pvBits = NULL; @@ -470,5 +470,5 @@ pThis->JmpStubsRVA = NIL_RTLDRADDR; pThis->cSections = cSections; - pThis->paSections = (PKLDRMODMACHOSECT)&pThis->aSegments[pThis->cSegments]; + pThis->paSections = (PRTLDRMODMACHOSECT)&pThis->aSegments[pThis->cSegments]; /* @@ -560,5 +560,5 @@ * Convert and validate command header. */ - KLDRMODMACHO_CHECK_RETURN(cbLeft >= sizeof(load_command_t), VERR_LDRMACHO_BAD_LOAD_COMMAND); + RTLDRMODMACHO_CHECK_RETURN(cbLeft >= sizeof(load_command_t), VERR_LDRMACHO_BAD_LOAD_COMMAND); if (fConvertEndian) { @@ -566,5 +566,5 @@ u.pLoadCmd->cmdsize = RT_BSWAP_U32(u.pLoadCmd->cmdsize); } - KLDRMODMACHO_CHECK_RETURN(u.pLoadCmd->cmdsize <= cbLeft, VERR_LDRMACHO_BAD_LOAD_COMMAND); + RTLDRMODMACHO_CHECK_RETURN(u.pLoadCmd->cmdsize <= cbLeft, VERR_LDRMACHO_BAD_LOAD_COMMAND); cbLeft -= u.pLoadCmd->cmdsize; pb += u.pLoadCmd->cmdsize; @@ -584,6 +584,6 @@ /* Convert and verify the segment. */ - KLDRMODMACHO_CHECK_RETURN(u.pLoadCmd->cmdsize >= sizeof(segment_command_32_t), VERR_LDRMACHO_BAD_LOAD_COMMAND); - KLDRMODMACHO_CHECK_RETURN( pHdr->magic == IMAGE_MACHO32_SIGNATURE_OE + RTLDRMODMACHO_CHECK_RETURN(u.pLoadCmd->cmdsize >= sizeof(segment_command_32_t), VERR_LDRMACHO_BAD_LOAD_COMMAND); + RTLDRMODMACHO_CHECK_RETURN( pHdr->magic == IMAGE_MACHO32_SIGNATURE_OE || pHdr->magic == IMAGE_MACHO32_SIGNATURE, VERR_LDRMACHO_BIT_MIX); if (fConvertEndian) @@ -613,19 +613,19 @@ *puEffFileType = uEffFileType = MH_OBJECT; \ \ - KLDRMODMACHO_CHECK_RETURN( pSrcSeg->filesize == 0 \ + RTLDRMODMACHO_CHECK_RETURN( pSrcSeg->filesize == 0 \ || ( pSrcSeg->fileoff <= cbFile \ && (uint64_t)pSrcSeg->fileoff + pSrcSeg->filesize <= cbFile), \ VERR_LDRMACHO_BAD_LOAD_COMMAND); \ - KLDRMODMACHO_CHECK_RETURN( pSrcSeg->filesize <= pSrcSeg->vmsize \ + RTLDRMODMACHO_CHECK_RETURN( pSrcSeg->filesize <= pSrcSeg->vmsize \ || (fSkipSeg && !strcmp(pSrcSeg->segname, "__CTF") /* see above */), \ VERR_LDRMACHO_BAD_LOAD_COMMAND); \ - KLDRMODMACHO_CHECK_RETURN(!(~pSrcSeg->maxprot & pSrcSeg->initprot), \ + RTLDRMODMACHO_CHECK_RETURN(!(~pSrcSeg->maxprot & pSrcSeg->initprot), \ VERR_LDRMACHO_BAD_LOAD_COMMAND); \ - KLDRMODMACHO_CHECK_RETURN(!(pSrcSeg->flags & ~(SG_HIGHVM | SG_FVMLIB | SG_NORELOC | SG_PROTECTED_VERSION_1)), \ + RTLDRMODMACHO_CHECK_RETURN(!(pSrcSeg->flags & ~(SG_HIGHVM | SG_FVMLIB | SG_NORELOC | SG_PROTECTED_VERSION_1)), \ VERR_LDRMACHO_BAD_LOAD_COMMAND); \ - KLDRMODMACHO_CHECK_RETURN( pSrcSeg->nsects * sizeof(section_##a_cBits##_t) \ + RTLDRMODMACHO_CHECK_RETURN( pSrcSeg->nsects * sizeof(section_##a_cBits##_t) \ <= u.pLoadCmd->cmdsize - sizeof(segment_command_##a_cBits##_t), \ VERR_LDRMACHO_BAD_LOAD_COMMAND); \ - KLDRMODMACHO_CHECK_RETURN( uEffFileType != MH_OBJECT \ + RTLDRMODMACHO_CHECK_RETURN( uEffFileType != MH_OBJECT \ || cSegmentCommands == 0 \ || ( cSegmentCommands == 1 \ @@ -675,5 +675,5 @@ /* validate */ \ if (uEffFileType != MH_OBJECT) \ - KLDRMODMACHO_CHECK_RETURN(!strcmp(pSect->segname, pSrcSeg->segname),\ + RTLDRMODMACHO_CHECK_RETURN(!strcmp(pSect->segname, pSrcSeg->segname),\ VERR_LDRMACHO_BAD_SECTION); \ \ @@ -681,6 +681,6 @@ { \ case S_ZEROFILL: \ - KLDRMODMACHO_CHECK_RETURN(!pSect->reserved1, VERR_LDRMACHO_BAD_SECTION); \ - KLDRMODMACHO_CHECK_RETURN(!pSect->reserved2, VERR_LDRMACHO_BAD_SECTION); \ + RTLDRMODMACHO_CHECK_RETURN(!pSect->reserved1, VERR_LDRMACHO_BAD_SECTION); \ + RTLDRMODMACHO_CHECK_RETURN(!pSect->reserved2, VERR_LDRMACHO_BAD_SECTION); \ fFileBits = 0; \ break; \ @@ -691,13 +691,13 @@ case S_8BYTE_LITERALS: \ case S_16BYTE_LITERALS: \ - KLDRMODMACHO_CHECK_RETURN(!pSect->reserved1, VERR_LDRMACHO_BAD_SECTION); \ - KLDRMODMACHO_CHECK_RETURN(!pSect->reserved2, VERR_LDRMACHO_BAD_SECTION); \ + RTLDRMODMACHO_CHECK_RETURN(!pSect->reserved1, VERR_LDRMACHO_BAD_SECTION); \ + RTLDRMODMACHO_CHECK_RETURN(!pSect->reserved2, VERR_LDRMACHO_BAD_SECTION); \ fFileBits = 1; \ break; \ \ case S_SYMBOL_STUBS: \ - KLDRMODMACHO_CHECK_RETURN(!pSect->reserved1, VERR_LDRMACHO_BAD_SECTION); \ + RTLDRMODMACHO_CHECK_RETURN(!pSect->reserved1, VERR_LDRMACHO_BAD_SECTION); \ /* reserved2 == stub size. 0 has been seen (corecrypto.kext) */ \ - KLDRMODMACHO_CHECK_RETURN(pSect->reserved2 < 64, VERR_LDRMACHO_BAD_SECTION); \ + RTLDRMODMACHO_CHECK_RETURN(pSect->reserved2 < 64, VERR_LDRMACHO_BAD_SECTION); \ fFileBits = 1; \ break; \ @@ -707,5 +707,5 @@ case S_LAZY_DYLIB_SYMBOL_POINTERS: \ /* (reserved 1 = is indirect symbol table index) */ \ - KLDRMODMACHO_CHECK_RETURN(!pSect->reserved2, VERR_LDRMACHO_BAD_SECTION); \ + RTLDRMODMACHO_CHECK_RETURN(!pSect->reserved2, VERR_LDRMACHO_BAD_SECTION); \ *pfCanLoad = false; \ fFileBits = -1; /* __DATA.__got in the 64-bit mach_kernel has bits, any things without bits? */ \ @@ -714,13 +714,13 @@ case S_MOD_INIT_FUNC_POINTERS: \ /** @todo this requires a query API or flag... (e.g. C++ constructors) */ \ - KLDRMODMACHO_CHECK_RETURN(fOpenFlags & RTLDR_O_FOR_DEBUG, \ + RTLDRMODMACHO_CHECK_RETURN(fOpenFlags & RTLDR_O_FOR_DEBUG, \ VERR_LDRMACHO_UNSUPPORTED_INIT_SECTION); \ /* Falls through. */ \ case S_MOD_TERM_FUNC_POINTERS: \ /** @todo this requires a query API or flag... (e.g. C++ destructors) */ \ - KLDRMODMACHO_CHECK_RETURN(fOpenFlags & RTLDR_O_FOR_DEBUG, \ + RTLDRMODMACHO_CHECK_RETURN(fOpenFlags & RTLDR_O_FOR_DEBUG, \ VERR_LDRMACHO_UNSUPPORTED_TERM_SECTION); \ - KLDRMODMACHO_CHECK_RETURN(!pSect->reserved1, VERR_LDRMACHO_BAD_SECTION); \ - KLDRMODMACHO_CHECK_RETURN(!pSect->reserved2, VERR_LDRMACHO_BAD_SECTION); \ + RTLDRMODMACHO_CHECK_RETURN(!pSect->reserved1, VERR_LDRMACHO_BAD_SECTION); \ + RTLDRMODMACHO_CHECK_RETURN(!pSect->reserved2, VERR_LDRMACHO_BAD_SECTION); \ fFileBits = 1; \ break; /* ignored */ \ @@ -728,6 +728,6 @@ case S_LITERAL_POINTERS: \ case S_DTRACE_DOF: \ - KLDRMODMACHO_CHECK_RETURN(!pSect->reserved1, VERR_LDRMACHO_BAD_SECTION); \ - KLDRMODMACHO_CHECK_RETURN(!pSect->reserved2, VERR_LDRMACHO_BAD_SECTION); \ + RTLDRMODMACHO_CHECK_RETURN(!pSect->reserved1, VERR_LDRMACHO_BAD_SECTION); \ + RTLDRMODMACHO_CHECK_RETURN(!pSect->reserved2, VERR_LDRMACHO_BAD_SECTION); \ fFileBits = 1; \ break; \ @@ -735,23 +735,23 @@ case S_INTERPOSING: \ case S_GB_ZEROFILL: \ - KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_UNSUPPORTED_SECTION); \ + RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_UNSUPPORTED_SECTION); \ \ default: \ - KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_UNKNOWN_SECTION); \ + RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_UNKNOWN_SECTION); \ } \ - KLDRMODMACHO_CHECK_RETURN(!(pSect->flags & ~( S_ATTR_PURE_INSTRUCTIONS | S_ATTR_NO_TOC | S_ATTR_STRIP_STATIC_SYMS \ + RTLDRMODMACHO_CHECK_RETURN(!(pSect->flags & ~( S_ATTR_PURE_INSTRUCTIONS | S_ATTR_NO_TOC | S_ATTR_STRIP_STATIC_SYMS \ | S_ATTR_NO_DEAD_STRIP | S_ATTR_LIVE_SUPPORT | S_ATTR_SELF_MODIFYING_CODE \ | S_ATTR_DEBUG | S_ATTR_SOME_INSTRUCTIONS | S_ATTR_EXT_RELOC \ | S_ATTR_LOC_RELOC | SECTION_TYPE)), \ VERR_LDRMACHO_BAD_SECTION); \ - KLDRMODMACHO_CHECK_RETURN((pSect->flags & S_ATTR_DEBUG) == (pFirstSect->flags & S_ATTR_DEBUG), \ + RTLDRMODMACHO_CHECK_RETURN((pSect->flags & S_ATTR_DEBUG) == (pFirstSect->flags & S_ATTR_DEBUG), \ VERR_LDRMACHO_MIXED_DEBUG_SECTION_FLAGS); \ \ - KLDRMODMACHO_CHECK_RETURN(pSect->addr - pSrcSeg->vmaddr <= pSrcSeg->vmsize, \ + RTLDRMODMACHO_CHECK_RETURN(pSect->addr - pSrcSeg->vmaddr <= pSrcSeg->vmsize, \ VERR_LDRMACHO_BAD_SECTION); \ - KLDRMODMACHO_CHECK_RETURN( pSect->addr - pSrcSeg->vmaddr + pSect->size <= pSrcSeg->vmsize \ + RTLDRMODMACHO_CHECK_RETURN( pSect->addr - pSrcSeg->vmaddr + pSect->size <= pSrcSeg->vmsize \ || !strcmp(pSrcSeg->segname, "__CTF") /* see above */, \ VERR_LDRMACHO_BAD_SECTION); \ - KLDRMODMACHO_CHECK_RETURN(pSect->align < 31, \ + RTLDRMODMACHO_CHECK_RETURN(pSect->align < 31, \ VERR_LDRMACHO_BAD_SECTION); \ /* Workaround for buggy ld64 (or as, llvm, ++) that produces a misaligned __TEXT.__unwind_info. */ \ @@ -761,7 +761,7 @@ && strcmp(pSect->sectname, "__unwind_info") == 0) \ pSect->align = 2; \ - KLDRMODMACHO_CHECK_RETURN(!((RT_BIT_32(pSect->align) - UINT32_C(1)) & pSect->addr), \ + RTLDRMODMACHO_CHECK_RETURN(!((RT_BIT_32(pSect->align) - UINT32_C(1)) & pSect->addr), \ VERR_LDRMACHO_BAD_SECTION); \ - KLDRMODMACHO_CHECK_RETURN(!((RT_BIT_32(pSect->align) - UINT32_C(1)) & pSrcSeg->vmaddr), \ + RTLDRMODMACHO_CHECK_RETURN(!((RT_BIT_32(pSect->align) - UINT32_C(1)) & pSrcSeg->vmaddr), \ VERR_LDRMACHO_BAD_SECTION); \ \ @@ -770,5 +770,5 @@ if (pSect->addr) \ { \ - KLDRMODMACHO_CHECK_RETURN(offSect <= pSect->addr - pSrcSeg->vmaddr, VERR_LDRMACHO_BAD_SECTION); \ + RTLDRMODMACHO_CHECK_RETURN(offSect <= pSect->addr - pSrcSeg->vmaddr, VERR_LDRMACHO_BAD_SECTION); \ if (offSect < pSect->addr - pSrcSeg->vmaddr) \ offSect = pSect->addr - pSrcSeg->vmaddr; \ @@ -781,25 +781,25 @@ if (uEffFileType != MH_OBJECT) \ { \ - KLDRMODMACHO_CHECK_RETURN(pSect->offset == pSrcSeg->fileoff + offSect, \ + RTLDRMODMACHO_CHECK_RETURN(pSect->offset == pSrcSeg->fileoff + offSect, \ VERR_LDRMACHO_NON_CONT_SEG_BITS); \ - KLDRMODMACHO_CHECK_RETURN(pSect->offset - pSrcSeg->fileoff <= pSrcSeg->filesize, \ + RTLDRMODMACHO_CHECK_RETURN(pSect->offset - pSrcSeg->fileoff <= pSrcSeg->filesize, \ VERR_LDRMACHO_BAD_SECTION); \ } \ - KLDRMODMACHO_CHECK_RETURN(pSect->offset <= cbFile, \ + RTLDRMODMACHO_CHECK_RETURN(pSect->offset <= cbFile, \ VERR_LDRMACHO_BAD_SECTION); \ - KLDRMODMACHO_CHECK_RETURN((uint64_t)pSect->offset + pSect->size <= cbFile, \ + RTLDRMODMACHO_CHECK_RETURN((uint64_t)pSect->offset + pSect->size <= cbFile, \ VERR_LDRMACHO_BAD_SECTION); \ } \ else \ - KLDRMODMACHO_CHECK_RETURN(pSect->offset == 0, VERR_LDRMACHO_BAD_SECTION); \ + RTLDRMODMACHO_CHECK_RETURN(pSect->offset == 0, VERR_LDRMACHO_BAD_SECTION); \ \ if (!pSect->nreloc) \ - KLDRMODMACHO_CHECK_RETURN(!pSect->reloff, \ + RTLDRMODMACHO_CHECK_RETURN(!pSect->reloff, \ VERR_LDRMACHO_BAD_SECTION); \ else \ { \ - KLDRMODMACHO_CHECK_RETURN(pSect->reloff <= cbFile, \ + RTLDRMODMACHO_CHECK_RETURN(pSect->reloff <= cbFile, \ VERR_LDRMACHO_BAD_SECTION); \ - KLDRMODMACHO_CHECK_RETURN( (uint64_t)pSect->reloff \ + RTLDRMODMACHO_CHECK_RETURN( (uint64_t)pSect->reloff \ + (RTFOFF)pSect->nreloc * sizeof(macho_relocation_info_t) \ <= cbFile, \ @@ -829,5 +829,5 @@ break; \ default: \ - KLDRMODMACHO_FAILED_RETURN(VERR_INVALID_PARAMETER); \ + RTLDRMODMACHO_FAILED_RETURN(VERR_INVALID_PARAMETER); \ } \ \ @@ -853,6 +853,6 @@ /* Convert and verify the segment. */ - KLDRMODMACHO_CHECK_RETURN(u.pLoadCmd->cmdsize >= sizeof(segment_command_64_t), VERR_LDRMACHO_BAD_LOAD_COMMAND); - KLDRMODMACHO_CHECK_RETURN( pHdr->magic == IMAGE_MACHO64_SIGNATURE_OE + RTLDRMODMACHO_CHECK_RETURN(u.pLoadCmd->cmdsize >= sizeof(segment_command_64_t), VERR_LDRMACHO_BAD_LOAD_COMMAND); + RTLDRMODMACHO_CHECK_RETURN( pHdr->magic == IMAGE_MACHO64_SIGNATURE_OE || pHdr->magic == IMAGE_MACHO64_SIGNATURE, VERR_LDRMACHO_BIT_MIX); if (fConvertEndian) @@ -915,8 +915,8 @@ if ( u.pSymTab->symoff >= cbFile || (uint64_t)u.pSymTab->symoff + u.pSymTab->nsyms * cbSym > cbFile) - KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND); if ( u.pSymTab->stroff >= cbFile || (uint64_t)u.pSymTab->stroff + u.pSymTab->strsize > cbFile) - KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND); /* only one string in objects, please. */ @@ -924,5 +924,5 @@ if ( uEffFileType == MH_OBJECT && cSymbolTabs != 1) - KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_OBJECT_FILE); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_OBJECT_FILE); break; } @@ -941,5 +941,5 @@ /* convert & verify header items ([0] == flavor, [1] == uint32_t count). */ if (cItemsLeft < 2) - KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND); if (fConvertEndian) { @@ -948,5 +948,5 @@ } if (pu32[1] + 2 > cItemsLeft) - KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND); /* convert & verify according to flavor. */ @@ -967,5 +967,5 @@ case LC_UUID: if (u.pUuid->cmdsize != sizeof(uuid_command_t)) - KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND); /** @todo Check anything here need converting? */ break; @@ -973,5 +973,5 @@ case LC_CODE_SIGNATURE: if (u.pUuid->cmdsize != sizeof(linkedit_data_command_t)) - KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND); break; @@ -979,5 +979,5 @@ case LC_VERSION_MIN_IPHONEOS: if (u.pUuid->cmdsize != sizeof(version_min_command_t)) - KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND); break; @@ -1007,5 +1007,5 @@ /** @todo valid command size. */ if (!(fOpenFlags & RTLDR_O_FOR_DEBUG)) - KLDRMODMACHO_FAILED_RETURN(RTErrInfoSetF(pErrInfo, VERR_LDRMACHO_UNSUPPORTED_LOAD_COMMAND, + RTLDRMODMACHO_FAILED_RETURN(RTErrInfoSetF(pErrInfo, VERR_LDRMACHO_UNSUPPORTED_LOAD_COMMAND, "cmd=%#x", u.pLoadCmd->cmd)); *pfCanLoad = false; @@ -1026,9 +1026,9 @@ case LC_PREBIND_CKSUM: case LC_SYMSEG: - KLDRMODMACHO_FAILED_RETURN(RTErrInfoSetF(pErrInfo, VERR_LDRMACHO_UNSUPPORTED_LOAD_COMMAND, + RTLDRMODMACHO_FAILED_RETURN(RTErrInfoSetF(pErrInfo, VERR_LDRMACHO_UNSUPPORTED_LOAD_COMMAND, "cmd=%#x", u.pLoadCmd->cmd)); default: - KLDRMODMACHO_FAILED_RETURN(RTErrInfoSetF(pErrInfo, VERR_LDRMACHO_UNKNOWN_LOAD_COMMAND, + RTLDRMODMACHO_FAILED_RETURN(RTErrInfoSetF(pErrInfo, VERR_LDRMACHO_UNKNOWN_LOAD_COMMAND, "cmd=%#x", u.pLoadCmd->cmd)); } @@ -1037,5 +1037,5 @@ /* be strict. */ if (cbLeft) - KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND); switch (uEffFileType) @@ -1048,5 +1048,5 @@ case MH_KEXT_BUNDLE: if (!cSegments) - KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_OBJECT_FILE); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_OBJECT_FILE); break; } @@ -1070,5 +1070,5 @@ * @param cbStringPool The size of the string pool. */ -static int kldrModMachOParseLoadCommands(PKLDRMODMACHO pThis, char *pbStringPool, uint32_t cbStringPool) +static int kldrModMachOParseLoadCommands(PRTLDRMODMACHO pThis, char *pbStringPool, uint32_t cbStringPool) { union @@ -1084,8 +1084,8 @@ uint32_t cbLeft = pThis->Hdr.sizeofcmds; const uint8_t *pb = pThis->pbLoadCommands; - PKLDRMODMACHOSEG pDstSeg = &pThis->aSegments[0]; - PKLDRMODMACHOSECT pSectExtra = pThis->paSections; + PRTLDRMODMACHOSEG pDstSeg = &pThis->aSegments[0]; + PRTLDRMODMACHOSECT pSectExtra = pThis->paSections; const uint32_t cSegments = pThis->cSegments; - PKLDRMODMACHOSEG pSegItr; + PRTLDRMODMACHOSEG pSegItr; RT_NOREF(cbStringPool); @@ -1169,5 +1169,5 @@ for (pSegItr = &pThis->aSegments[0]; pSegItr != pDstSeg; pSegItr++) \ if (!strncmp(pSegItr->SegInfo.pszName, pSrcSeg->segname, sizeof(pSrcSeg->segname))) \ - KLDRMODMACHO_FAILED_RETURN(VERR_LDR_DUPLICATE_SEGMENT_NAME); \ + RTLDRMODMACHO_FAILED_RETURN(VERR_LDR_DUPLICATE_SEGMENT_NAME); \ \ /* \ @@ -1287,5 +1287,5 @@ { bool fLoadLinkEdit = false; - PKLDRMODMACHOSECT pSectExtraItr; + PRTLDRMODMACHOSECT pSectExtraItr; RTLDRADDR uNextRVA = 0; RTLDRADDR cb; @@ -1325,4 +1325,5 @@ for (pDstSeg = &pThis->aSegments[0]; c-- > 0; pDstSeg++) { + uNextRVA = RTLDR_ALIGN_ADDR(uNextRVA, pDstSeg->SegInfo.Alignment); cb = pDstSeg->SegInfo.RVA - uNextRVA; if (cb >= 0x00100000) /* 1MB */ @@ -1331,5 +1332,5 @@ //pThis->pMod->fFlags |= KLDRMOD_FLAGS_NON_CONTIGUOUS_LINK_ADDRS; } - uNextRVA = pDstSeg->SegInfo.RVA + RTLDR_ALIGN_ADDR(pDstSeg->SegInfo.cb, pDstSeg->SegInfo.Alignment); + uNextRVA = pDstSeg->SegInfo.RVA + pDstSeg->SegInfo.cb; } @@ -1422,6 +1423,6 @@ static DECLCALLBACK(int) rtldrMachO_Close(PRTLDRMODINTERNAL pMod) { - PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core); - KLDRMODMACHO_ASSERT(!pThis->pvMapping); + PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core); + RTLDRMODMACHO_ASSERT(!pThis->pvMapping); uint32_t i = pThis->cSegments; @@ -1453,5 +1454,5 @@ * @param pBaseAddress The base address, IN & OUT. Optional. */ -static void kldrModMachOAdjustBaseAddress(PKLDRMODMACHO pThis, PRTLDRADDR pBaseAddress) +static void kldrModMachOAdjustBaseAddress(PRTLDRMODMACHO pThis, PRTLDRADDR pBaseAddress) { /* @@ -1477,5 +1478,5 @@ * @param puValue Where to return the symbol value. */ -static int kldrModMachOQueryLinkerSymbol(PKLDRMODMACHO pThis, const char *pchSymbol, size_t cchSymbol, +static int kldrModMachOQueryLinkerSymbol(PRTLDRMODMACHO pThis, const char *pchSymbol, size_t cchSymbol, RTLDRADDR BaseAddress, PRTLDRADDR puValue) { @@ -1614,5 +1615,5 @@ uint32_t iOrdinal, const char *pszSymbol, RTUINTPTR *pValue) { - PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core); + PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core); RT_NOREF(pvBits); //RT_NOREF(pszVersion); @@ -1631,5 +1632,5 @@ * Refuse segmented requests for now. */ - KLDRMODMACHO_CHECK_RETURN( !pfKind + RTLDRMODMACHO_CHECK_RETURN( !pfKind || (*pfKind & RTLDRSYMKIND_REQ_TYPE_MASK) == RTLDRSYMKIND_REQ_FLAT, VERR_LDRMACHO_TODO); @@ -1701,5 +1702,5 @@ * @param pfKind See kLdrModQuerySymbol. */ -static int kldrModMachODoQuerySymbol32Bit(PKLDRMODMACHO pThis, const macho_nlist_32_t *paSyms, uint32_t cSyms, +static int kldrModMachODoQuerySymbol32Bit(PRTLDRMODMACHO pThis, const macho_nlist_32_t *paSyms, uint32_t cSyms, const char *pchStrings, uint32_t cchStrings, RTLDRADDR BaseAddress, uint32_t iSymbol, const char *pchSymbol, uint32_t cchSymbol, PRTLDRADDR puValue, uint32_t *pfKind) @@ -1775,11 +1776,11 @@ case MACHO_N_SECT: { - PKLDRMODMACHOSECT pSect; + PRTLDRMODMACHOSECT pSect; RTLDRADDR offSect; - KLDRMODMACHO_CHECK_RETURN((uint32_t)(paSyms[iSymbol].n_sect - 1) < pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL); + RTLDRMODMACHO_CHECK_RETURN((uint32_t)(paSyms[iSymbol].n_sect - 1) < pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL); pSect = &pThis->paSections[paSyms[iSymbol].n_sect - 1]; offSect = paSyms[iSymbol].n_value - pSect->LinkAddress; - KLDRMODMACHO_CHECK_RETURN( offSect <= pSect->cb + RTLDRMODMACHO_CHECK_RETURN( offSect <= pSect->cb || ( paSyms[iSymbol].n_sect == 1 /* special hack for __mh_execute_header */ && offSect == 0U - pSect->RVA @@ -1806,5 +1807,5 @@ /** @todo implement indirect and prebound symbols. */ default: - KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO); } @@ -1829,5 +1830,5 @@ * @param pfKind See kLdrModQuerySymbol. */ -static int kldrModMachODoQuerySymbol64Bit(PKLDRMODMACHO pThis, const macho_nlist_64_t *paSyms, uint32_t cSyms, +static int kldrModMachODoQuerySymbol64Bit(PRTLDRMODMACHO pThis, const macho_nlist_64_t *paSyms, uint32_t cSyms, const char *pchStrings, uint32_t cchStrings, RTLDRADDR BaseAddress, uint32_t iSymbol, const char *pchSymbol, uint32_t cchSymbol, PRTLDRADDR puValue, uint32_t *pfKind) @@ -1903,11 +1904,11 @@ case MACHO_N_SECT: { - PKLDRMODMACHOSECT pSect; + PRTLDRMODMACHOSECT pSect; RTLDRADDR offSect; - KLDRMODMACHO_CHECK_RETURN((uint32_t)(paSyms[iSymbol].n_sect - 1) < pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL); + RTLDRMODMACHO_CHECK_RETURN((uint32_t)(paSyms[iSymbol].n_sect - 1) < pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL); pSect = &pThis->paSections[paSyms[iSymbol].n_sect - 1]; offSect = paSyms[iSymbol].n_value - pSect->LinkAddress; - KLDRMODMACHO_CHECK_RETURN( offSect <= pSect->cb + RTLDRMODMACHO_CHECK_RETURN( offSect <= pSect->cb || ( paSyms[iSymbol].n_sect == 1 /* special hack for __mh_execute_header */ && offSect == 0U - pSect->RVA @@ -1934,5 +1935,5 @@ /** @todo implement indirect and prebound symbols. */ default: - KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO); } @@ -1947,5 +1948,5 @@ RTUINTPTR BaseAddress, PFNRTLDRENUMSYMS pfnCallback, void *pvUser) { - PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core); + PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core); RT_NOREF(pvBits); @@ -1981,5 +1982,5 @@ } else - KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO); return rc; @@ -2001,5 +2002,5 @@ * @param pvUser See kLdrModEnumSymbols. */ -static int kldrModMachODoEnumSymbols32Bit(PKLDRMODMACHO pThis, const macho_nlist_32_t *paSyms, uint32_t cSyms, +static int kldrModMachODoEnumSymbols32Bit(PRTLDRMODMACHO pThis, const macho_nlist_32_t *paSyms, uint32_t cSyms, const char *pchStrings, uint32_t cchStrings, RTLDRADDR BaseAddress, uint32_t fFlags, PFNRTLDRENUMSYMS pfnCallback, void *pvUser) @@ -2043,5 +2044,5 @@ /* name */ - KLDRMODMACHO_CHECK_RETURN((uint32_t)paSyms[iSym].n_un.n_strx < cchStrings, VERR_LDRMACHO_BAD_SYMBOL); + RTLDRMODMACHO_CHECK_RETURN((uint32_t)paSyms[iSym].n_un.n_strx < cchStrings, VERR_LDRMACHO_BAD_SYMBOL); psz = &pchStrings[paSyms[iSym].n_un.n_strx]; cch = strlen(psz); @@ -2057,10 +2058,10 @@ case MACHO_N_SECT: { - PKLDRMODMACHOSECT pSect; - KLDRMODMACHO_CHECK_RETURN((uint32_t)(paSyms[iSym].n_sect - 1) < pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL); + PRTLDRMODMACHOSECT pSect; + RTLDRMODMACHO_CHECK_RETURN((uint32_t)(paSyms[iSym].n_sect - 1) < pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL); pSect = &pThis->paSections[paSyms[iSym].n_sect - 1]; uValue = paSyms[iSym].n_value - pSect->LinkAddress; - KLDRMODMACHO_CHECK_RETURN( uValue <= pSect->cb + RTLDRMODMACHO_CHECK_RETURN( uValue <= pSect->cb || ( paSyms[iSym].n_sect == 1 /* special hack for __mh_execute_header */ && uValue == 0U - pSect->RVA @@ -2085,5 +2086,5 @@ /** @todo implement indirect and prebound symbols. */ default: - KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO); } @@ -2113,5 +2114,5 @@ * @param pvUser See kLdrModEnumSymbols. */ -static int kldrModMachODoEnumSymbols64Bit(PKLDRMODMACHO pThis, const macho_nlist_64_t *paSyms, uint32_t cSyms, +static int kldrModMachODoEnumSymbols64Bit(PRTLDRMODMACHO pThis, const macho_nlist_64_t *paSyms, uint32_t cSyms, const char *pchStrings, uint32_t cchStrings, RTLDRADDR BaseAddress, uint32_t fFlags, PFNRTLDRENUMSYMS pfnCallback, void *pvUser) @@ -2155,5 +2156,5 @@ /* name */ - KLDRMODMACHO_CHECK_RETURN((uint32_t)paSyms[iSym].n_un.n_strx < cchStrings, VERR_LDRMACHO_BAD_SYMBOL); + RTLDRMODMACHO_CHECK_RETURN((uint32_t)paSyms[iSym].n_un.n_strx < cchStrings, VERR_LDRMACHO_BAD_SYMBOL); psz = &pchStrings[paSyms[iSym].n_un.n_strx]; cch = strlen(psz); @@ -2169,10 +2170,10 @@ case MACHO_N_SECT: { - PKLDRMODMACHOSECT pSect; - KLDRMODMACHO_CHECK_RETURN((uint32_t)(paSyms[iSym].n_sect - 1) < pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL); + PRTLDRMODMACHOSECT pSect; + RTLDRMODMACHO_CHECK_RETURN((uint32_t)(paSyms[iSym].n_sect - 1) < pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL); pSect = &pThis->paSections[paSyms[iSym].n_sect - 1]; uValue = paSyms[iSym].n_value - pSect->LinkAddress; - KLDRMODMACHO_CHECK_RETURN( uValue <= pSect->cb + RTLDRMODMACHO_CHECK_RETURN( uValue <= pSect->cb || ( paSyms[iSym].n_sect == 1 /* special hack for __mh_execute_header */ && uValue == 0U - pSect->RVA @@ -2197,5 +2198,5 @@ /** @todo implement indirect and prebound symbols. */ default: - KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO); } @@ -2215,5 +2216,5 @@ static int kldrModMachOGetImport(PRTLDRMODINTERNAL pMod, const void *pvBits, uint32_t iImport, char *pszName, size_t cchName) { - PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core); + PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core); RT_NOREF(pvBits); RT_NOREF(iImport); @@ -2233,5 +2234,5 @@ static int32_t kldrModMachONumberOfImports(PRTLDRMODINTERNAL pMod, const void *pvBits) { - PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core); + PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core); RT_NOREF(pvBits); @@ -2247,5 +2248,5 @@ static int kldrModMachOGetStackInfo(PRTLDRMODINTERNAL pMod, const void *pvBits, RTLDRADDR BaseAddress, PKLDRSTACKINFO pStackInfo) { - /*PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core);*/ + /*PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core);*/ RT_NOREF(pMod); RT_NOREF(pvBits); @@ -2265,5 +2266,5 @@ { #if 0 - PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core); + PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core); int rc; @@ -2298,5 +2299,5 @@ static DECLCALLBACK(int) rtldrMachO_EnumDbgInfo(PRTLDRMODINTERNAL pMod, const void *pvBits, PFNRTLDRENUMDBG pfnCallback, void *pvUser) { - PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core); + PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core); int rc = VINF_SUCCESS; uint32_t iSect; @@ -2335,5 +2336,5 @@ static int kldrModMachOHasDbgInfo(PRTLDRMODINTERNAL pMod, const void *pvBits) { - /*PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core);*/ + /*PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core);*/ #if 0 @@ -2357,5 +2358,5 @@ static int kldrModMachOMap(PRTLDRMODINTERNAL pMod) { - PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core); + PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core); unsigned fFixed; uint32_t i; @@ -2409,5 +2410,5 @@ static int kldrModMachOUnmap(PRTLDRMODINTERNAL pMod) { - PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core); + PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core); uint32_t i; int rc; @@ -2440,5 +2441,5 @@ static int kldrModMachOAllocTLS(PRTLDRMODINTERNAL pMod, void *pvMapping) { - PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core); + PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core); /* @@ -2464,5 +2465,5 @@ static int kldrModMachOReload(PRTLDRMODINTERNAL pMod) { - PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core); + PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core); /* @@ -2480,5 +2481,5 @@ static int kldrModMachOFixupMapping(PRTLDRMODINTERNAL pMod, PFNRTLDRIMPORT pfnGetImport, void *pvUser) { - PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core); + PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core); int rc, rc2; @@ -2522,5 +2523,5 @@ * @param pvUser User argument to the callback. */ -static int kldrModMachOObjDoImports(PKLDRMODMACHO pThis, RTLDRADDR BaseAddress, PFNRTLDRIMPORT pfnGetImport, void *pvUser) +static int kldrModMachOObjDoImports(PRTLDRMODMACHO pThis, RTLDRADDR BaseAddress, PFNRTLDRIMPORT pfnGetImport, void *pvUser) { const uint32_t cSyms = pThis->cSymbols; @@ -2556,8 +2557,8 @@ /** @todo Implement N_REF_TO_WEAK. */ - KLDRMODMACHO_CHECK_RETURN(!(paSyms[iSym].n_desc & N_REF_TO_WEAK), VERR_LDRMACHO_TODO); + RTLDRMODMACHO_CHECK_RETURN(!(paSyms[iSym].n_desc & N_REF_TO_WEAK), VERR_LDRMACHO_TODO); /* Get the symbol name. */ - KLDRMODMACHO_CHECK_RETURN((uint32_t)paSyms[iSym].n_un.n_strx < pThis->cchStrings, VERR_LDRMACHO_BAD_SYMBOL); + RTLDRMODMACHO_CHECK_RETURN((uint32_t)paSyms[iSym].n_un.n_strx < pThis->cchStrings, VERR_LDRMACHO_BAD_SYMBOL); pszSymbol = &pThis->pchStrings[paSyms[iSym].n_un.n_strx]; cchSymbol = strlen(pszSymbol); @@ -2615,8 +2616,8 @@ /** @todo Implement N_REF_TO_WEAK. */ - KLDRMODMACHO_CHECK_RETURN(!(paSyms[iSym].n_desc & N_REF_TO_WEAK), VERR_LDRMACHO_TODO); + RTLDRMODMACHO_CHECK_RETURN(!(paSyms[iSym].n_desc & N_REF_TO_WEAK), VERR_LDRMACHO_TODO); /* Get the symbol name. */ - KLDRMODMACHO_CHECK_RETURN(paSyms[iSym].n_un.n_strx < pThis->cchStrings, VERR_LDRMACHO_BAD_SYMBOL); + RTLDRMODMACHO_CHECK_RETURN(paSyms[iSym].n_un.n_strx < pThis->cchStrings, VERR_LDRMACHO_BAD_SYMBOL); pszSymbol = &pThis->pchStrings[paSyms[iSym].n_un.n_strx]; cchSymbol = strlen(pszSymbol); @@ -2669,5 +2670,5 @@ * @param NewBaseAddress The address to fixup the mapping to. */ -static int kldrModMachOObjDoFixups(PKLDRMODMACHO pThis, void *pvMapping, RTLDRADDR NewBaseAddress) +static int kldrModMachOObjDoFixups(PRTLDRMODMACHO pThis, void *pvMapping, RTLDRADDR NewBaseAddress) { /* @@ -2684,8 +2685,8 @@ for (uint32_t iSeg = 0; RT_SUCCESS(rc) && iSeg < pThis->cSegments; iSeg++) { - PKLDRMODMACHOSEG pSeg = &pThis->aSegments[iSeg]; + PRTLDRMODMACHOSEG pSeg = &pThis->aSegments[iSeg]; for (uint32_t iSect = 0; iSect < pSeg->cSections; iSect++) { - PKLDRMODMACHOSECT pSect = &pSeg->paSections[iSect]; + PRTLDRMODMACHOSECT pSect = &pSeg->paSections[iSect]; /* skip sections without fixups. */ @@ -2715,5 +2716,5 @@ pThis->cSymbols, NewBaseAddress); else - KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO); if (RT_FAILURE(rc)) break; @@ -2737,5 +2738,5 @@ * @param NewBaseAddress The new base image address. */ -static int kldrModMachOFixupSectionGeneric32Bit(PKLDRMODMACHO pThis, uint8_t *pbSectBits, PKLDRMODMACHOSECT pFixupSect, +static int kldrModMachOFixupSectionGeneric32Bit(PRTLDRMODMACHO pThis, uint8_t *pbSectBits, PRTLDRMODMACHOSECT pFixupSect, macho_nlist_32_t *paSyms, uint32_t cSyms, RTLDRADDR NewBaseAddress) { @@ -2815,6 +2816,6 @@ case MACHO_N_SECT: { - PKLDRMODMACHOSECT pSymSect; - KLDRMODMACHO_CHECK_RETURN((uint32_t)pSym->n_sect - 1 <= pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL); + PRTLDRMODMACHOSECT pSymSect; + RTLDRMODMACHO_CHECK_RETURN((uint32_t)pSym->n_sect - 1 <= pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL); pSymSect = &pThis->paSections[pSym->n_sect - 1]; @@ -2830,12 +2831,12 @@ case MACHO_N_INDR: case MACHO_N_PBUD: - KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO); default: - KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_SYMBOL); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_SYMBOL); } } else if (Fixup.r.r_symbolnum != R_ABS) { - PKLDRMODMACHOSECT pSymSect; + PRTLDRMODMACHOSECT pSymSect; if (Fixup.r.r_symbolnum > pThis->cSections) return VERR_LDR_BAD_FIXUP; @@ -2852,10 +2853,10 @@ else { - PKLDRMODMACHOSECT pSymSect; + PRTLDRMODMACHOSECT pSymSect; uint32_t iSymSect; RTLDRADDR Value; /* sanity */ - KLDRMODMACHO_ASSERT(Fixup.s.r_scattered); + RTLDRMODMACHO_ASSERT(Fixup.s.r_scattered); if ((uint32_t)Fixup.s.r_address >= cbSectBits) return VERR_LDR_BAD_FIXUP; @@ -2940,5 +2941,5 @@ * @param NewBaseAddress The new base image address. */ -static int kldrModMachOFixupSectionAMD64(PKLDRMODMACHO pThis, uint8_t *pbSectBits, PKLDRMODMACHOSECT pFixupSect, +static int kldrModMachOFixupSectionAMD64(PRTLDRMODMACHO pThis, uint8_t *pbSectBits, PRTLDRMODMACHOSECT pFixupSect, macho_nlist_64_t *paSyms, uint32_t cSyms, RTLDRADDR NewBaseAddress) { @@ -2977,8 +2978,8 @@ /* AMD64 doesn't use scattered fixups. */ - KLDRMODMACHO_CHECK_RETURN(!(Fixup.r.r_address & R_SCATTERED), VERR_LDR_BAD_FIXUP); + RTLDRMODMACHO_CHECK_RETURN(!(Fixup.r.r_address & R_SCATTERED), VERR_LDR_BAD_FIXUP); /* sanity */ - KLDRMODMACHO_CHECK_RETURN((uint32_t)Fixup.r.r_address < cbSectBits, VERR_LDR_BAD_FIXUP); + RTLDRMODMACHO_CHECK_RETURN((uint32_t)Fixup.r.r_address < cbSectBits, VERR_LDR_BAD_FIXUP); /* calc fixup addresses. */ @@ -2998,5 +2999,5 @@ case 3: SymAddr = *uFixVirgin.pi64; break; default: - KLDRMODMACHO_FAILED_RETURN(VERR_LDR_BAD_FIXUP); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDR_BAD_FIXUP); } @@ -3006,7 +3007,7 @@ const macho_nlist_64_t *pSym; - KLDRMODMACHO_CHECK_RETURN(Fixup.r.r_symbolnum < cSyms, VERR_LDR_BAD_FIXUP); + RTLDRMODMACHO_CHECK_RETURN(Fixup.r.r_symbolnum < cSyms, VERR_LDR_BAD_FIXUP); pSym = &paSyms[Fixup.r.r_symbolnum]; - KLDRMODMACHO_CHECK_RETURN(!(pSym->n_type & MACHO_N_STAB), VERR_LDR_BAD_FIXUP); + RTLDRMODMACHO_CHECK_RETURN(!(pSym->n_type & MACHO_N_STAB), VERR_LDR_BAD_FIXUP); switch (Fixup.r.r_type) @@ -3024,10 +3025,10 @@ case MACHO_N_INDR: case MACHO_N_PBUD: - KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO); default: - KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_SYMBOL); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_SYMBOL); } SymAddr = sizeof(uint64_t) * Fixup.r.r_symbolnum + pThis->GotRVA + NewBaseAddress; - KLDRMODMACHO_CHECK_RETURN(Fixup.r.r_length == 2, VERR_LDR_BAD_FIXUP); + RTLDRMODMACHO_CHECK_RETURN(Fixup.r.r_length == 2, VERR_LDR_BAD_FIXUP); SymAddr -= 4; break; @@ -3039,5 +3040,5 @@ case X86_64_RELOC_SIGNED_2: case X86_64_RELOC_SIGNED_4: - KLDRMODMACHO_CHECK_RETURN(Fixup.r.r_pcrel, VERR_LDR_BAD_FIXUP); + RTLDRMODMACHO_CHECK_RETURN(Fixup.r.r_pcrel, VERR_LDR_BAD_FIXUP); /* Falls through. */ default: @@ -3047,8 +3048,8 @@ { case X86_64_RELOC_UNSIGNED: - KLDRMODMACHO_CHECK_RETURN(!Fixup.r.r_pcrel, VERR_LDR_BAD_FIXUP); + RTLDRMODMACHO_CHECK_RETURN(!Fixup.r.r_pcrel, VERR_LDR_BAD_FIXUP); break; case X86_64_RELOC_BRANCH: - KLDRMODMACHO_CHECK_RETURN(Fixup.r.r_length == 2, VERR_LDR_BAD_FIXUP); + RTLDRMODMACHO_CHECK_RETURN(Fixup.r.r_length == 2, VERR_LDR_BAD_FIXUP); SymAddr -= 4; break; @@ -3060,5 +3061,5 @@ break; default: - KLDRMODMACHO_FAILED_RETURN(VERR_LDR_BAD_FIXUP); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDR_BAD_FIXUP); } @@ -3067,6 +3068,6 @@ case MACHO_N_SECT: { - PKLDRMODMACHOSECT pSymSect; - KLDRMODMACHO_CHECK_RETURN((uint32_t)pSym->n_sect - 1 <= pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL); + PRTLDRMODMACHOSECT pSymSect; + RTLDRMODMACHO_CHECK_RETURN((uint32_t)pSym->n_sect - 1 <= pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL); pSymSect = &pThis->paSections[pSym->n_sect - 1]; SymAddr += pSym->n_value - pSymSect->LinkAddress + pSymSect->RVA + NewBaseAddress; @@ -3092,7 +3093,7 @@ case MACHO_N_INDR: case MACHO_N_PBUD: - KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO); default: - KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_SYMBOL); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_SYMBOL); } break; @@ -3111,6 +3112,6 @@ case MACHO_N_SECT: { - PKLDRMODMACHOSECT pSymSect; - KLDRMODMACHO_CHECK_RETURN((uint32_t)pSym->n_sect - 1 <= pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL); + PRTLDRMODMACHOSECT pSymSect; + RTLDRMODMACHO_CHECK_RETURN((uint32_t)pSym->n_sect - 1 <= pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL); pSymSect = &pThis->paSections[pSym->n_sect - 1]; SymAddr -= pSym->n_value - pSymSect->LinkAddress + pSymSect->RVA + NewBaseAddress; @@ -3125,14 +3126,14 @@ case MACHO_N_INDR: case MACHO_N_PBUD: - KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO); default: - KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_SYMBOL); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_SYMBOL); } /* Load the 2nd fixup, check sanity. */ iFixup++; - KLDRMODMACHO_CHECK_RETURN(!Fixup.r.r_pcrel && iFixup < cFixups, VERR_LDR_BAD_FIXUP); + RTLDRMODMACHO_CHECK_RETURN(!Fixup.r.r_pcrel && iFixup < cFixups, VERR_LDR_BAD_FIXUP); Fixup2 = paFixups[iFixup]; - KLDRMODMACHO_CHECK_RETURN( Fixup2.r_address == Fixup.r.r_address + RTLDRMODMACHO_CHECK_RETURN( Fixup2.r_address == Fixup.r.r_address && Fixup2.r_length == Fixup.r.r_length && Fixup2.r_type == X86_64_RELOC_UNSIGNED @@ -3143,7 +3144,7 @@ if (Fixup2.r_extern) { - KLDRMODMACHO_CHECK_RETURN(Fixup2.r_symbolnum < cSyms, VERR_LDR_BAD_FIXUP); + RTLDRMODMACHO_CHECK_RETURN(Fixup2.r_symbolnum < cSyms, VERR_LDR_BAD_FIXUP); pSym = &paSyms[Fixup2.r_symbolnum]; - KLDRMODMACHO_CHECK_RETURN(!(pSym->n_type & MACHO_N_STAB), VERR_LDR_BAD_FIXUP); + RTLDRMODMACHO_CHECK_RETURN(!(pSym->n_type & MACHO_N_STAB), VERR_LDR_BAD_FIXUP); /* Add it's value to SymAddr. */ @@ -3152,6 +3153,6 @@ case MACHO_N_SECT: { - PKLDRMODMACHOSECT pSymSect; - KLDRMODMACHO_CHECK_RETURN((uint32_t)pSym->n_sect - 1 <= pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL); + PRTLDRMODMACHOSECT pSymSect; + RTLDRMODMACHO_CHECK_RETURN((uint32_t)pSym->n_sect - 1 <= pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL); pSymSect = &pThis->paSections[pSym->n_sect - 1]; SymAddr += pSym->n_value - pSymSect->LinkAddress + pSymSect->RVA + NewBaseAddress; @@ -3166,18 +3167,18 @@ case MACHO_N_INDR: case MACHO_N_PBUD: - KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO); default: - KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_SYMBOL); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_SYMBOL); } } else if (Fixup2.r_symbolnum != R_ABS) { - PKLDRMODMACHOSECT pSymSect; - KLDRMODMACHO_CHECK_RETURN(Fixup2.r_symbolnum <= pThis->cSections, VERR_LDR_BAD_FIXUP); + PRTLDRMODMACHOSECT pSymSect; + RTLDRMODMACHO_CHECK_RETURN(Fixup2.r_symbolnum <= pThis->cSections, VERR_LDR_BAD_FIXUP); pSymSect = &pThis->paSections[Fixup2.r_symbolnum - 1]; SymAddr += pSymSect->RVA + NewBaseAddress; } else - KLDRMODMACHO_FAILED_RETURN(VERR_LDR_BAD_FIXUP); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDR_BAD_FIXUP); } break; @@ -3190,8 +3191,8 @@ { case X86_64_RELOC_UNSIGNED: - KLDRMODMACHO_CHECK_RETURN(!Fixup.r.r_pcrel, VERR_LDR_BAD_FIXUP); + RTLDRMODMACHO_CHECK_RETURN(!Fixup.r.r_pcrel, VERR_LDR_BAD_FIXUP); break; case X86_64_RELOC_BRANCH: - KLDRMODMACHO_CHECK_RETURN(Fixup.r.r_pcrel, VERR_LDR_BAD_FIXUP); + RTLDRMODMACHO_CHECK_RETURN(Fixup.r.r_pcrel, VERR_LDR_BAD_FIXUP); SymAddr += 4; /* dunno what the assmbler/linker really is doing here... */ break; @@ -3200,5 +3201,5 @@ case X86_64_RELOC_SIGNED_2: case X86_64_RELOC_SIGNED_4: - KLDRMODMACHO_CHECK_RETURN(Fixup.r.r_pcrel, VERR_LDR_BAD_FIXUP); + RTLDRMODMACHO_CHECK_RETURN(Fixup.r.r_pcrel, VERR_LDR_BAD_FIXUP); break; /*case X86_64_RELOC_GOT_LOAD:*/ @@ -3206,10 +3207,10 @@ /*case X86_64_RELOC_SUBTRACTOR: - must be r_extern=1 says as. */ default: - KLDRMODMACHO_FAILED_RETURN(VERR_LDR_BAD_FIXUP); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDR_BAD_FIXUP); } if (Fixup.r.r_symbolnum != R_ABS) { - PKLDRMODMACHOSECT pSymSect; - KLDRMODMACHO_CHECK_RETURN(Fixup.r.r_symbolnum <= pThis->cSections, VERR_LDR_BAD_FIXUP); + PRTLDRMODMACHOSECT pSymSect; + RTLDRMODMACHO_CHECK_RETURN(Fixup.r.r_symbolnum <= pThis->cSections, VERR_LDR_BAD_FIXUP); pSymSect = &pThis->paSections[Fixup.r.r_symbolnum - 1]; @@ -3234,10 +3235,10 @@ break; case 2: - KLDRMODMACHO_CHECK_RETURN(Fixup.r.r_pcrel || Fixup.r.r_type == X86_64_RELOC_SUBTRACTOR, VERR_LDR_BAD_FIXUP); - KLDRMODMACHO_CHECK_RETURN((int32_t)SymAddr == (int64_t)SymAddr, VERR_LDR_ADDRESS_OVERFLOW); + RTLDRMODMACHO_CHECK_RETURN(Fixup.r.r_pcrel || Fixup.r.r_type == X86_64_RELOC_SUBTRACTOR, VERR_LDR_BAD_FIXUP); + RTLDRMODMACHO_CHECK_RETURN((int32_t)SymAddr == (int64_t)SymAddr, VERR_LDR_ADDRESS_OVERFLOW); *uFix.pu32 = (uint32_t)SymAddr; break; default: - KLDRMODMACHO_FAILED_RETURN(VERR_LDR_BAD_FIXUP); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDR_BAD_FIXUP); } } @@ -3250,10 +3251,10 @@ * Loads the symbol table for a MH_OBJECT file. * - * The symbol table is pointed to by KLDRMODMACHO::pvaSymbols. + * The symbol table is pointed to by RTLDRMODMACHO::pvaSymbols. * * @returns IPRT status code. * @param pThis The Mach-O module interpreter instance. */ -static int kldrModMachOLoadObjSymTab(PKLDRMODMACHO pThis) +static int kldrModMachOLoadObjSymTab(PRTLDRMODMACHO pThis) { int rc = VINF_SUCCESS; @@ -3268,5 +3269,5 @@ /* sanity */ - KLDRMODMACHO_CHECK_RETURN( pThis->offSymbols + RTLDRMODMACHO_CHECK_RETURN( pThis->offSymbols && (!pThis->cchStrings || pThis->offStrings), VERR_LDRMACHO_BAD_OBJECT_FILE); @@ -3278,5 +3279,5 @@ : sizeof(macho_nlist_64_t); cbSyms = pThis->cSymbols * cbSym; - KLDRMODMACHO_CHECK_RETURN(cbSyms / cbSym == pThis->cSymbols, VERR_LDRMACHO_BAD_SYMTAB_SIZE); + RTLDRMODMACHO_CHECK_RETURN(cbSyms / cbSym == pThis->cSymbols, VERR_LDRMACHO_BAD_SYMTAB_SIZE); rc = VERR_NO_MEMORY; pvSyms = RTMemAlloc(cbSyms); @@ -3333,5 +3334,5 @@ } else - KLDRMODMACHO_ASSERT(pThis->pchStrings || pThis->Hdr.filetype == MH_DSYM); + RTLDRMODMACHO_ASSERT(pThis->pchStrings || pThis->Hdr.filetype == MH_DSYM); return rc; @@ -3349,5 +3350,5 @@ * @param ppaFixups Where to put the pointer to the allocated fixup array. */ -static int kldrModMachOLoadFixups(PKLDRMODMACHO pThis, RTFOFF offFixups, uint32_t cFixups, macho_relocation_info_t **ppaFixups) +static int kldrModMachOLoadFixups(PRTLDRMODMACHO pThis, RTFOFF offFixups, uint32_t cFixups, macho_relocation_info_t **ppaFixups) { macho_relocation_info_t *paFixups; @@ -3356,5 +3357,5 @@ /* allocate the memory. */ cbFixups = cFixups * sizeof(*paFixups); - KLDRMODMACHO_CHECK_RETURN(cbFixups / sizeof(*paFixups) == cFixups, VERR_LDRMACHO_BAD_SYMTAB_SIZE); + RTLDRMODMACHO_CHECK_RETURN(cbFixups / sizeof(*paFixups) == cFixups, VERR_LDRMACHO_BAD_SYMTAB_SIZE); paFixups = (macho_relocation_info_t *)RTMemAlloc(cbFixups); if (!paFixups) @@ -3392,5 +3393,5 @@ * @param pThis The Mach-O module interpreter instance. */ -static int kldrModMachOMapVirginBits(PKLDRMODMACHO pThis) +static int kldrModMachOMapVirginBits(PRTLDRMODMACHO pThis) { int rc = VINF_SUCCESS; @@ -3443,5 +3444,5 @@ static DECLCALLBACK(size_t) rtldrMachO_GetImageSize(PRTLDRMODINTERNAL pMod) { - PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core); + PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core); return pThis->cbImage; } @@ -3454,5 +3455,5 @@ PFNRTLDRIMPORT pfnGetImport, void *pvUser) { - PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core); + PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core); if (!pThis->fCanLoad) @@ -3496,5 +3497,5 @@ RTUINTPTR OldBaseAddress, PFNRTLDRIMPORT pfnGetImport, void *pvUser) { - PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core); + PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core); int rc; RT_NOREF(OldBaseAddress); @@ -3535,5 +3536,5 @@ * the bits has been cleared up front. */ -static int kldrModMachOMakeGOT(PKLDRMODMACHO pThis, void *pvBits, RTLDRADDR NewBaseAddress) +static int kldrModMachOMakeGOT(PRTLDRMODMACHO pThis, void *pvBits, RTLDRADDR NewBaseAddress) { uint32_t iSym = pThis->cSymbols; @@ -3548,6 +3549,6 @@ case MACHO_N_SECT: { - PKLDRMODMACHOSECT pSymSect; - KLDRMODMACHO_CHECK_RETURN((uint32_t)paSyms[iSym].n_sect - 1 <= pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL); + PRTLDRMODMACHOSECT pSymSect; + RTLDRMODMACHO_CHECK_RETURN((uint32_t)paSyms[iSym].n_sect - 1 <= pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL); pSymSect = &pThis->paSections[paSyms[iSym].n_sect - 1]; paGOT[iSym] = (uint32_t)(paSyms[iSym].n_value - pSymSect->LinkAddress + pSymSect->RVA + NewBaseAddress); @@ -3571,6 +3572,6 @@ case MACHO_N_SECT: { - PKLDRMODMACHOSECT pSymSect; - KLDRMODMACHO_CHECK_RETURN((uint32_t)paSyms[iSym].n_sect - 1 <= pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL); + PRTLDRMODMACHOSECT pSymSect; + RTLDRMODMACHO_CHECK_RETURN((uint32_t)paSyms[iSym].n_sect - 1 <= pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL); pSymSect = &pThis->paSections[paSyms[iSym].n_sect - 1]; paGOT[iSym] = paSyms[iSym].n_value - pSymSect->LinkAddress + pSymSect->RVA + NewBaseAddress; @@ -3625,5 +3626,5 @@ default: - KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO); + RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO); } } @@ -3638,5 +3639,5 @@ static DECLCALLBACK(int) rtldrMachO_EnumSegments(PRTLDRMODINTERNAL pMod, PFNRTLDRENUMSEGS pfnCallback, void *pvUser) { - PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core); + PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core); uint32_t const cSegments = pThis->cSegments; for (uint32_t iSeg = 0; iSeg < cSegments; iSeg++) @@ -3657,5 +3658,5 @@ uint32_t *piSeg, PRTLDRADDR poffSeg) { - PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core); + PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core); uint32_t const cSegments = pThis->cSegments; for (uint32_t iSeg = 0; iSeg < cSegments; iSeg++) @@ -3680,5 +3681,5 @@ static DECLCALLBACK(int) rtldrMachO_LinkAddressToRva(PRTLDRMODINTERNAL pMod, RTLDRADDR LinkAddress, PRTLDRADDR pRva) { - PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core); + PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core); uint32_t const cSegments = pThis->cSegments; for (uint32_t iSeg = 0; iSeg < cSegments; iSeg++) @@ -3702,9 +3703,9 @@ static DECLCALLBACK(int) rtldrMachO_SegOffsetToRva(PRTLDRMODINTERNAL pMod, uint32_t iSeg, RTLDRADDR offSeg, PRTLDRADDR pRva) { - PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core); + PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core); if (iSeg >= pThis->cSegments) return VERR_LDR_INVALID_SEG_OFFSET; - KLDRMODMACHOSEG const *pSegment = &pThis->aSegments[iSeg]; + RTLDRMODMACHOSEG const *pSegment = &pThis->aSegments[iSeg]; if ( offSeg > pSegment->SegInfo.cbMapped @@ -3724,5 +3725,5 @@ static DECLCALLBACK(int) rtldrMachO_RvaToSegOffset(PRTLDRMODINTERNAL pMod, RTLDRADDR Rva, uint32_t *piSeg, PRTLDRADDR poffSeg) { - PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core); + PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core); uint32_t const cSegments = pThis->cSegments; for (uint32_t iSeg = 0; iSeg < cSegments; iSeg++) @@ -3747,5 +3748,5 @@ static DECLCALLBACK(int) rtldrMachO_ReadDbgInfo(PRTLDRMODINTERNAL pMod, uint32_t iDbgInfo, RTFOFF off, size_t cb, void *pvBuf) { - PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core); + PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core); /** @todo May have to apply fixups here. */ @@ -3760,5 +3761,5 @@ void *pvBuf, size_t cbBuf, size_t *pcbRet) { - PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core); + PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core); int rc; switch (enmProp) @@ -3830,5 +3831,5 @@ * Create the instance data and do a minimal header validation. */ - PKLDRMODMACHO pThis = NULL; + PRTLDRMODMACHO pThis = NULL; int rc = kldrModMachODoCreate(pReader, offImage, fFlags, &pThis, pErrInfo); if (RT_SUCCESS(rc)) Index: /trunk/src/VBox/Runtime/testcase/tstLdr-3.cpp =================================================================== --- /trunk/src/VBox/Runtime/testcase/tstLdr-3.cpp (revision 74646) +++ /trunk/src/VBox/Runtime/testcase/tstLdr-3.cpp (revision 74647) @@ -231,5 +231,8 @@ if (hLdrMod != g_hLdrMod || pvUser != NULL) return VERR_INTERNAL_ERROR_3; - RTPrintf("Seg#%02u: %RTptr LB %RTptr %s\n", g_iSegNo++, pSeg->RVA, pSeg->cbMapped, pSeg->pszName); + RTPrintf("Seg#%02u: %RTptr LB %RTptr %s\n" + " link=%RTptr LB %RTptr align=%RTptr fProt=%#x offFile=%RTfoff\n" + , g_iSegNo++, pSeg->RVA, pSeg->cbMapped, pSeg->pszName, + pSeg->LinkAddress, pSeg->cb, pSeg->Alignment, pSeg->fProt, pSeg->offFile); return VINF_SUCCESS;