VirtualBox

Changeset 74647 in vbox for trunk/src/VBox


Ignore:
Timestamp:
Oct 6, 2018 9:29:40 PM (6 years ago)
Author:
vboxsync
Message:

IPRT: Fixed segment alignment bug in the mach-o code. bugref:9232

Location:
trunk/src/VBox/Runtime
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Runtime/common/ldr/ldrMachO.cpp

    r74646 r74647  
    5151*   Defined Constants And Macros                                                                                                 *
    5252*********************************************************************************************************************************/
    53 /** @def KLDRMODMACHO_STRICT
    54  * Define KLDRMODMACHO_STRICT to enabled strict checks in KLDRMODMACHO. */
    55 #define KLDRMODMACHO_STRICT 1
    56 
    57 /** @def KLDRMODMACHO_ASSERT
     53/** @def RTLDRMODMACHO_STRICT
     54 * Define RTLDRMODMACHO_STRICT to enabled strict checks in RTLDRMODMACHO. */
     55#define RTLDRMODMACHO_STRICT 1
     56
     57/** @def RTLDRMODMACHO_ASSERT
    5858 * Assert that an expression is true when KLDR_STRICT is defined.
    5959 */
    60 #ifdef KLDRMODMACHO_STRICT
    61 # define KLDRMODMACHO_ASSERT(expr)  Assert(expr)
     60#ifdef RTLDRMODMACHO_STRICT
     61# define RTLDRMODMACHO_ASSERT(expr)  Assert(expr)
    6262#else
    63 # define KLDRMODMACHO_ASSERT(expr)  do {} while (0)
     63# define RTLDRMODMACHO_ASSERT(expr)  do {} while (0)
    6464#endif
    6565
    66 /** @def KLDRMODMACHO_CHECK_RETURN
     66/** @def RTLDRMODMACHO_CHECK_RETURN
    6767 * Checks that an expression is true and return if it isn't.
    6868 * This is a debug aid.
    6969 */
    70 #ifdef KLDRMODMACHO_STRICT2
    71 # define KLDRMODMACHO_CHECK_RETURN(expr, rc)  AssertReturn(expr, rc)
     70#ifdef RTLDRMODMACHO_STRICT2
     71# define RTLDRMODMACHO_CHECK_RETURN(expr, rc)  AssertReturn(expr, rc)
    7272#else
    73 # define KLDRMODMACHO_CHECK_RETURN(expr, rc)  do { if (!(expr)) { return (rc); } } while (0)
     73# define RTLDRMODMACHO_CHECK_RETURN(expr, rc)  do { if (!(expr)) { return (rc); } } while (0)
    7474#endif
    7575
    76 /** @def KLDRMODMACHO_CHECK_RETURN
     76/** @def RTLDRMODMACHO_CHECK_RETURN
    7777 * Checks that an expression is true and return if it isn't.
    7878 * This is a debug aid.
    7979 */
    80 #ifdef KLDRMODMACHO_STRICT2
    81 # define KLDRMODMACHO_FAILED_RETURN(rc)  AssertFailedReturn(rc)
     80#ifdef RTLDRMODMACHO_STRICT2
     81# define RTLDRMODMACHO_FAILED_RETURN(rc)  AssertFailedReturn(rc)
    8282#else
    83 # define KLDRMODMACHO_FAILED_RETURN(rc)  return (rc)
     83# define RTLDRMODMACHO_FAILED_RETURN(rc)  return (rc)
    8484#endif
    8585
    … …  
    9191 * Mach-O section details.
    9292 */
    93 typedef struct KLDRMODMACHOSECT
     93typedef struct RTLDRMODMACHOSECT
    9494{
    9595    /** The size of the section (in bytes). */
    … …  
    115115    /** Pointer to the Mach-O section structure. */
    116116    void                   *pvMachoSection;
    117 } KLDRMODMACHOSECT, *PKLDRMODMACHOSECT;
     117} RTLDRMODMACHOSECT, *PRTLDRMODMACHOSECT;
    118118
    119119/**
    … …  
    122122 * This is corresponds to a kLdr segment, not a Mach-O segment!
    123123 */
    124 typedef struct KLDRMODMACHOSEG
     124typedef struct RTLDRMODMACHOSEG
    125125{
    126126    /** Common segment info. */
    … …  
    134134     * The array resides in the big memory chunk allocated for
    135135     * the module handle, so it doesn't need freeing. */
    136     PKLDRMODMACHOSECT       paSections;
    137 
    138 } KLDRMODMACHOSEG, *PKLDRMODMACHOSEG;
     136    PRTLDRMODMACHOSECT      paSections;
     137
     138} RTLDRMODMACHOSEG, *PRTLDRMODMACHOSEG;
    139139
    140140/**
    … …  
    142142 * @todo interpret the other MH_* formats.
    143143 */
    144 typedef struct KLDRMODMACHO
     144typedef struct RTLDRMODMACHO
    145145{
    146146    /** Core module structure. */
    … …  
    209209    uint32_t                cSections;
    210210    /** Pointer to the section array running in parallel to the Mach-O one. */
    211     PKLDRMODMACHOSECT       paSections;
     211    PRTLDRMODMACHOSECT      paSections;
    212212
    213213    /** Array of segments parallel to the one in KLDRMOD. */
    214     KLDRMODMACHOSEG         aSegments[1];
    215 } KLDRMODMACHO, *PKLDRMODMACHO;
     214    RTLDRMODMACHOSEG        aSegments[1];
     215} RTLDRMODMACHO, *PRTLDRMODMACHO;
    216216
    217217
    … …  
    231231                                             uint32_t fOpenFlags, uint32_t *pcSegments, uint32_t *pcSections, uint32_t *pcbStringPool,
    232232                                             bool *pfCanLoad, PRTLDRADDR pLinkAddress, uint8_t *puEffFileType, PRTERRINFO pErrInfo);
    233 static int  kldrModMachOParseLoadCommands(PKLDRMODMACHO pThis, char *pbStringPool, uint32_t cbStringPool);
    234 
    235 static int  kldrModMachOLoadObjSymTab(PKLDRMODMACHO pThis);
    236 static int  kldrModMachOLoadFixups(PKLDRMODMACHO pThis, RTFOFF offFixups, uint32_t cFixups, macho_relocation_info_t **ppaFixups);
    237 static int  kldrModMachOMapVirginBits(PKLDRMODMACHO pThis);
    238 
    239 static int  kldrModMachODoQuerySymbol32Bit(PKLDRMODMACHO pThis, const macho_nlist_32_t *paSyms, uint32_t cSyms, const char *pchStrings,
     233static int  kldrModMachOParseLoadCommands(PRTLDRMODMACHO pThis, char *pbStringPool, uint32_t cbStringPool);
     234
     235static int  kldrModMachOLoadObjSymTab(PRTLDRMODMACHO pThis);
     236static int  kldrModMachOLoadFixups(PRTLDRMODMACHO pThis, RTFOFF offFixups, uint32_t cFixups, macho_relocation_info_t **ppaFixups);
     237static int  kldrModMachOMapVirginBits(PRTLDRMODMACHO pThis);
     238
     239static int  kldrModMachODoQuerySymbol32Bit(PRTLDRMODMACHO pThis, const macho_nlist_32_t *paSyms, uint32_t cSyms, const char *pchStrings,
    240240                                           uint32_t cchStrings, RTLDRADDR BaseAddress, uint32_t iSymbol, const char *pchSymbol,
    241241                                           uint32_t cchSymbol, PRTLDRADDR puValue, uint32_t *pfKind);
    242 static int  kldrModMachODoQuerySymbol64Bit(PKLDRMODMACHO pThis, const macho_nlist_64_t *paSyms, uint32_t cSyms, const char *pchStrings,
     242static int  kldrModMachODoQuerySymbol64Bit(PRTLDRMODMACHO pThis, const macho_nlist_64_t *paSyms, uint32_t cSyms, const char *pchStrings,
    243243                                           uint32_t cchStrings, RTLDRADDR BaseAddress, uint32_t iSymbol, const char *pchSymbol,
    244244                                           uint32_t cchSymbol, PRTLDRADDR puValue, uint32_t *pfKind);
    245 static int  kldrModMachODoEnumSymbols32Bit(PKLDRMODMACHO pThis, const macho_nlist_32_t *paSyms, uint32_t cSyms,
     245static int  kldrModMachODoEnumSymbols32Bit(PRTLDRMODMACHO pThis, const macho_nlist_32_t *paSyms, uint32_t cSyms,
    246246                                           const char *pchStrings, uint32_t cchStrings, RTLDRADDR BaseAddress,
    247247                                           uint32_t fFlags, PFNRTLDRENUMSYMS pfnCallback, void *pvUser);
    248 static int  kldrModMachODoEnumSymbols64Bit(PKLDRMODMACHO pThis, const macho_nlist_64_t *paSyms, uint32_t cSyms,
     248static int  kldrModMachODoEnumSymbols64Bit(PRTLDRMODMACHO pThis, const macho_nlist_64_t *paSyms, uint32_t cSyms,
    249249                                           const char *pchStrings, uint32_t cchStrings, RTLDRADDR BaseAddress,
    250250                                           uint32_t fFlags, PFNRTLDRENUMSYMS pfnCallback, void *pvUser);
    251 static int  kldrModMachOObjDoImports(PKLDRMODMACHO pThis, RTLDRADDR BaseAddress, PFNRTLDRIMPORT pfnGetImport, void *pvUser);
    252 static int  kldrModMachOObjDoFixups(PKLDRMODMACHO pThis, void *pvMapping, RTLDRADDR NewBaseAddress);
    253 static int  kldrModMachOFixupSectionGeneric32Bit(PKLDRMODMACHO pThis, uint8_t *pbSectBits, PKLDRMODMACHOSECT pFixupSect,
     251static int  kldrModMachOObjDoImports(PRTLDRMODMACHO pThis, RTLDRADDR BaseAddress, PFNRTLDRIMPORT pfnGetImport, void *pvUser);
     252static int  kldrModMachOObjDoFixups(PRTLDRMODMACHO pThis, void *pvMapping, RTLDRADDR NewBaseAddress);
     253static int  kldrModMachOFixupSectionGeneric32Bit(PRTLDRMODMACHO pThis, uint8_t *pbSectBits, PRTLDRMODMACHOSECT pFixupSect,
    254254                                                 macho_nlist_32_t *paSyms, uint32_t cSyms, RTLDRADDR NewBaseAddress);
    255 static int  kldrModMachOFixupSectionAMD64(PKLDRMODMACHO pThis, uint8_t *pbSectBits, PKLDRMODMACHOSECT pFixupSect,
     255static int  kldrModMachOFixupSectionAMD64(PRTLDRMODMACHO pThis, uint8_t *pbSectBits, PRTLDRMODMACHOSECT pFixupSect,
    256256                                          macho_nlist_64_t *paSyms, uint32_t cSyms, RTLDRADDR NewBaseAddress);
    257257
    258 static int  kldrModMachOMakeGOT(PKLDRMODMACHO pThis, void *pvBits, RTLDRADDR NewBaseAddress);
    259 
    260 /*static int  kldrModMachODoFixups(PKLDRMODMACHO pThis, void *pvMapping, RTLDRADDR NewBaseAddress, RTLDRADDR OldBaseAddress);
    261 static int  kldrModMachODoImports(PKLDRMODMACHO pThis, void *pvMapping, PFNRTLDRIMPORT pfnGetImport, void *pvUser);*/
     258static int  kldrModMachOMakeGOT(PRTLDRMODMACHO pThis, void *pvBits, RTLDRADDR NewBaseAddress);
     259
     260/*static int  kldrModMachODoFixups(PRTLDRMODMACHO pThis, void *pvMapping, RTLDRADDR NewBaseAddress, RTLDRADDR OldBaseAddress);
     261static int  kldrModMachODoImports(PRTLDRMODMACHO pThis, void *pvMapping, PFNRTLDRIMPORT pfnGetImport, void *pvUser);*/
    262262
    263263
    … …  
    268268 */
    269269static int kldrModMachODoCreate(PRTLDRREADER pRdr, RTFOFF offImage, uint32_t fOpenFlags,
    270                                 PKLDRMODMACHO *ppModMachO, PRTERRINFO pErrInfo)
     270                                PRTLDRMODMACHO *ppModMachO, PRTERRINFO pErrInfo)
    271271{
    272272    *ppModMachO = NULL;
    … …  
    357357     * Calc the instance size, allocate and initialize it.
    358358     */
    359     size_t const cbModAndSegs = RT_ALIGN_Z(RT_UOFFSETOF_DYN(KLDRMODMACHO, aSegments[cSegments])
    360                                            + sizeof(KLDRMODMACHOSECT) * cSections, 16);
    361     PKLDRMODMACHO pThis = (PKLDRMODMACHO)RTMemAlloc(cbModAndSegs + cbStringPool);
     359    size_t const cbModAndSegs = RT_ALIGN_Z(RT_UOFFSETOF_DYN(RTLDRMODMACHO, aSegments[cSegments])
     360                                           + sizeof(RTLDRMODMACHOSECT) * cSections, 16);
     361    PRTLDRMODMACHO pThis = (PRTLDRMODMACHO)RTMemAlloc(cbModAndSegs + cbStringPool);
    362362    if (!pThis)
    363363        return VERR_NO_MEMORY;
    … …  
    445445    }
    446446
    447     /* KLDRMODMACHO */
     447    /* RTLDRMODMACHO */
    448448    pThis->cSegments = cSegments;
    449449    pThis->pvBits = NULL;
    … …  
    470470    pThis->JmpStubsRVA = NIL_RTLDRADDR;
    471471    pThis->cSections = cSections;
    472     pThis->paSections = (PKLDRMODMACHOSECT)&pThis->aSegments[pThis->cSegments];
     472    pThis->paSections = (PRTLDRMODMACHOSECT)&pThis->aSegments[pThis->cSegments];
    473473
    474474    /*
    … …  
    560560         * Convert and validate command header.
    561561         */
    562         KLDRMODMACHO_CHECK_RETURN(cbLeft >= sizeof(load_command_t), VERR_LDRMACHO_BAD_LOAD_COMMAND);
     562        RTLDRMODMACHO_CHECK_RETURN(cbLeft >= sizeof(load_command_t), VERR_LDRMACHO_BAD_LOAD_COMMAND);
    563563        if (fConvertEndian)
    564564        {
    … …  
    566566            u.pLoadCmd->cmdsize = RT_BSWAP_U32(u.pLoadCmd->cmdsize);
    567567        }
    568         KLDRMODMACHO_CHECK_RETURN(u.pLoadCmd->cmdsize <= cbLeft, VERR_LDRMACHO_BAD_LOAD_COMMAND);
     568        RTLDRMODMACHO_CHECK_RETURN(u.pLoadCmd->cmdsize <= cbLeft, VERR_LDRMACHO_BAD_LOAD_COMMAND);
    569569        cbLeft -= u.pLoadCmd->cmdsize;
    570570        pb += u.pLoadCmd->cmdsize;
    … …  
    584584
    585585                /* Convert and verify the segment. */
    586                 KLDRMODMACHO_CHECK_RETURN(u.pLoadCmd->cmdsize >= sizeof(segment_command_32_t), VERR_LDRMACHO_BAD_LOAD_COMMAND);
    587                 KLDRMODMACHO_CHECK_RETURN(   pHdr->magic == IMAGE_MACHO32_SIGNATURE_OE
     586                RTLDRMODMACHO_CHECK_RETURN(u.pLoadCmd->cmdsize >= sizeof(segment_command_32_t), VERR_LDRMACHO_BAD_LOAD_COMMAND);
     587                RTLDRMODMACHO_CHECK_RETURN(   pHdr->magic == IMAGE_MACHO32_SIGNATURE_OE
    588588                                          || pHdr->magic == IMAGE_MACHO32_SIGNATURE, VERR_LDRMACHO_BIT_MIX);
    589589                if (fConvertEndian)
    … …  
    613613                        *puEffFileType = uEffFileType = MH_OBJECT; \
    614614                    \
    615                     KLDRMODMACHO_CHECK_RETURN(   pSrcSeg->filesize == 0 \
     615                    RTLDRMODMACHO_CHECK_RETURN(   pSrcSeg->filesize == 0 \
    616616                                              || (   pSrcSeg->fileoff <= cbFile \
    617617                                                  && (uint64_t)pSrcSeg->fileoff + pSrcSeg->filesize <= cbFile), \
    618618                                              VERR_LDRMACHO_BAD_LOAD_COMMAND); \
    619                     KLDRMODMACHO_CHECK_RETURN(   pSrcSeg->filesize <= pSrcSeg->vmsize \
     619                    RTLDRMODMACHO_CHECK_RETURN(   pSrcSeg->filesize <= pSrcSeg->vmsize \
    620620                                              || (fSkipSeg && !strcmp(pSrcSeg->segname, "__CTF") /* see above */), \
    621621                                              VERR_LDRMACHO_BAD_LOAD_COMMAND); \
    622                     KLDRMODMACHO_CHECK_RETURN(!(~pSrcSeg->maxprot & pSrcSeg->initprot), \
     622                    RTLDRMODMACHO_CHECK_RETURN(!(~pSrcSeg->maxprot & pSrcSeg->initprot), \
    623623                                              VERR_LDRMACHO_BAD_LOAD_COMMAND); \
    624                     KLDRMODMACHO_CHECK_RETURN(!(pSrcSeg->flags & ~(SG_HIGHVM | SG_FVMLIB | SG_NORELOC | SG_PROTECTED_VERSION_1)), \
     624                    RTLDRMODMACHO_CHECK_RETURN(!(pSrcSeg->flags & ~(SG_HIGHVM | SG_FVMLIB | SG_NORELOC | SG_PROTECTED_VERSION_1)), \
    625625                                              VERR_LDRMACHO_BAD_LOAD_COMMAND); \
    626                     KLDRMODMACHO_CHECK_RETURN(   pSrcSeg->nsects * sizeof(section_##a_cBits##_t) \
     626                    RTLDRMODMACHO_CHECK_RETURN(   pSrcSeg->nsects * sizeof(section_##a_cBits##_t) \
    627627                                              <= u.pLoadCmd->cmdsize - sizeof(segment_command_##a_cBits##_t), \
    628628                                              VERR_LDRMACHO_BAD_LOAD_COMMAND); \
    629                     KLDRMODMACHO_CHECK_RETURN(   uEffFileType != MH_OBJECT \
     629                    RTLDRMODMACHO_CHECK_RETURN(   uEffFileType != MH_OBJECT \
    630630                                              || cSegmentCommands == 0 \
    631631                                              || (   cSegmentCommands == 1 \
    … …  
    675675                        /* validate */ \
    676676                        if (uEffFileType != MH_OBJECT) \
    677                             KLDRMODMACHO_CHECK_RETURN(!strcmp(pSect->segname, pSrcSeg->segname),\
     677                            RTLDRMODMACHO_CHECK_RETURN(!strcmp(pSect->segname, pSrcSeg->segname),\
    678678                                                      VERR_LDRMACHO_BAD_SECTION); \
    679679                        \
    … …  
    681681                        { \
    682682                            case S_ZEROFILL: \
    683                                 KLDRMODMACHO_CHECK_RETURN(!pSect->reserved1, VERR_LDRMACHO_BAD_SECTION); \
    684                                 KLDRMODMACHO_CHECK_RETURN(!pSect->reserved2, VERR_LDRMACHO_BAD_SECTION); \
     683                                RTLDRMODMACHO_CHECK_RETURN(!pSect->reserved1, VERR_LDRMACHO_BAD_SECTION); \
     684                                RTLDRMODMACHO_CHECK_RETURN(!pSect->reserved2, VERR_LDRMACHO_BAD_SECTION); \
    685685                                fFileBits = 0; \
    686686                                break; \
    … …  
    691691                            case S_8BYTE_LITERALS: \
    692692                            case S_16BYTE_LITERALS: \
    693                                 KLDRMODMACHO_CHECK_RETURN(!pSect->reserved1, VERR_LDRMACHO_BAD_SECTION); \
    694                                 KLDRMODMACHO_CHECK_RETURN(!pSect->reserved2, VERR_LDRMACHO_BAD_SECTION); \
     693                                RTLDRMODMACHO_CHECK_RETURN(!pSect->reserved1, VERR_LDRMACHO_BAD_SECTION); \
     694                                RTLDRMODMACHO_CHECK_RETURN(!pSect->reserved2, VERR_LDRMACHO_BAD_SECTION); \
    695695                                fFileBits = 1; \
    696696                                break; \
    697697                            \
    698698                            case S_SYMBOL_STUBS: \
    699                                 KLDRMODMACHO_CHECK_RETURN(!pSect->reserved1, VERR_LDRMACHO_BAD_SECTION); \
     699                                RTLDRMODMACHO_CHECK_RETURN(!pSect->reserved1, VERR_LDRMACHO_BAD_SECTION); \
    700700                                /* reserved2 == stub size. 0 has been seen (corecrypto.kext) */ \
    701                                 KLDRMODMACHO_CHECK_RETURN(pSect->reserved2 < 64, VERR_LDRMACHO_BAD_SECTION); \
     701                                RTLDRMODMACHO_CHECK_RETURN(pSect->reserved2 < 64, VERR_LDRMACHO_BAD_SECTION); \
    702702                                fFileBits = 1; \
    703703                                break; \
    … …  
    707707                            case S_LAZY_DYLIB_SYMBOL_POINTERS: \
    708708                                /* (reserved 1 = is indirect symbol table index) */ \
    709                                 KLDRMODMACHO_CHECK_RETURN(!pSect->reserved2, VERR_LDRMACHO_BAD_SECTION); \
     709                                RTLDRMODMACHO_CHECK_RETURN(!pSect->reserved2, VERR_LDRMACHO_BAD_SECTION); \
    710710                                *pfCanLoad = false; \
    711711                                fFileBits = -1; /* __DATA.__got in the 64-bit mach_kernel has bits, any things without bits? */ \
    … …  
    714714                            case S_MOD_INIT_FUNC_POINTERS: \
    715715                                /** @todo this requires a query API or flag... (e.g. C++ constructors) */ \
    716                                 KLDRMODMACHO_CHECK_RETURN(fOpenFlags & RTLDR_O_FOR_DEBUG, \
     716                                RTLDRMODMACHO_CHECK_RETURN(fOpenFlags & RTLDR_O_FOR_DEBUG, \
    717717                                                          VERR_LDRMACHO_UNSUPPORTED_INIT_SECTION); \
    718718                                /* Falls through. */ \
    719719                            case S_MOD_TERM_FUNC_POINTERS: \
    720720                                /** @todo this requires a query API or flag... (e.g. C++ destructors) */ \
    721                                 KLDRMODMACHO_CHECK_RETURN(fOpenFlags & RTLDR_O_FOR_DEBUG, \
     721                                RTLDRMODMACHO_CHECK_RETURN(fOpenFlags & RTLDR_O_FOR_DEBUG, \
    722722                                                          VERR_LDRMACHO_UNSUPPORTED_TERM_SECTION); \
    723                                 KLDRMODMACHO_CHECK_RETURN(!pSect->reserved1, VERR_LDRMACHO_BAD_SECTION); \
    724                                 KLDRMODMACHO_CHECK_RETURN(!pSect->reserved2, VERR_LDRMACHO_BAD_SECTION); \
     723                                RTLDRMODMACHO_CHECK_RETURN(!pSect->reserved1, VERR_LDRMACHO_BAD_SECTION); \
     724                                RTLDRMODMACHO_CHECK_RETURN(!pSect->reserved2, VERR_LDRMACHO_BAD_SECTION); \
    725725                                fFileBits = 1; \
    726726                                break; /* ignored */ \
    … …  
    728728                            case S_LITERAL_POINTERS: \
    729729                            case S_DTRACE_DOF: \
    730                                 KLDRMODMACHO_CHECK_RETURN(!pSect->reserved1, VERR_LDRMACHO_BAD_SECTION); \
    731                                 KLDRMODMACHO_CHECK_RETURN(!pSect->reserved2, VERR_LDRMACHO_BAD_SECTION); \
     730                                RTLDRMODMACHO_CHECK_RETURN(!pSect->reserved1, VERR_LDRMACHO_BAD_SECTION); \
     731                                RTLDRMODMACHO_CHECK_RETURN(!pSect->reserved2, VERR_LDRMACHO_BAD_SECTION); \
    732732                                fFileBits = 1; \
    733733                                break; \
    … …  
    735735                            case S_INTERPOSING: \
    736736                            case S_GB_ZEROFILL: \
    737                                 KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_UNSUPPORTED_SECTION); \
     737                                RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_UNSUPPORTED_SECTION); \
    738738                            \
    739739                            default: \
    740                                 KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_UNKNOWN_SECTION); \
     740                                RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_UNKNOWN_SECTION); \
    741741                        } \
    742                         KLDRMODMACHO_CHECK_RETURN(!(pSect->flags & ~(  S_ATTR_PURE_INSTRUCTIONS | S_ATTR_NO_TOC | S_ATTR_STRIP_STATIC_SYMS \
     742                        RTLDRMODMACHO_CHECK_RETURN(!(pSect->flags & ~(  S_ATTR_PURE_INSTRUCTIONS | S_ATTR_NO_TOC | S_ATTR_STRIP_STATIC_SYMS \
    743743                                                                     | S_ATTR_NO_DEAD_STRIP | S_ATTR_LIVE_SUPPORT | S_ATTR_SELF_MODIFYING_CODE \
    744744                                                                     | S_ATTR_DEBUG | S_ATTR_SOME_INSTRUCTIONS | S_ATTR_EXT_RELOC \
    745745                                                                     | S_ATTR_LOC_RELOC | SECTION_TYPE)), \
    746746                                                  VERR_LDRMACHO_BAD_SECTION); \
    747                         KLDRMODMACHO_CHECK_RETURN((pSect->flags & S_ATTR_DEBUG) == (pFirstSect->flags & S_ATTR_DEBUG), \
     747                        RTLDRMODMACHO_CHECK_RETURN((pSect->flags & S_ATTR_DEBUG) == (pFirstSect->flags & S_ATTR_DEBUG), \
    748748                                                  VERR_LDRMACHO_MIXED_DEBUG_SECTION_FLAGS); \
    749749                        \
    750                         KLDRMODMACHO_CHECK_RETURN(pSect->addr - pSrcSeg->vmaddr <= pSrcSeg->vmsize, \
     750                        RTLDRMODMACHO_CHECK_RETURN(pSect->addr - pSrcSeg->vmaddr <= pSrcSeg->vmsize, \
    751751                                                  VERR_LDRMACHO_BAD_SECTION); \
    752                         KLDRMODMACHO_CHECK_RETURN(   pSect->addr - pSrcSeg->vmaddr + pSect->size <= pSrcSeg->vmsize \
     752                        RTLDRMODMACHO_CHECK_RETURN(   pSect->addr - pSrcSeg->vmaddr + pSect->size <= pSrcSeg->vmsize \
    753753                                                  || !strcmp(pSrcSeg->segname, "__CTF") /* see above */, \
    754754                                                  VERR_LDRMACHO_BAD_SECTION); \
    755                         KLDRMODMACHO_CHECK_RETURN(pSect->align < 31, \
     755                        RTLDRMODMACHO_CHECK_RETURN(pSect->align < 31, \
    756756                                                  VERR_LDRMACHO_BAD_SECTION); \
    757757                        /* Workaround for buggy ld64 (or as, llvm, ++) that produces a misaligned __TEXT.__unwind_info. */ \
    … …  
    761761                            && strcmp(pSect->sectname, "__unwind_info") == 0) \
    762762                            pSect->align = 2; \
    763                         KLDRMODMACHO_CHECK_RETURN(!((RT_BIT_32(pSect->align) - UINT32_C(1)) & pSect->addr), \
     763                        RTLDRMODMACHO_CHECK_RETURN(!((RT_BIT_32(pSect->align) - UINT32_C(1)) & pSect->addr), \
    764764                                                  VERR_LDRMACHO_BAD_SECTION); \
    765                         KLDRMODMACHO_CHECK_RETURN(!((RT_BIT_32(pSect->align) - UINT32_C(1)) & pSrcSeg->vmaddr), \
     765                        RTLDRMODMACHO_CHECK_RETURN(!((RT_BIT_32(pSect->align) - UINT32_C(1)) & pSrcSeg->vmaddr), \
    766766                                                  VERR_LDRMACHO_BAD_SECTION); \
    767767                        \
    … …  
    770770                        if (pSect->addr) \
    771771                        { \
    772                             KLDRMODMACHO_CHECK_RETURN(offSect <= pSect->addr - pSrcSeg->vmaddr, VERR_LDRMACHO_BAD_SECTION); \
     772                            RTLDRMODMACHO_CHECK_RETURN(offSect <= pSect->addr - pSrcSeg->vmaddr, VERR_LDRMACHO_BAD_SECTION); \
    773773                            if (offSect < pSect->addr - pSrcSeg->vmaddr) \
    774774                                offSect = pSect->addr - pSrcSeg->vmaddr; \
    … …  
    781781                            if (uEffFileType != MH_OBJECT) \
    782782                            { \
    783                                 KLDRMODMACHO_CHECK_RETURN(pSect->offset == pSrcSeg->fileoff + offSect, \
     783                                RTLDRMODMACHO_CHECK_RETURN(pSect->offset == pSrcSeg->fileoff + offSect, \
    784784                                                          VERR_LDRMACHO_NON_CONT_SEG_BITS); \
    785                                 KLDRMODMACHO_CHECK_RETURN(pSect->offset - pSrcSeg->fileoff <= pSrcSeg->filesize, \
     785                                RTLDRMODMACHO_CHECK_RETURN(pSect->offset - pSrcSeg->fileoff <= pSrcSeg->filesize, \
    786786                                                          VERR_LDRMACHO_BAD_SECTION); \
    787787                            } \
    788                             KLDRMODMACHO_CHECK_RETURN(pSect->offset <= cbFile, \
     788                            RTLDRMODMACHO_CHECK_RETURN(pSect->offset <= cbFile, \
    789789                                                      VERR_LDRMACHO_BAD_SECTION); \
    790                             KLDRMODMACHO_CHECK_RETURN((uint64_t)pSect->offset + pSect->size <= cbFile, \
     790                            RTLDRMODMACHO_CHECK_RETURN((uint64_t)pSect->offset + pSect->size <= cbFile, \
    791791                                                      VERR_LDRMACHO_BAD_SECTION); \
    792792                        } \
    793793                        else \
    794                             KLDRMODMACHO_CHECK_RETURN(pSect->offset == 0, VERR_LDRMACHO_BAD_SECTION); \
     794                            RTLDRMODMACHO_CHECK_RETURN(pSect->offset == 0, VERR_LDRMACHO_BAD_SECTION); \
    795795                        \
    796796                        if (!pSect->nreloc) \
    797                             KLDRMODMACHO_CHECK_RETURN(!pSect->reloff, \
     797                            RTLDRMODMACHO_CHECK_RETURN(!pSect->reloff, \
    798798                                                      VERR_LDRMACHO_BAD_SECTION); \
    799799                        else \
    800800                        { \
    801                             KLDRMODMACHO_CHECK_RETURN(pSect->reloff <= cbFile, \
     801                            RTLDRMODMACHO_CHECK_RETURN(pSect->reloff <= cbFile, \
    802802                                                      VERR_LDRMACHO_BAD_SECTION); \
    803                             KLDRMODMACHO_CHECK_RETURN(     (uint64_t)pSect->reloff \
     803                            RTLDRMODMACHO_CHECK_RETURN(     (uint64_t)pSect->reloff \
    804804                                                         + (RTFOFF)pSect->nreloc * sizeof(macho_relocation_info_t) \
    805805                                                      <= cbFile, \
    … …  
    829829                                break; \
    830830                            default: \
    831                                 KLDRMODMACHO_FAILED_RETURN(VERR_INVALID_PARAMETER); \
     831                                RTLDRMODMACHO_FAILED_RETURN(VERR_INVALID_PARAMETER); \
    832832                        } \
    833833                        \
    … …  
    853853
    854854                /* Convert and verify the segment. */
    855                 KLDRMODMACHO_CHECK_RETURN(u.pLoadCmd->cmdsize >= sizeof(segment_command_64_t), VERR_LDRMACHO_BAD_LOAD_COMMAND);
    856                 KLDRMODMACHO_CHECK_RETURN(   pHdr->magic == IMAGE_MACHO64_SIGNATURE_OE
     855                RTLDRMODMACHO_CHECK_RETURN(u.pLoadCmd->cmdsize >= sizeof(segment_command_64_t), VERR_LDRMACHO_BAD_LOAD_COMMAND);
     856                RTLDRMODMACHO_CHECK_RETURN(   pHdr->magic == IMAGE_MACHO64_SIGNATURE_OE
    857857                                          || pHdr->magic == IMAGE_MACHO64_SIGNATURE, VERR_LDRMACHO_BIT_MIX);
    858858                if (fConvertEndian)
    … …  
    915915                if (    u.pSymTab->symoff >= cbFile
    916916                    ||  (uint64_t)u.pSymTab->symoff + u.pSymTab->nsyms * cbSym > cbFile)
    917                     KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND);
     917                    RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND);
    918918                if (    u.pSymTab->stroff >= cbFile
    919919                    ||  (uint64_t)u.pSymTab->stroff + u.pSymTab->strsize > cbFile)
    920                     KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND);
     920                    RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND);
    921921
    922922                /* only one string in objects, please. */
    … …  
    924924                if (    uEffFileType == MH_OBJECT
    925925                    &&  cSymbolTabs != 1)
    926                     KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_OBJECT_FILE);
     926                    RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_OBJECT_FILE);
    927927                break;
    928928            }
    … …  
    941941                    /* convert & verify header items ([0] == flavor, [1] == uint32_t count). */
    942942                    if (cItemsLeft < 2)
    943                         KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND);
     943                        RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND);
    944944                    if (fConvertEndian)
    945945                    {
    … …  
    948948                    }
    949949                    if (pu32[1] + 2 > cItemsLeft)
    950                         KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND);
     950                        RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND);
    951951
    952952                    /* convert & verify according to flavor. */
    … …  
    967967            case LC_UUID:
    968968                if (u.pUuid->cmdsize != sizeof(uuid_command_t))
    969                     KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND);
     969                    RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND);
    970970                /** @todo Check anything here need converting? */
    971971                break;
    … …  
    973973            case LC_CODE_SIGNATURE:
    974974                if (u.pUuid->cmdsize != sizeof(linkedit_data_command_t))
    975                     KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND);
     975                    RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND);
    976976                break;
    977977
    … …  
    979979            case LC_VERSION_MIN_IPHONEOS:
    980980                if (u.pUuid->cmdsize != sizeof(version_min_command_t))
    981                     KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND);
     981                    RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND);
    982982                break;
    983983
    … …  
    10071007                /** @todo valid command size. */
    10081008                if (!(fOpenFlags & RTLDR_O_FOR_DEBUG))
    1009                     KLDRMODMACHO_FAILED_RETURN(RTErrInfoSetF(pErrInfo, VERR_LDRMACHO_UNSUPPORTED_LOAD_COMMAND,
     1009                    RTLDRMODMACHO_FAILED_RETURN(RTErrInfoSetF(pErrInfo, VERR_LDRMACHO_UNSUPPORTED_LOAD_COMMAND,
    10101010                                                             "cmd=%#x", u.pLoadCmd->cmd));
    10111011                *pfCanLoad = false;
    … …  
    10261026            case LC_PREBIND_CKSUM:
    10271027            case LC_SYMSEG:
    1028                 KLDRMODMACHO_FAILED_RETURN(RTErrInfoSetF(pErrInfo, VERR_LDRMACHO_UNSUPPORTED_LOAD_COMMAND,
     1028                RTLDRMODMACHO_FAILED_RETURN(RTErrInfoSetF(pErrInfo, VERR_LDRMACHO_UNSUPPORTED_LOAD_COMMAND,
    10291029                                                         "cmd=%#x", u.pLoadCmd->cmd));
    10301030
    10311031            default:
    1032                 KLDRMODMACHO_FAILED_RETURN(RTErrInfoSetF(pErrInfo, VERR_LDRMACHO_UNKNOWN_LOAD_COMMAND,
     1032                RTLDRMODMACHO_FAILED_RETURN(RTErrInfoSetF(pErrInfo, VERR_LDRMACHO_UNKNOWN_LOAD_COMMAND,
    10331033                                                         "cmd=%#x", u.pLoadCmd->cmd));
    10341034        }
    … …  
    10371037    /* be strict. */
    10381038    if (cbLeft)
    1039         KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND);
     1039        RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_LOAD_COMMAND);
    10401040
    10411041    switch (uEffFileType)
    … …  
    10481048        case MH_KEXT_BUNDLE:
    10491049            if (!cSegments)
    1050                 KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_OBJECT_FILE);
     1050                RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_OBJECT_FILE);
    10511051            break;
    10521052    }
    … …  
    10701070 * @param   cbStringPool    The size of the string pool.
    10711071 */
    1072 static int  kldrModMachOParseLoadCommands(PKLDRMODMACHO pThis, char *pbStringPool, uint32_t cbStringPool)
     1072static int  kldrModMachOParseLoadCommands(PRTLDRMODMACHO pThis, char *pbStringPool, uint32_t cbStringPool)
    10731073{
    10741074    union
    … …  
    10841084    uint32_t cbLeft = pThis->Hdr.sizeofcmds;
    10851085    const uint8_t *pb = pThis->pbLoadCommands;
    1086     PKLDRMODMACHOSEG pDstSeg = &pThis->aSegments[0];
    1087     PKLDRMODMACHOSECT pSectExtra = pThis->paSections;
     1086    PRTLDRMODMACHOSEG pDstSeg = &pThis->aSegments[0];
     1087    PRTLDRMODMACHOSECT pSectExtra = pThis->paSections;
    10881088    const uint32_t cSegments = pThis->cSegments;
    1089     PKLDRMODMACHOSEG pSegItr;
     1089    PRTLDRMODMACHOSEG pSegItr;
    10901090    RT_NOREF(cbStringPool);
    10911091
    … …  
    11691169                        for (pSegItr = &pThis->aSegments[0]; pSegItr != pDstSeg; pSegItr++) \
    11701170                            if (!strncmp(pSegItr->SegInfo.pszName, pSrcSeg->segname, sizeof(pSrcSeg->segname))) \
    1171                                 KLDRMODMACHO_FAILED_RETURN(VERR_LDR_DUPLICATE_SEGMENT_NAME); \
     1171                                RTLDRMODMACHO_FAILED_RETURN(VERR_LDR_DUPLICATE_SEGMENT_NAME); \
    11721172                    \
    11731173                    /* \
    … …  
    12871287    {
    12881288        bool                fLoadLinkEdit = false;
    1289         PKLDRMODMACHOSECT   pSectExtraItr;
     1289        PRTLDRMODMACHOSECT  pSectExtraItr;
    12901290        RTLDRADDR           uNextRVA = 0;
    12911291        RTLDRADDR           cb;
    … …  
    13251325        for (pDstSeg = &pThis->aSegments[0]; c-- > 0; pDstSeg++)
    13261326        {
     1327            uNextRVA = RTLDR_ALIGN_ADDR(uNextRVA, pDstSeg->SegInfo.Alignment);
    13271328            cb = pDstSeg->SegInfo.RVA - uNextRVA;
    13281329            if (cb >= 0x00100000) /* 1MB */
    … …  
    13311332                //pThis->pMod->fFlags |= KLDRMOD_FLAGS_NON_CONTIGUOUS_LINK_ADDRS;
    13321333            }
    1333             uNextRVA = pDstSeg->SegInfo.RVA + RTLDR_ALIGN_ADDR(pDstSeg->SegInfo.cb, pDstSeg->SegInfo.Alignment);
     1334            uNextRVA = pDstSeg->SegInfo.RVA + pDstSeg->SegInfo.cb;
    13341335        }
    13351336
    … …  
    14221423static DECLCALLBACK(int) rtldrMachO_Close(PRTLDRMODINTERNAL pMod)
    14231424{
    1424     PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core);
    1425     KLDRMODMACHO_ASSERT(!pThis->pvMapping);
     1425    PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core);
     1426    RTLDRMODMACHO_ASSERT(!pThis->pvMapping);
    14261427
    14271428    uint32_t i = pThis->cSegments;
    … …  
    14531454 * @param   pBaseAddress    The base address, IN & OUT. Optional.
    14541455 */
    1455 static void kldrModMachOAdjustBaseAddress(PKLDRMODMACHO pThis, PRTLDRADDR pBaseAddress)
     1456static void kldrModMachOAdjustBaseAddress(PRTLDRMODMACHO pThis, PRTLDRADDR pBaseAddress)
    14561457{
    14571458    /*
    … …  
    14771478 * @param   puValue             Where to return the symbol value.
    14781479 */
    1479 static int kldrModMachOQueryLinkerSymbol(PKLDRMODMACHO pThis, const char *pchSymbol, size_t cchSymbol,
     1480static int kldrModMachOQueryLinkerSymbol(PRTLDRMODMACHO pThis, const char *pchSymbol, size_t cchSymbol,
    14801481                                         RTLDRADDR BaseAddress, PRTLDRADDR puValue)
    14811482{
    … …  
    16141615                                                uint32_t iOrdinal, const char *pszSymbol, RTUINTPTR *pValue)
    16151616{
    1616     PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core);
     1617    PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core);
    16171618    RT_NOREF(pvBits);
    16181619    //RT_NOREF(pszVersion);
    … …  
    16311632     * Refuse segmented requests for now.
    16321633     */
    1633     KLDRMODMACHO_CHECK_RETURN(   !pfKind
     1634    RTLDRMODMACHO_CHECK_RETURN(   !pfKind
    16341635                              || (*pfKind & RTLDRSYMKIND_REQ_TYPE_MASK) == RTLDRSYMKIND_REQ_FLAT,
    16351636                              VERR_LDRMACHO_TODO);
    … …  
    17011702 * @param   pfKind      See kLdrModQuerySymbol.
    17021703 */
    1703 static int kldrModMachODoQuerySymbol32Bit(PKLDRMODMACHO pThis, const macho_nlist_32_t *paSyms, uint32_t cSyms,
     1704static int kldrModMachODoQuerySymbol32Bit(PRTLDRMODMACHO pThis, const macho_nlist_32_t *paSyms, uint32_t cSyms,
    17041705                                          const char *pchStrings, uint32_t cchStrings, RTLDRADDR BaseAddress, uint32_t iSymbol,
    17051706                                          const char *pchSymbol, uint32_t cchSymbol, PRTLDRADDR puValue, uint32_t *pfKind)
    … …  
    17751776        case MACHO_N_SECT:
    17761777        {
    1777             PKLDRMODMACHOSECT pSect;
     1778            PRTLDRMODMACHOSECT pSect;
    17781779            RTLDRADDR offSect;
    1779             KLDRMODMACHO_CHECK_RETURN((uint32_t)(paSyms[iSymbol].n_sect - 1) < pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL);
     1780            RTLDRMODMACHO_CHECK_RETURN((uint32_t)(paSyms[iSymbol].n_sect - 1) < pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL);
    17801781            pSect = &pThis->paSections[paSyms[iSymbol].n_sect - 1];
    17811782
    17821783            offSect = paSyms[iSymbol].n_value - pSect->LinkAddress;
    1783             KLDRMODMACHO_CHECK_RETURN(   offSect <= pSect->cb
     1784            RTLDRMODMACHO_CHECK_RETURN(   offSect <= pSect->cb
    17841785                                      || (   paSyms[iSymbol].n_sect == 1 /* special hack for __mh_execute_header */
    17851786                                          && offSect == 0U - pSect->RVA
    … …  
    18061807            /** @todo implement indirect and prebound symbols. */
    18071808        default:
    1808             KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO);
     1809            RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO);
    18091810    }
    18101811
    … …  
    18291830 * @param   pfKind      See kLdrModQuerySymbol.
    18301831 */
    1831 static int kldrModMachODoQuerySymbol64Bit(PKLDRMODMACHO pThis, const macho_nlist_64_t *paSyms, uint32_t cSyms,
     1832static int kldrModMachODoQuerySymbol64Bit(PRTLDRMODMACHO pThis, const macho_nlist_64_t *paSyms, uint32_t cSyms,
    18321833                                          const char *pchStrings, uint32_t cchStrings, RTLDRADDR BaseAddress, uint32_t iSymbol,
    18331834                                          const char *pchSymbol, uint32_t cchSymbol, PRTLDRADDR puValue, uint32_t *pfKind)
    … …  
    19031904        case MACHO_N_SECT:
    19041905        {
    1905             PKLDRMODMACHOSECT pSect;
     1906            PRTLDRMODMACHOSECT pSect;
    19061907            RTLDRADDR offSect;
    1907             KLDRMODMACHO_CHECK_RETURN((uint32_t)(paSyms[iSymbol].n_sect - 1) < pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL);
     1908            RTLDRMODMACHO_CHECK_RETURN((uint32_t)(paSyms[iSymbol].n_sect - 1) < pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL);
    19081909            pSect = &pThis->paSections[paSyms[iSymbol].n_sect - 1];
    19091910
    19101911            offSect = paSyms[iSymbol].n_value - pSect->LinkAddress;
    1911             KLDRMODMACHO_CHECK_RETURN(   offSect <= pSect->cb
     1912            RTLDRMODMACHO_CHECK_RETURN(   offSect <= pSect->cb
    19121913                                      || (   paSyms[iSymbol].n_sect == 1 /* special hack for __mh_execute_header */
    19131914                                          && offSect == 0U - pSect->RVA
    … …  
    19341935            /** @todo implement indirect and prebound symbols. */
    19351936        default:
    1936             KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO);
     1937            RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO);
    19371938    }
    19381939
    … …  
    19471948                                                RTUINTPTR BaseAddress, PFNRTLDRENUMSYMS pfnCallback, void *pvUser)
    19481949{
    1949     PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core);
     1950    PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core);
    19501951    RT_NOREF(pvBits);
    19511952
    … …  
    19811982    }
    19821983    else
    1983         KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO);
     1984        RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO);
    19841985
    19851986    return rc;
    … …  
    20012002 * @param   pvUser      See kLdrModEnumSymbols.
    20022003 */
    2003 static int kldrModMachODoEnumSymbols32Bit(PKLDRMODMACHO pThis, const macho_nlist_32_t *paSyms, uint32_t cSyms,
     2004static int kldrModMachODoEnumSymbols32Bit(PRTLDRMODMACHO pThis, const macho_nlist_32_t *paSyms, uint32_t cSyms,
    20042005                                          const char *pchStrings, uint32_t cchStrings, RTLDRADDR BaseAddress,
    20052006                                          uint32_t fFlags, PFNRTLDRENUMSYMS pfnCallback, void *pvUser)
    … …  
    20432044
    20442045        /* name */
    2045         KLDRMODMACHO_CHECK_RETURN((uint32_t)paSyms[iSym].n_un.n_strx < cchStrings, VERR_LDRMACHO_BAD_SYMBOL);
     2046        RTLDRMODMACHO_CHECK_RETURN((uint32_t)paSyms[iSym].n_un.n_strx < cchStrings, VERR_LDRMACHO_BAD_SYMBOL);
    20462047        psz = &pchStrings[paSyms[iSym].n_un.n_strx];
    20472048        cch = strlen(psz);
    … …  
    20572058            case MACHO_N_SECT:
    20582059            {
    2059                 PKLDRMODMACHOSECT pSect;
    2060                 KLDRMODMACHO_CHECK_RETURN((uint32_t)(paSyms[iSym].n_sect - 1) < pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL);
     2060                PRTLDRMODMACHOSECT pSect;
     2061                RTLDRMODMACHO_CHECK_RETURN((uint32_t)(paSyms[iSym].n_sect - 1) < pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL);
    20612062                pSect = &pThis->paSections[paSyms[iSym].n_sect - 1];
    20622063
    20632064                uValue = paSyms[iSym].n_value - pSect->LinkAddress;
    2064                 KLDRMODMACHO_CHECK_RETURN(   uValue <= pSect->cb
     2065                RTLDRMODMACHO_CHECK_RETURN(   uValue <= pSect->cb
    20652066                                          || (   paSyms[iSym].n_sect == 1 /* special hack for __mh_execute_header */
    20662067                                              && uValue == 0U - pSect->RVA
    … …  
    20852086                /** @todo implement indirect and prebound symbols. */
    20862087            default:
    2087                 KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO);
     2088                RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO);
    20882089        }
    20892090
    … …  
    21132114 * @param   pvUser      See kLdrModEnumSymbols.
    21142115 */
    2115 static int kldrModMachODoEnumSymbols64Bit(PKLDRMODMACHO pThis, const macho_nlist_64_t *paSyms, uint32_t cSyms,
     2116static int kldrModMachODoEnumSymbols64Bit(PRTLDRMODMACHO pThis, const macho_nlist_64_t *paSyms, uint32_t cSyms,
    21162117                                          const char *pchStrings, uint32_t cchStrings, RTLDRADDR BaseAddress,
    21172118                                          uint32_t fFlags, PFNRTLDRENUMSYMS pfnCallback, void *pvUser)
    … …  
    21552156
    21562157        /* name */
    2157         KLDRMODMACHO_CHECK_RETURN((uint32_t)paSyms[iSym].n_un.n_strx < cchStrings, VERR_LDRMACHO_BAD_SYMBOL);
     2158        RTLDRMODMACHO_CHECK_RETURN((uint32_t)paSyms[iSym].n_un.n_strx < cchStrings, VERR_LDRMACHO_BAD_SYMBOL);
    21582159        psz = &pchStrings[paSyms[iSym].n_un.n_strx];
    21592160        cch = strlen(psz);
    … …  
    21692170            case MACHO_N_SECT:
    21702171            {
    2171                 PKLDRMODMACHOSECT pSect;
    2172                 KLDRMODMACHO_CHECK_RETURN((uint32_t)(paSyms[iSym].n_sect - 1) < pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL);
     2172                PRTLDRMODMACHOSECT pSect;
     2173                RTLDRMODMACHO_CHECK_RETURN((uint32_t)(paSyms[iSym].n_sect - 1) < pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL);
    21732174                pSect = &pThis->paSections[paSyms[iSym].n_sect - 1];
    21742175
    21752176                uValue = paSyms[iSym].n_value - pSect->LinkAddress;
    2176                 KLDRMODMACHO_CHECK_RETURN(   uValue <= pSect->cb
     2177                RTLDRMODMACHO_CHECK_RETURN(   uValue <= pSect->cb
    21772178                                          || (   paSyms[iSym].n_sect == 1 /* special hack for __mh_execute_header */
    21782179                                              && uValue == 0U - pSect->RVA
    … …  
    21972198                /** @todo implement indirect and prebound symbols. */
    21982199            default:
    2199                 KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO);
     2200                RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO);
    22002201        }
    22012202
    … …  
    22152216static int kldrModMachOGetImport(PRTLDRMODINTERNAL pMod, const void *pvBits, uint32_t iImport, char *pszName, size_t cchName)
    22162217{
    2217     PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core);
     2218    PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core);
    22182219    RT_NOREF(pvBits);
    22192220    RT_NOREF(iImport);
    … …  
    22332234static int32_t kldrModMachONumberOfImports(PRTLDRMODINTERNAL pMod, const void *pvBits)
    22342235{
    2235     PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core);
     2236    PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core);
    22362237    RT_NOREF(pvBits);
    22372238
    … …  
    22472248static int kldrModMachOGetStackInfo(PRTLDRMODINTERNAL pMod, const void *pvBits, RTLDRADDR BaseAddress, PKLDRSTACKINFO pStackInfo)
    22482249{
    2249     /*PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core);*/
     2250    /*PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core);*/
    22502251    RT_NOREF(pMod);
    22512252    RT_NOREF(pvBits);
    … …  
    22652266{
    22662267#if 0
    2267     PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core);
     2268    PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core);
    22682269    int rc;
    22692270
    … …  
    22982299static DECLCALLBACK(int) rtldrMachO_EnumDbgInfo(PRTLDRMODINTERNAL pMod, const void *pvBits, PFNRTLDRENUMDBG pfnCallback, void *pvUser)
    22992300{
    2300     PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core);
     2301    PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core);
    23012302    int rc = VINF_SUCCESS;
    23022303    uint32_t iSect;
    … …  
    23352336static int kldrModMachOHasDbgInfo(PRTLDRMODINTERNAL pMod, const void *pvBits)
    23362337{
    2337     /*PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core);*/
     2338    /*PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core);*/
    23382339
    23392340#if 0
    … …  
    23572358static int kldrModMachOMap(PRTLDRMODINTERNAL pMod)
    23582359{
    2359     PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core);
     2360    PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core);
    23602361    unsigned fFixed;
    23612362    uint32_t i;
    … …  
    24092410static int kldrModMachOUnmap(PRTLDRMODINTERNAL pMod)
    24102411{
    2411     PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core);
     2412    PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core);
    24122413    uint32_t i;
    24132414    int rc;
    … …  
    24402441static int kldrModMachOAllocTLS(PRTLDRMODINTERNAL pMod, void *pvMapping)
    24412442{
    2442     PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core);
     2443    PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core);
    24432444
    24442445    /*
    … …  
    24642465static int kldrModMachOReload(PRTLDRMODINTERNAL pMod)
    24652466{
    2466     PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core);
     2467    PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core);
    24672468
    24682469    /*
    … …  
    24802481static int kldrModMachOFixupMapping(PRTLDRMODINTERNAL pMod, PFNRTLDRIMPORT pfnGetImport, void *pvUser)
    24812482{
    2482     PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core);
     2483    PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core);
    24832484    int rc, rc2;
    24842485
    … …  
    25222523 * @param   pvUser          User argument to the callback.
    25232524 */
    2524 static int  kldrModMachOObjDoImports(PKLDRMODMACHO pThis, RTLDRADDR BaseAddress, PFNRTLDRIMPORT pfnGetImport, void *pvUser)
     2525static int  kldrModMachOObjDoImports(PRTLDRMODMACHO pThis, RTLDRADDR BaseAddress, PFNRTLDRIMPORT pfnGetImport, void *pvUser)
    25252526{
    25262527    const uint32_t cSyms = pThis->cSymbols;
    … …  
    25562557
    25572558                /** @todo Implement N_REF_TO_WEAK. */
    2558                 KLDRMODMACHO_CHECK_RETURN(!(paSyms[iSym].n_desc & N_REF_TO_WEAK), VERR_LDRMACHO_TODO);
     2559                RTLDRMODMACHO_CHECK_RETURN(!(paSyms[iSym].n_desc & N_REF_TO_WEAK), VERR_LDRMACHO_TODO);
    25592560
    25602561                /* Get the symbol name. */
    2561                 KLDRMODMACHO_CHECK_RETURN((uint32_t)paSyms[iSym].n_un.n_strx < pThis->cchStrings, VERR_LDRMACHO_BAD_SYMBOL);
     2562                RTLDRMODMACHO_CHECK_RETURN((uint32_t)paSyms[iSym].n_un.n_strx < pThis->cchStrings, VERR_LDRMACHO_BAD_SYMBOL);
    25622563                pszSymbol = &pThis->pchStrings[paSyms[iSym].n_un.n_strx];
    25632564                cchSymbol = strlen(pszSymbol);
    … …  
    26152616
    26162617                /** @todo Implement N_REF_TO_WEAK. */
    2617                 KLDRMODMACHO_CHECK_RETURN(!(paSyms[iSym].n_desc & N_REF_TO_WEAK), VERR_LDRMACHO_TODO);
     2618                RTLDRMODMACHO_CHECK_RETURN(!(paSyms[iSym].n_desc & N_REF_TO_WEAK), VERR_LDRMACHO_TODO);
    26182619
    26192620                 /* Get the symbol name. */
    2620                 KLDRMODMACHO_CHECK_RETURN(paSyms[iSym].n_un.n_strx < pThis->cchStrings, VERR_LDRMACHO_BAD_SYMBOL);
     2621                RTLDRMODMACHO_CHECK_RETURN(paSyms[iSym].n_un.n_strx < pThis->cchStrings, VERR_LDRMACHO_BAD_SYMBOL);
    26212622                pszSymbol = &pThis->pchStrings[paSyms[iSym].n_un.n_strx];
    26222623                cchSymbol = strlen(pszSymbol);
    … …  
    26692670 * @param   NewBaseAddress  The address to fixup the mapping to.
    26702671 */
    2671 static int  kldrModMachOObjDoFixups(PKLDRMODMACHO pThis, void *pvMapping, RTLDRADDR NewBaseAddress)
     2672static int  kldrModMachOObjDoFixups(PRTLDRMODMACHO pThis, void *pvMapping, RTLDRADDR NewBaseAddress)
    26722673{
    26732674    /*
    … …  
    26842685    for (uint32_t iSeg = 0; RT_SUCCESS(rc) && iSeg < pThis->cSegments; iSeg++)
    26852686    {
    2686         PKLDRMODMACHOSEG pSeg = &pThis->aSegments[iSeg];
     2687        PRTLDRMODMACHOSEG pSeg = &pThis->aSegments[iSeg];
    26872688        for (uint32_t iSect = 0; iSect < pSeg->cSections; iSect++)
    26882689        {
    2689             PKLDRMODMACHOSECT pSect = &pSeg->paSections[iSect];
     2690            PRTLDRMODMACHOSECT pSect = &pSeg->paSections[iSect];
    26902691
    26912692            /* skip sections without fixups. */
    … …  
    27152716                                                   pThis->cSymbols, NewBaseAddress);
    27162717            else
    2717                 KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO);
     2718                RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO);
    27182719            if (RT_FAILURE(rc))
    27192720                break;
    … …  
    27372738 * @param   NewBaseAddress  The new base image address.
    27382739 */
    2739 static int  kldrModMachOFixupSectionGeneric32Bit(PKLDRMODMACHO pThis, uint8_t *pbSectBits, PKLDRMODMACHOSECT pFixupSect,
     2740static int  kldrModMachOFixupSectionGeneric32Bit(PRTLDRMODMACHO pThis, uint8_t *pbSectBits, PRTLDRMODMACHOSECT pFixupSect,
    27402741                                                 macho_nlist_32_t *paSyms, uint32_t cSyms, RTLDRADDR NewBaseAddress)
    27412742{
    … …  
    28152816                    case MACHO_N_SECT:
    28162817                    {
    2817                         PKLDRMODMACHOSECT pSymSect;
    2818                         KLDRMODMACHO_CHECK_RETURN((uint32_t)pSym->n_sect - 1 <= pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL);
     2818                        PRTLDRMODMACHOSECT pSymSect;
     2819                        RTLDRMODMACHO_CHECK_RETURN((uint32_t)pSym->n_sect - 1 <= pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL);
    28192820                        pSymSect = &pThis->paSections[pSym->n_sect - 1];
    28202821
    … …  
    28302831                    case MACHO_N_INDR:
    28312832                    case MACHO_N_PBUD:
    2832                         KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO);
     2833                        RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO);
    28332834                    default:
    2834                         KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_SYMBOL);
     2835                        RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_SYMBOL);
    28352836                }
    28362837            }
    28372838            else if (Fixup.r.r_symbolnum != R_ABS)
    28382839            {
    2839                 PKLDRMODMACHOSECT pSymSect;
     2840                PRTLDRMODMACHOSECT pSymSect;
    28402841                if (Fixup.r.r_symbolnum > pThis->cSections)
    28412842                    return VERR_LDR_BAD_FIXUP;
    … …  
    28522853        else
    28532854        {
    2854             PKLDRMODMACHOSECT pSymSect;
     2855            PRTLDRMODMACHOSECT pSymSect;
    28552856            uint32_t iSymSect;
    28562857            RTLDRADDR Value;
    28572858
    28582859            /* sanity */
    2859             KLDRMODMACHO_ASSERT(Fixup.s.r_scattered);
     2860            RTLDRMODMACHO_ASSERT(Fixup.s.r_scattered);
    28602861            if ((uint32_t)Fixup.s.r_address >= cbSectBits)
    28612862                return VERR_LDR_BAD_FIXUP;
    … …  
    29402941 * @param   NewBaseAddress  The new base image address.
    29412942 */
    2942 static int  kldrModMachOFixupSectionAMD64(PKLDRMODMACHO pThis, uint8_t *pbSectBits, PKLDRMODMACHOSECT pFixupSect,
     2943static int  kldrModMachOFixupSectionAMD64(PRTLDRMODMACHO pThis, uint8_t *pbSectBits, PRTLDRMODMACHOSECT pFixupSect,
    29432944                                          macho_nlist_64_t *paSyms, uint32_t cSyms, RTLDRADDR NewBaseAddress)
    29442945{
    … …  
    29772978
    29782979        /* AMD64 doesn't use scattered fixups. */
    2979         KLDRMODMACHO_CHECK_RETURN(!(Fixup.r.r_address & R_SCATTERED), VERR_LDR_BAD_FIXUP);
     2980        RTLDRMODMACHO_CHECK_RETURN(!(Fixup.r.r_address & R_SCATTERED), VERR_LDR_BAD_FIXUP);
    29802981
    29812982        /* sanity */
    2982         KLDRMODMACHO_CHECK_RETURN((uint32_t)Fixup.r.r_address < cbSectBits, VERR_LDR_BAD_FIXUP);
     2983        RTLDRMODMACHO_CHECK_RETURN((uint32_t)Fixup.r.r_address < cbSectBits, VERR_LDR_BAD_FIXUP);
    29832984
    29842985        /* calc fixup addresses. */
    … …  
    29982999            case 3: SymAddr = *uFixVirgin.pi64; break;
    29993000            default:
    3000                 KLDRMODMACHO_FAILED_RETURN(VERR_LDR_BAD_FIXUP);
     3001                RTLDRMODMACHO_FAILED_RETURN(VERR_LDR_BAD_FIXUP);
    30013002        }
    30023003
    … …  
    30063007            const macho_nlist_64_t *pSym;
    30073008
    3008             KLDRMODMACHO_CHECK_RETURN(Fixup.r.r_symbolnum < cSyms, VERR_LDR_BAD_FIXUP);
     3009            RTLDRMODMACHO_CHECK_RETURN(Fixup.r.r_symbolnum < cSyms, VERR_LDR_BAD_FIXUP);
    30093010            pSym = &paSyms[Fixup.r.r_symbolnum];
    3010             KLDRMODMACHO_CHECK_RETURN(!(pSym->n_type & MACHO_N_STAB), VERR_LDR_BAD_FIXUP);
     3011            RTLDRMODMACHO_CHECK_RETURN(!(pSym->n_type & MACHO_N_STAB), VERR_LDR_BAD_FIXUP);
    30113012
    30123013            switch (Fixup.r.r_type)
    … …  
    30243025                        case MACHO_N_INDR:
    30253026                        case MACHO_N_PBUD:
    3026                             KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO);
     3027                            RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO);
    30273028                        default:
    3028                             KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_SYMBOL);
     3029                            RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_SYMBOL);
    30293030                    }
    30303031                    SymAddr = sizeof(uint64_t) * Fixup.r.r_symbolnum + pThis->GotRVA + NewBaseAddress;
    3031                     KLDRMODMACHO_CHECK_RETURN(Fixup.r.r_length == 2, VERR_LDR_BAD_FIXUP);
     3032                    RTLDRMODMACHO_CHECK_RETURN(Fixup.r.r_length == 2, VERR_LDR_BAD_FIXUP);
    30323033                    SymAddr -= 4;
    30333034                    break;
    … …  
    30393040                case X86_64_RELOC_SIGNED_2:
    30403041                case X86_64_RELOC_SIGNED_4:
    3041                     KLDRMODMACHO_CHECK_RETURN(Fixup.r.r_pcrel, VERR_LDR_BAD_FIXUP);
     3042                    RTLDRMODMACHO_CHECK_RETURN(Fixup.r.r_pcrel, VERR_LDR_BAD_FIXUP);
    30423043                    /* Falls through. */
    30433044                default:
    … …  
    30473048                    {
    30483049                        case X86_64_RELOC_UNSIGNED:
    3049                             KLDRMODMACHO_CHECK_RETURN(!Fixup.r.r_pcrel, VERR_LDR_BAD_FIXUP);
     3050                            RTLDRMODMACHO_CHECK_RETURN(!Fixup.r.r_pcrel, VERR_LDR_BAD_FIXUP);
    30503051                            break;
    30513052                        case X86_64_RELOC_BRANCH:
    3052                             KLDRMODMACHO_CHECK_RETURN(Fixup.r.r_length == 2, VERR_LDR_BAD_FIXUP);
     3053                            RTLDRMODMACHO_CHECK_RETURN(Fixup.r.r_length == 2, VERR_LDR_BAD_FIXUP);
    30533054                            SymAddr -= 4;
    30543055                            break;
    … …  
    30603061                            break;
    30613062                        default:
    3062                             KLDRMODMACHO_FAILED_RETURN(VERR_LDR_BAD_FIXUP);
     3063                            RTLDRMODMACHO_FAILED_RETURN(VERR_LDR_BAD_FIXUP);
    30633064                    }
    30643065
    … …  
    30673068                        case MACHO_N_SECT:
    30683069                        {
    3069                             PKLDRMODMACHOSECT pSymSect;
    3070                             KLDRMODMACHO_CHECK_RETURN((uint32_t)pSym->n_sect - 1 <= pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL);
     3070                            PRTLDRMODMACHOSECT pSymSect;
     3071                            RTLDRMODMACHO_CHECK_RETURN((uint32_t)pSym->n_sect - 1 <= pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL);
    30713072                            pSymSect = &pThis->paSections[pSym->n_sect - 1];
    30723073                            SymAddr += pSym->n_value - pSymSect->LinkAddress + pSymSect->RVA + NewBaseAddress;
    … …  
    30923093                        case MACHO_N_INDR:
    30933094                        case MACHO_N_PBUD:
    3094                             KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO);
     3095                            RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO);
    30953096                        default:
    3096                             KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_SYMBOL);
     3097                            RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_SYMBOL);
    30973098                    }
    30983099                    break;
    … …  
    31113112                        case MACHO_N_SECT:
    31123113                        {
    3113                             PKLDRMODMACHOSECT pSymSect;
    3114                             KLDRMODMACHO_CHECK_RETURN((uint32_t)pSym->n_sect - 1 <= pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL);
     3114                            PRTLDRMODMACHOSECT pSymSect;
     3115                            RTLDRMODMACHO_CHECK_RETURN((uint32_t)pSym->n_sect - 1 <= pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL);
    31153116                            pSymSect = &pThis->paSections[pSym->n_sect - 1];
    31163117                            SymAddr -= pSym->n_value - pSymSect->LinkAddress + pSymSect->RVA + NewBaseAddress;
    … …  
    31253126                        case MACHO_N_INDR:
    31263127                        case MACHO_N_PBUD:
    3127                             KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO);
     3128                            RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO);
    31283129                        default:
    3129                             KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_SYMBOL);
     3130                            RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_SYMBOL);
    31303131                    }
    31313132
    31323133                    /* Load the 2nd fixup, check sanity. */
    31333134                    iFixup++;
    3134                     KLDRMODMACHO_CHECK_RETURN(!Fixup.r.r_pcrel && iFixup < cFixups, VERR_LDR_BAD_FIXUP);
     3135                    RTLDRMODMACHO_CHECK_RETURN(!Fixup.r.r_pcrel && iFixup < cFixups, VERR_LDR_BAD_FIXUP);
    31353136                    Fixup2 = paFixups[iFixup];
    3136                     KLDRMODMACHO_CHECK_RETURN(   Fixup2.r_address == Fixup.r.r_address
     3137                    RTLDRMODMACHO_CHECK_RETURN(   Fixup2.r_address == Fixup.r.r_address
    31373138                                              && Fixup2.r_length == Fixup.r.r_length
    31383139                                              && Fixup2.r_type == X86_64_RELOC_UNSIGNED
    … …  
    31433144                    if (Fixup2.r_extern)
    31443145                    {
    3145                         KLDRMODMACHO_CHECK_RETURN(Fixup2.r_symbolnum < cSyms, VERR_LDR_BAD_FIXUP);
     3146                        RTLDRMODMACHO_CHECK_RETURN(Fixup2.r_symbolnum < cSyms, VERR_LDR_BAD_FIXUP);
    31463147                        pSym = &paSyms[Fixup2.r_symbolnum];
    3147                         KLDRMODMACHO_CHECK_RETURN(!(pSym->n_type & MACHO_N_STAB), VERR_LDR_BAD_FIXUP);
     3148                        RTLDRMODMACHO_CHECK_RETURN(!(pSym->n_type & MACHO_N_STAB), VERR_LDR_BAD_FIXUP);
    31483149
    31493150                        /* Add it's value to SymAddr. */
    … …  
    31523153                            case MACHO_N_SECT:
    31533154                            {
    3154                                 PKLDRMODMACHOSECT pSymSect;
    3155                                 KLDRMODMACHO_CHECK_RETURN((uint32_t)pSym->n_sect - 1 <= pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL);
     3155                                PRTLDRMODMACHOSECT pSymSect;
     3156                                RTLDRMODMACHO_CHECK_RETURN((uint32_t)pSym->n_sect - 1 <= pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL);
    31563157                                pSymSect = &pThis->paSections[pSym->n_sect - 1];
    31573158                                SymAddr += pSym->n_value - pSymSect->LinkAddress + pSymSect->RVA + NewBaseAddress;
    … …  
    31663167                            case MACHO_N_INDR:
    31673168                            case MACHO_N_PBUD:
    3168                                 KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO);
     3169                                RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO);
    31693170                            default:
    3170                                 KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_SYMBOL);
     3171                                RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_BAD_SYMBOL);
    31713172                        }
    31723173                    }
    31733174                    else if (Fixup2.r_symbolnum != R_ABS)
    31743175                    {
    3175                         PKLDRMODMACHOSECT pSymSect;
    3176                         KLDRMODMACHO_CHECK_RETURN(Fixup2.r_symbolnum <= pThis->cSections, VERR_LDR_BAD_FIXUP);
     3176                        PRTLDRMODMACHOSECT pSymSect;
     3177                        RTLDRMODMACHO_CHECK_RETURN(Fixup2.r_symbolnum <= pThis->cSections, VERR_LDR_BAD_FIXUP);
    31773178                        pSymSect = &pThis->paSections[Fixup2.r_symbolnum - 1];
    31783179                        SymAddr += pSymSect->RVA + NewBaseAddress;
    31793180                    }
    31803181                    else
    3181                         KLDRMODMACHO_FAILED_RETURN(VERR_LDR_BAD_FIXUP);
     3182                        RTLDRMODMACHO_FAILED_RETURN(VERR_LDR_BAD_FIXUP);
    31823183                }
    31833184                break;
    … …  
    31903191            {
    31913192                case X86_64_RELOC_UNSIGNED:
    3192                     KLDRMODMACHO_CHECK_RETURN(!Fixup.r.r_pcrel, VERR_LDR_BAD_FIXUP);
     3193                    RTLDRMODMACHO_CHECK_RETURN(!Fixup.r.r_pcrel, VERR_LDR_BAD_FIXUP);
    31933194                    break;
    31943195                case X86_64_RELOC_BRANCH:
    3195                     KLDRMODMACHO_CHECK_RETURN(Fixup.r.r_pcrel, VERR_LDR_BAD_FIXUP);
     3196                    RTLDRMODMACHO_CHECK_RETURN(Fixup.r.r_pcrel, VERR_LDR_BAD_FIXUP);
    31963197                    SymAddr += 4; /* dunno what the assmbler/linker really is doing here... */
    31973198                    break;
    … …  
    32003201                case X86_64_RELOC_SIGNED_2:
    32013202                case X86_64_RELOC_SIGNED_4:
    3202                     KLDRMODMACHO_CHECK_RETURN(Fixup.r.r_pcrel, VERR_LDR_BAD_FIXUP);
     3203                    RTLDRMODMACHO_CHECK_RETURN(Fixup.r.r_pcrel, VERR_LDR_BAD_FIXUP);
    32033204                    break;
    32043205                /*case X86_64_RELOC_GOT_LOAD:*/
    … …  
    32063207                /*case X86_64_RELOC_SUBTRACTOR: - must be r_extern=1 says as. */
    32073208                default:
    3208                     KLDRMODMACHO_FAILED_RETURN(VERR_LDR_BAD_FIXUP);
     3209                    RTLDRMODMACHO_FAILED_RETURN(VERR_LDR_BAD_FIXUP);
    32093210            }
    32103211            if (Fixup.r.r_symbolnum != R_ABS)
    32113212            {
    3212                 PKLDRMODMACHOSECT pSymSect;
    3213                 KLDRMODMACHO_CHECK_RETURN(Fixup.r.r_symbolnum <= pThis->cSections, VERR_LDR_BAD_FIXUP);
     3213                PRTLDRMODMACHOSECT pSymSect;
     3214                RTLDRMODMACHO_CHECK_RETURN(Fixup.r.r_symbolnum <= pThis->cSections, VERR_LDR_BAD_FIXUP);
    32143215                pSymSect = &pThis->paSections[Fixup.r.r_symbolnum - 1];
    32153216
    … …  
    32343235                break;
    32353236            case 2:
    3236                 KLDRMODMACHO_CHECK_RETURN(Fixup.r.r_pcrel || Fixup.r.r_type == X86_64_RELOC_SUBTRACTOR, VERR_LDR_BAD_FIXUP);
    3237                 KLDRMODMACHO_CHECK_RETURN((int32_t)SymAddr == (int64_t)SymAddr, VERR_LDR_ADDRESS_OVERFLOW);
     3237                RTLDRMODMACHO_CHECK_RETURN(Fixup.r.r_pcrel || Fixup.r.r_type == X86_64_RELOC_SUBTRACTOR, VERR_LDR_BAD_FIXUP);
     3238                RTLDRMODMACHO_CHECK_RETURN((int32_t)SymAddr == (int64_t)SymAddr, VERR_LDR_ADDRESS_OVERFLOW);
    32383239                *uFix.pu32 = (uint32_t)SymAddr;
    32393240                break;
    32403241            default:
    3241                 KLDRMODMACHO_FAILED_RETURN(VERR_LDR_BAD_FIXUP);
     3242                RTLDRMODMACHO_FAILED_RETURN(VERR_LDR_BAD_FIXUP);
    32423243        }
    32433244    }
    … …  
    32503251 * Loads the symbol table for a MH_OBJECT file.
    32513252 *
    3252  * The symbol table is pointed to by KLDRMODMACHO::pvaSymbols.
     3253 * The symbol table is pointed to by RTLDRMODMACHO::pvaSymbols.
    32533254 *
    32543255 * @returns IPRT status code.
    32553256 * @param   pThis       The Mach-O module interpreter instance.
    32563257 */
    3257 static int  kldrModMachOLoadObjSymTab(PKLDRMODMACHO pThis)
     3258static int  kldrModMachOLoadObjSymTab(PRTLDRMODMACHO pThis)
    32583259{
    32593260    int rc = VINF_SUCCESS;
    … …  
    32683269
    32693270        /* sanity */
    3270         KLDRMODMACHO_CHECK_RETURN(   pThis->offSymbols
     3271        RTLDRMODMACHO_CHECK_RETURN(   pThis->offSymbols
    32713272                                  && (!pThis->cchStrings || pThis->offStrings),
    32723273                                  VERR_LDRMACHO_BAD_OBJECT_FILE);
    … …  
    32783279             : sizeof(macho_nlist_64_t);
    32793280        cbSyms = pThis->cSymbols * cbSym;
    3280         KLDRMODMACHO_CHECK_RETURN(cbSyms / cbSym == pThis->cSymbols, VERR_LDRMACHO_BAD_SYMTAB_SIZE);
     3281        RTLDRMODMACHO_CHECK_RETURN(cbSyms / cbSym == pThis->cSymbols, VERR_LDRMACHO_BAD_SYMTAB_SIZE);
    32813282        rc = VERR_NO_MEMORY;
    32823283        pvSyms = RTMemAlloc(cbSyms);
    … …  
    33333334    }
    33343335    else
    3335         KLDRMODMACHO_ASSERT(pThis->pchStrings || pThis->Hdr.filetype == MH_DSYM);
     3336        RTLDRMODMACHO_ASSERT(pThis->pchStrings || pThis->Hdr.filetype == MH_DSYM);
    33363337
    33373338    return rc;
    … …  
    33493350 * @param   ppaFixups       Where to put the pointer to the allocated fixup array.
    33503351 */
    3351 static int  kldrModMachOLoadFixups(PKLDRMODMACHO pThis, RTFOFF offFixups, uint32_t cFixups, macho_relocation_info_t **ppaFixups)
     3352static int  kldrModMachOLoadFixups(PRTLDRMODMACHO pThis, RTFOFF offFixups, uint32_t cFixups, macho_relocation_info_t **ppaFixups)
    33523353{
    33533354    macho_relocation_info_t *paFixups;
    … …  
    33563357    /* allocate the memory. */
    33573358    cbFixups = cFixups * sizeof(*paFixups);
    3358     KLDRMODMACHO_CHECK_RETURN(cbFixups / sizeof(*paFixups) == cFixups, VERR_LDRMACHO_BAD_SYMTAB_SIZE);
     3359    RTLDRMODMACHO_CHECK_RETURN(cbFixups / sizeof(*paFixups) == cFixups, VERR_LDRMACHO_BAD_SYMTAB_SIZE);
    33593360    paFixups = (macho_relocation_info_t *)RTMemAlloc(cbFixups);
    33603361    if (!paFixups)
    … …  
    33923393 * @param   pThis       The Mach-O module interpreter instance.
    33933394 */
    3394 static int kldrModMachOMapVirginBits(PKLDRMODMACHO pThis)
     3395static int kldrModMachOMapVirginBits(PRTLDRMODMACHO pThis)
    33953396{
    33963397    int rc = VINF_SUCCESS;
    … …  
    34433444static DECLCALLBACK(size_t) rtldrMachO_GetImageSize(PRTLDRMODINTERNAL pMod)
    34443445{
    3445     PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core);
     3446    PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core);
    34463447    return pThis->cbImage;
    34473448}
    … …  
    34543455                                            PFNRTLDRIMPORT pfnGetImport, void *pvUser)
    34553456{
    3456     PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core);
     3457    PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core);
    34573458
    34583459    if (!pThis->fCanLoad)
    … …  
    34963497                                                 RTUINTPTR OldBaseAddress, PFNRTLDRIMPORT pfnGetImport, void *pvUser)
    34973498{
    3498     PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core);
     3499    PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core);
    34993500    int rc;
    35003501    RT_NOREF(OldBaseAddress);
    … …  
    35353536 * the bits has been cleared up front.
    35363537 */
    3537 static int kldrModMachOMakeGOT(PKLDRMODMACHO pThis, void *pvBits, RTLDRADDR NewBaseAddress)
     3538static int kldrModMachOMakeGOT(PRTLDRMODMACHO pThis, void *pvBits, RTLDRADDR NewBaseAddress)
    35383539{
    35393540    uint32_t  iSym = pThis->cSymbols;
    … …  
    35483549                case MACHO_N_SECT:
    35493550                {
    3550                     PKLDRMODMACHOSECT pSymSect;
    3551                     KLDRMODMACHO_CHECK_RETURN((uint32_t)paSyms[iSym].n_sect - 1 <= pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL);
     3551                    PRTLDRMODMACHOSECT pSymSect;
     3552                    RTLDRMODMACHO_CHECK_RETURN((uint32_t)paSyms[iSym].n_sect - 1 <= pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL);
    35523553                    pSymSect = &pThis->paSections[paSyms[iSym].n_sect - 1];
    35533554                    paGOT[iSym] = (uint32_t)(paSyms[iSym].n_value - pSymSect->LinkAddress + pSymSect->RVA + NewBaseAddress);
    … …  
    35713572                case MACHO_N_SECT:
    35723573                {
    3573                     PKLDRMODMACHOSECT pSymSect;
    3574                     KLDRMODMACHO_CHECK_RETURN((uint32_t)paSyms[iSym].n_sect - 1 <= pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL);
     3574                    PRTLDRMODMACHOSECT pSymSect;
     3575                    RTLDRMODMACHO_CHECK_RETURN((uint32_t)paSyms[iSym].n_sect - 1 <= pThis->cSections, VERR_LDRMACHO_BAD_SYMBOL);
    35753576                    pSymSect = &pThis->paSections[paSyms[iSym].n_sect - 1];
    35763577                    paGOT[iSym] = paSyms[iSym].n_value - pSymSect->LinkAddress + pSymSect->RVA + NewBaseAddress;
    … …  
    36253626
    36263627                default:
    3627                     KLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO);
     3628                    RTLDRMODMACHO_FAILED_RETURN(VERR_LDRMACHO_TODO);
    36283629            }
    36293630        }
    … …  
    36383639static DECLCALLBACK(int) rtldrMachO_EnumSegments(PRTLDRMODINTERNAL pMod, PFNRTLDRENUMSEGS pfnCallback, void *pvUser)
    36393640{
    3640     PKLDRMODMACHO  pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core);
     3641    PRTLDRMODMACHO  pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core);
    36413642    uint32_t const cSegments  = pThis->cSegments;
    36423643    for (uint32_t iSeg = 0; iSeg < cSegments; iSeg++)
    … …  
    36573658                                                           uint32_t *piSeg, PRTLDRADDR poffSeg)
    36583659{
    3659     PKLDRMODMACHO  pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core);
     3660    PRTLDRMODMACHO  pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core);
    36603661    uint32_t const cSegments  = pThis->cSegments;
    36613662    for (uint32_t iSeg = 0; iSeg < cSegments; iSeg++)
    … …  
    36803681static DECLCALLBACK(int) rtldrMachO_LinkAddressToRva(PRTLDRMODINTERNAL pMod, RTLDRADDR LinkAddress, PRTLDRADDR pRva)
    36813682{
    3682     PKLDRMODMACHO  pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core);
     3683    PRTLDRMODMACHO  pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core);
    36833684    uint32_t const cSegments  = pThis->cSegments;
    36843685    for (uint32_t iSeg = 0; iSeg < cSegments; iSeg++)
    … …  
    37023703static DECLCALLBACK(int) rtldrMachO_SegOffsetToRva(PRTLDRMODINTERNAL pMod, uint32_t iSeg, RTLDRADDR offSeg, PRTLDRADDR pRva)
    37033704{
    3704     PKLDRMODMACHO  pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core);
     3705    PRTLDRMODMACHO  pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core);
    37053706
    37063707    if (iSeg >= pThis->cSegments)
    37073708        return VERR_LDR_INVALID_SEG_OFFSET;
    3708     KLDRMODMACHOSEG const *pSegment = &pThis->aSegments[iSeg];
     3709    RTLDRMODMACHOSEG const *pSegment = &pThis->aSegments[iSeg];
    37093710
    37103711    if (   offSeg > pSegment->SegInfo.cbMapped
    … …  
    37243725static DECLCALLBACK(int) rtldrMachO_RvaToSegOffset(PRTLDRMODINTERNAL pMod, RTLDRADDR Rva, uint32_t *piSeg, PRTLDRADDR poffSeg)
    37253726{
    3726     PKLDRMODMACHO  pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core);
     3727    PRTLDRMODMACHO  pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core);
    37273728    uint32_t const cSegments  = pThis->cSegments;
    37283729    for (uint32_t iSeg = 0; iSeg < cSegments; iSeg++)
    … …  
    37473748static DECLCALLBACK(int) rtldrMachO_ReadDbgInfo(PRTLDRMODINTERNAL pMod, uint32_t iDbgInfo, RTFOFF off, size_t cb, void *pvBuf)
    37483749{
    3749     PKLDRMODMACHO  pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core);
     3750    PRTLDRMODMACHO  pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core);
    37503751
    37513752    /** @todo May have to apply fixups here. */
    … …  
    37603761                                          void *pvBuf, size_t cbBuf, size_t *pcbRet)
    37613762{
    3762     PKLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, KLDRMODMACHO, Core);
     3763    PRTLDRMODMACHO pThis = RT_FROM_MEMBER(pMod, RTLDRMODMACHO, Core);
    37633764    int           rc;
    37643765    switch (enmProp)
    … …  
    38303831     * Create the instance data and do a minimal header validation.
    38313832     */
    3832     PKLDRMODMACHO pThis = NULL;
     3833    PRTLDRMODMACHO pThis = NULL;
    38333834    int rc = kldrModMachODoCreate(pReader, offImage, fFlags, &pThis, pErrInfo);
    38343835    if (RT_SUCCESS(rc))

  • trunk/src/VBox/Runtime/testcase/tstLdr-3.cpp

    r74646 r74647  
    231231    if (hLdrMod != g_hLdrMod || pvUser != NULL)
    232232        return VERR_INTERNAL_ERROR_3;
    233     RTPrintf("Seg#%02u: %RTptr LB %RTptr %s\n", g_iSegNo++, pSeg->RVA, pSeg->cbMapped, pSeg->pszName);
     233    RTPrintf("Seg#%02u: %RTptr LB %RTptr %s\n"
     234             "   link=%RTptr LB %RTptr align=%RTptr fProt=%#x offFile=%RTfoff\n"
     235             , g_iSegNo++, pSeg->RVA, pSeg->cbMapped, pSeg->pszName,
     236             pSeg->LinkAddress, pSeg->cb, pSeg->Alignment, pSeg->fProt, pSeg->offFile);
    234237
    235238    return VINF_SUCCESS;
Note: See TracChangeset for help on using the changeset viewer.

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