Changeset 3567 for trunk/kStuff/kLdr/kLdrModMachO.c

Timestamp:

Aug 27, 2007, 9:54:05 PM (18 years ago)

Author:

bird

Message:

Use the new type system.

File:

• trunk/kStuff/kLdr/kLdrModMachO.c (modified) (70 diffs)

trunk/kStuff/kLdr/kLdrModMachO.c

@@ -70 +70 @@
     KLDRFOFF                offFile;
     /** The number of fixups. */
-    uint32_t                cFixups;
+    KU32                    cFixups;
     /** The array of fixups. (lazy loaded) */
     macho_relocation_info_t *paFixups;
@@ -77 +77 @@
     KLDRFOFF                offFixups;
     /** Mach-O section flags. */
-    uint32_t                fFlags;
+    KU32                    fFlags;
     /** kLdr segment index. */
-    uint32_t                iSegment;
+    KU32                    iSegment;
     /** Pointer to the Mach-O section structure. */
     void                   *pvMachoSection;
@@ -92 +92 @@
 {
     /** The number of sections in the segment. */
-    uint32_t                cSections;
+    KU32                    cSections;
     /** Pointer to the sections belonging to this segment.
      * The array resides in the big memory chunk allocated for
@@ -122 +122 @@
 
     /** Pointer to the load commands. (endian converted) */
-    uint8_t                *pbLoadCommands;
+    KU8                    *pbLoadCommands;
     /** The Mach-O header. (endian converted)
      * @remark The reserved field is only valid for real 64-bit headers. */
@@ -130 +130 @@
     KLDRFOFF                offSymbols;
     /** The number of symbols. */
-    uint32_t                cSymbols;
+    KU32                    cSymbols;
     /** The pointer to the loaded symbol table. */
     void                   *pvaSymbols;
@@ -136 +136 @@
     KLDRFOFF                offStrings;
     /** The size of the of the string table. */
-    uint32_t                cchStrings;
+    KU32                    cchStrings;
     /** Pointer to the loaded string table. */
     char                   *pchStrings;
 
     /** The number of sections. */
-    uint32_t                cSections;
+    KU32                    cSections;
     /** Pointer to the section array running in parallel to the Mach-O one. */
     PKLDRMODMACHOSECT       paSections;
@@ -155 +155 @@
 *******************************************************************************/
 #if 0
-static int32_t kldrModMachONumberOfImports(PKLDRMOD pMod, const void *pvBits);
+static KI32 kldrModMachONumberOfImports(PKLDRMOD pMod, const void *pvBits);
 #endif
 static int kldrModMachORelocateBits(PKLDRMOD pMod, void *pvBits, KLDRADDR NewBaseAddress, KLDRADDR OldBaseAddress,
@@ -161 +161 @@
 
 static int  kldrModMachODoCreate(PKLDRRDR pRdr, PKLDRMODMACHO *ppMod);
-static int  kldrModMachOPreParseLoadCommands(uint8_t *pbLoadCommands, const mach_header_32_t *pHdr, PKLDRRDR pRdr,
-                                             uint32_t *pcSegments, uint32_t *pcSections, uint32_t *pcbStringPool);
-static int  kldrModMachOParseLoadCommands(PKLDRMODMACHO pModMachO, char *pbStringPool, uint32_t cbStringPool);
+static int  kldrModMachOPreParseLoadCommands(KU8 *pbLoadCommands, const mach_header_32_t *pHdr, PKLDRRDR pRdr,
+                                             KU32 *pcSegments, KU32 *pcSections, KU32 *pcbStringPool);
+static int  kldrModMachOParseLoadCommands(PKLDRMODMACHO pModMachO, char *pbStringPool, KU32 cbStringPool);
 static int  kldrModMachOAdjustBaseAddress(PKLDRMODMACHO pModMachO, PKLDRADDR pBaseAddress);
 
 /*static int  kldrModMachOLoadLoadCommands(PKLDRMODMACHO pModMachO);*/
 static int  kldrModMachOLoadObjSymTab(PKLDRMODMACHO pModMachO);
-static int  kldrModMachOLoadFixups(PKLDRMODMACHO pModMachO, KLDRFOFF offFixups, uint32_t cFixups, macho_relocation_info_t **ppaFixups);
+static int  kldrModMachOLoadFixups(PKLDRMODMACHO pModMachO, KLDRFOFF offFixups, KU32 cFixups, macho_relocation_info_t **ppaFixups);
 static int  kldrModMachOMapVirginBits(PKLDRMODMACHO pModMachO);
 
-static int  kldrModMachODoQuerySymbol32Bit(PKLDRMODMACHO pModMachO, const macho_nlist_32_t *paSyms, uint32_t cSyms, const char *pchStrings,
-                                           uint32_t cchStrings, KLDRADDR BaseAddress, uint32_t iSymbol, const char *pchSymbol,
-                                           size_t cchSymbol, PKLDRADDR puValue, uint32_t *pfKind);
-static int  kldrModMachODoEnumSymbols32Bit(PKLDRMODMACHO pModMachO, const macho_nlist_32_t *paSyms, uint32_t cSyms,
-                                           const char *pchStrings, uint32_t cchStrings, KLDRADDR BaseAddress,
-                                           uint32_t fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser);
+static int  kldrModMachODoQuerySymbol32Bit(PKLDRMODMACHO pModMachO, const macho_nlist_32_t *paSyms, KU32 cSyms, const char *pchStrings,
+                                           KU32 cchStrings, KLDRADDR BaseAddress, KU32 iSymbol, const char *pchSymbol,
+                                           KSIZE cchSymbol, PKLDRADDR puValue, KU32 *pfKind);
+static int  kldrModMachODoEnumSymbols32Bit(PKLDRMODMACHO pModMachO, const macho_nlist_32_t *paSyms, KU32 cSyms,
+                                           const char *pchStrings, KU32 cchStrings, KLDRADDR BaseAddress,
+                                           KU32 fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser);
 static int  kldrModMachOObjDoImports(PKLDRMODMACHO pModMachO, PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
 static int  kldrModMachOObjDoFixups(PKLDRMODMACHO pModMachO, void *pvMapping, KLDRADDR NewBaseAddress);
-static int  kldrModMachOFixupSectionGeneric32Bit(PKLDRMODMACHO pModMachO, uint8_t *pbSectBits, PKLDRMODMACHOSECT pFixupSect,
-                                                 macho_nlist_32_t *paSyms, uint32_t cSyms, KLDRADDR NewBaseAddress);
+static int  kldrModMachOFixupSectionGeneric32Bit(PKLDRMODMACHO pModMachO, KU8 *pbSectBits, PKLDRMODMACHOSECT pFixupSect,
+                                                 macho_nlist_32_t *paSyms, KU32 cSyms, KLDRADDR NewBaseAddress);
 
 /*static int  kldrModMachODoFixups(PKLDRMODMACHO pModMachO, void *pvMapping, KLDRADDR NewBaseAddress, KLDRADDR OldBaseAddress);
@@ -235 +235 @@
     PKLDRMODMACHO pModMachO;
     PKLDRMOD pMod;
-    uint8_t *pbLoadCommands;
-    uint32_t cSegments;
-    uint32_t cSections;
-    uint32_t cbStringPool;
-    size_t cchFilename;
-    size_t cb;
+    KU8 *pbLoadCommands;
+    KU32 cSegments;
+    KU32 cSections;
+    KU32 cbStringPool;
+    KSIZE cchFilename;
+    KSIZE cb;
     int rc;
     *ppModMachO = NULL;
@@ -311 +311 @@
 
     /* KLDRMOD */
-    pMod = (PKLDRMOD)((uint8_t *)pModMachO + KLDR_ALIGN_Z(  KLDR_OFFSETOF(KLDRMODMACHO, aSegments[cSegments])
-                                                          + sizeof(KLDRMODMACHOSECT) * cSections, 16));
+    pMod = (PKLDRMOD)((KU8 *)pModMachO + KLDR_ALIGN_Z(  KLDR_OFFSETOF(KLDRMODMACHO, aSegments[cSegments])
+                                                      + sizeof(KLDRMODMACHOSECT) * cSections, 16));
     pMod->pvData = pModMachO;
     pMod->pRdr = pRdr;
@@ -430 +430 @@
  * @param   pcbStringPool   Where to store the string pool size.
  */
-static int  kldrModMachOPreParseLoadCommands(uint8_t *pbLoadCommands, const mach_header_32_t *pHdr, PKLDRRDR pRdr,
-                                             uint32_t *pcSegments, uint32_t *pcSections, uint32_t *pcbStringPool)
+static int  kldrModMachOPreParseLoadCommands(KU8 *pbLoadCommands, const mach_header_32_t *pHdr, PKLDRRDR pRdr,
+                                             KU32 *pcSegments, KU32 *pcSections, KU32 *pcbStringPool)
 {
     union
     {
-        uint8_t              *pb;
+        KU8                  *pb;
         load_command_t       *pLoadCmd;
         segment_command_32_t *pSeg32;
@@ -443 +443 @@
         uuid_command_t       *pUuid;
     } u;
-    const uint64_t cbFile = kLdrRdrSize(pRdr);
-    uint32_t cSegments = 0;
-    uint32_t cSections = 0;
-    uint32_t cbStringPool = 0;
-    uint32_t cLeft = pHdr->ncmds;
-    uint32_t cbLeft = pHdr->sizeofcmds;
-    uint8_t *pb = pbLoadCommands;
+    const KU64 cbFile = kLdrRdrSize(pRdr);
+    KU32 cSegments = 0;
+    KU32 cSections = 0;
+    KU32 cbStringPool = 0;
+    KU32 cLeft = pHdr->ncmds;
+    KU32 cbLeft = pHdr->sizeofcmds;
+    KU8 *pb = pbLoadCommands;
     int cSegmentCommands = 0;
     int cSymbolTabs = 0;
@@ -487 +487 @@
                 section_32_t *pSect;
                 section_32_t *pFirstSect;
-                uint32_t cSectionsLeft;
+                KU32 cSectionsLeft;
 
                 /* convert and verify*/
@@ -509 +509 @@
                 if (    u.pSeg32->filesize
                     &&  (   u.pSeg32->fileoff > cbFile
-                         || (uint64_t)u.pSeg32->fileoff + u.pSeg32->filesize > cbFile))
+                         || (KU64)u.pSeg32->fileoff + u.pSeg32->filesize > cbFile))
                     return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
                 if (!u.pSeg32->filesize && u.pSeg32->fileoff)
@@ -594 +594 @@
                     if (    fFileBits
                         &&  (   pSect->offset > cbFile
-                             || (uint64_t)pSect->offset + pSect->size > cbFile))
+                             || (KU64)pSect->offset + pSect->size > cbFile))
                         return KLDR_ERR_MACHO_BAD_SECTION;
                     if (!fFileBits && pSect->offset)
@@ -602 +602 @@
                     if (    pSect->nreloc
                         &&  (   pSect->reloff > cbFile
-                             || (uint64_t)pSect->reloff + (KLDRFOFF)pSect->nreloc * sizeof(macho_relocation_info_t)) > cbFile)
+                             || (KU64)pSect->reloff + (KLDRFOFF)pSect->nreloc * sizeof(macho_relocation_info_t)) > cbFile)
                         return KLDR_ERR_MACHO_BAD_SECTION;
 
@@ -624 +624 @@
                                 /* verify that the linker/assembler has ordered sections correctly. */
                                 section_32_t *pCur = (pSect - 2);
-                                while ((uintptr_t)pCur >= (uintptr_t)pFirstSect)
+                                while ((KUPTR)pCur >= (KUPTR)pFirstSect)
                                 {
                                     if (!kLdrHlpStrNComp(pCur->segname, pSect->segname, sizeof(pSect->segname)))
@@ -656 +656 @@
             case LC_SYMTAB:
             {
-                size_t cbSym;
+                KSIZE cbSym;
                 if (fConvertEndian)
                 {
@@ -671 +671 @@
                       : sizeof(macho_nlist_64_t);
                 if (    u.pSymTab->symoff >= cbFile
-                    ||  (uint64_t)u.pSymTab->symoff + u.pSymTab->nsyms * cbSym > kLdrRdrSize(pRdr))
+                    ||  (KU64)u.pSymTab->symoff + u.pSymTab->nsyms * cbSym > kLdrRdrSize(pRdr))
                     return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
                 if (    u.pSymTab->stroff >= cbFile
-                    ||  (uint64_t)u.pSymTab->stroff + u.pSymTab->strsize > cbFile)
+                    ||  (KU64)u.pSymTab->stroff + u.pSymTab->strsize > cbFile)
                     return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
 
@@ -692 +692 @@
             case LC_UNIXTHREAD:
             {
-                uint32_t *pu32 = (uint32_t *)(u.pb + sizeof(load_command_t));
-                uint32_t cItemsLeft = (u.pThread->cmdsize - sizeof(load_command_t)) / sizeof(uint32_t);
+                KU32 *pu32 = (KU32 *)(u.pb + sizeof(load_command_t));
+                KU32 cItemsLeft = (u.pThread->cmdsize - sizeof(load_command_t)) / sizeof(KU32);
                 while (cItemsLeft)
                 {
-                    /* convert & verify header items ([0] == flavor, [1] == uint32_t count). */
+                    /* convert & verify header items ([0] == flavor, [1] == KU32 count). */
                     if (cItemsLeft < 2)
                         return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
@@ -787 +787 @@
  * @param   cbStringPool    The size of the string pool.
  */
-static int  kldrModMachOParseLoadCommands(PKLDRMODMACHO pModMachO, char *pbStringPool, uint32_t cbStringPool)
+static int  kldrModMachOParseLoadCommands(PKLDRMODMACHO pModMachO, char *pbStringPool, KU32 cbStringPool)
 {
     union
     {
-        const uint8_t              *pb;
+        const KU8                  *pb;
         const load_command_t       *pLoadCmd;
         const segment_command_32_t *pSeg32;
@@ -797 +797 @@
         const symtab_command_t     *pSymTab;
     } u;
-    uint32_t cLeft = pModMachO->Hdr.ncmds;
-    uint32_t cbLeft = pModMachO->Hdr.sizeofcmds;
-    const uint8_t *pb = pModMachO->pbLoadCommands;
+    KU32 cLeft = pModMachO->Hdr.ncmds;
+    KU32 cbLeft = pModMachO->Hdr.sizeofcmds;
+    const KU8 *pb = pModMachO->pbLoadCommands;
     int fFirstSegment = 1;
     PKLDRSEG pSeg = &pModMachO->pMod->aSegments[0];
     PKLDRMODMACHOSEG pSegExtra = &pModMachO->aSegments[0];
     PKLDRMODMACHOSECT pSectExtra = pModMachO->paSections;
-    const uint32_t cSegments = pModMachO->pMod->cSegments;
-    uint32_t i;
+    const KU32 cSegments = pModMachO->pMod->cSegments;
+    KU32 i;
 
     while (cLeft-- > 0)
@@ -822 +822 @@
                 section_32_t *pSect;
                 section_32_t *pFirstSect;
-                uint32_t cSectionsLeft;
+                KU32 cSectionsLeft;
 
                 pModMachO->LinkAddress = u.pSeg32->vmaddr;
@@ -867 +867 @@
                                 pSeg->pvUser = NULL;
                                 pSeg->pchName = pbStringPool;
-                                pSeg->cchName = (uint32_t)kLdrHlpStrNLen(&pSect->segname[0], sizeof(pSect->sectname));
+                                pSeg->cchName = (KU32)kLdrHlpStrNLen(&pSect->segname[0], sizeof(pSect->sectname));
                                 kLdrHlpMemCopy(pbStringPool, &pSect->segname[0], pSeg->cchName);
                                 pbStringPool += pSeg->cchName;
@@ -967 +967 @@
         {
             KLDRADDR cb1;
-            size_t cb2;
+            KSIZE cb2;
 
             for (i = 0; i < cSegments - 1; i++)
             {
                 cb1 = pSeg[i + 1].LinkAddress - pSeg[i].LinkAddress;
-                cb2 = (size_t)cb1;
-                pSeg[i].cbMapped = cb2 == cb1 ? cb2 : ~(size_t)0;
+                cb2 = (KSIZE)cb1;
+                pSeg[i].cbMapped = cb2 == cb1 ? cb2 : ~(KSIZE)0;
             }
             cb1 = KLDR_ALIGN_ADDR(pSeg[i].cb, pSeg[i].Alignment);
-            cb2 = (size_t)cb1;
-            pSeg[i].cbMapped = cb2 == cb1 ? cb2 : ~(size_t)0;
+            cb2 = (KSIZE)cb1;
+            pSeg[i].cbMapped = cb2 == cb1 ? cb2 : ~(KSIZE)0;
 
             pModMachO->cbImage = pSeg[i].RVA + cb1;
@@ -993 +993 @@
     PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
     int rc = 0;
-    uint32_t i, j;
+    KU32 i, j;
     KLDRMODMACHO_ASSERT(!pModMachO->pvMapping);
 
@@ -1049 +1049 @@
 
 /** @copydoc kLdrModQuerySymbol */
-static int kldrModMachOQuerySymbol(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, uint32_t iSymbol,
-                                   const char *pchSymbol, size_t cchSymbol, const char *pszVersion,
-                                   PFNKLDRMODGETIMPORT pfnGetForwarder, void *pvUser, PKLDRADDR puValue, uint32_t *pfKind)
+static int kldrModMachOQuerySymbol(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, KU32 iSymbol,
+                                   const char *pchSymbol, KSIZE cchSymbol, const char *pszVersion,
+                                   PFNKLDRMODGETIMPORT pfnGetForwarder, void *pvUser, PKLDRADDR puValue, KU32 *pfKind)
 {
     PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
@@ -1115 +1115 @@
  * @param   pfKind      See kLdrModQuerySymbol.
  */
-static int kldrModMachODoQuerySymbol32Bit(PKLDRMODMACHO pModMachO, const macho_nlist_32_t *paSyms, uint32_t cSyms, const char *pchStrings,
-                                          uint32_t cchStrings, KLDRADDR BaseAddress, uint32_t iSymbol, const char *pchSymbol, size_t cchSymbol,
-                                          PKLDRADDR puValue, uint32_t *pfKind)
+static int kldrModMachODoQuerySymbol32Bit(PKLDRMODMACHO pModMachO, const macho_nlist_32_t *paSyms, KU32 cSyms, const char *pchStrings,
+                                          KU32 cchStrings, KLDRADDR BaseAddress, KU32 iSymbol, const char *pchSymbol, KSIZE cchSymbol,
+                                          PKLDRADDR puValue, KU32 *pfKind)
 {
     /*
@@ -1130 +1130 @@
 
         /* external symbols are usually at the end, so search the other way. */
-        for (iSymbol = cSyms - 1; iSymbol != UINT32_MAX; iSymbol--)
+        for (iSymbol = cSyms - 1; iSymbol != KU32_MAX; iSymbol--)
         {
             const char *psz;
@@ -1147 +1147 @@
             if (!paSyms[iSymbol].n_un.n_strx)
                 continue;
-            if ((uint32_t)paSyms[iSymbol].n_un.n_strx >= cchStrings)
+            if ((KU32)paSyms[iSymbol].n_un.n_strx >= cchStrings)
                 continue;
             psz = &pchStrings[paSyms[iSymbol].n_un.n_strx];
@@ -1158 +1158 @@
             break;
         }
-        if (iSymbol == UINT32_MAX)
+        if (iSymbol == KU32_MAX)
             return KLDR_ERR_SYMBOL_NOT_FOUND;
     }
@@ -1191 +1191 @@
             PKLDRMODMACHOSECT pSect;
             KLDRADDR RVA;
-            if ((uint32_t)(paSyms[iSymbol].n_sect - 1) >= pModMachO->cSections)
+            if ((KU32)(paSyms[iSymbol].n_sect - 1) >= pModMachO->cSections)
                 return KLDR_ERR_MACHO_BAD_SYMBOL;
             pSect = &pModMachO->paSections[paSyms[iSymbol].n_sect - 1];
@@ -1228 +1228 @@
 /** @copydoc kLdrModEnumSymbols */
 static int kldrModMachOEnumSymbols(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress,
-                                   uint32_t fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser)
+                                   KU32 fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser)
 {
     PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
@@ -1280 +1280 @@
  * @param   pvUser      See kLdrModEnumSymbols.
  */
-static int kldrModMachODoEnumSymbols32Bit(PKLDRMODMACHO pModMachO, const macho_nlist_32_t *paSyms, uint32_t cSyms,
-                                          const char *pchStrings, uint32_t cchStrings, KLDRADDR BaseAddress,
-                                          uint32_t fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser)
-{
-    const uint32_t fKindBase = pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE
+static int kldrModMachODoEnumSymbols32Bit(PKLDRMODMACHO pModMachO, const macho_nlist_32_t *paSyms, KU32 cSyms,
+                                          const char *pchStrings, KU32 cchStrings, KLDRADDR BaseAddress,
+                                          KU32 fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser)
+{
+    const KU32 fKindBase = pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE
                             || pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE_OE
                              ? KLDRSYMKIND_32BIT : KLDRSYMKIND_64BIT;
-    uint32_t iSym;
+    KU32 iSym;
     int rc;
 
@@ -1295 +1295 @@
     for (iSym = 0; iSym < cSyms; iSym++)
     {
-        uint32_t fKind;
+        KU32 fKind;
         KLDRADDR uValue;
         const char *psz;
-        size_t cch;
+        KSIZE cch;
 
         /* Skip debug symbols and undefined symbols. */
@@ -1322 +1322 @@
 
         /* name */
-        if ((uint32_t)paSyms[iSym].n_un.n_strx >= cchStrings)
+        if ((KU32)paSyms[iSym].n_un.n_strx >= cchStrings)
             return KLDR_ERR_MACHO_BAD_SYMBOL;
         psz = &pchStrings[paSyms[iSym].n_un.n_strx];
@@ -1338 +1338 @@
             {
                 PKLDRMODMACHOSECT pSect;
-                if ((uint32_t)(paSyms[iSym].n_sect - 1) >= pModMachO->cSections)
+                if ((KU32)(paSyms[iSym].n_sect - 1) >= pModMachO->cSections)
                     return KLDR_ERR_MACHO_BAD_SYMBOL;
                 pSect = &pModMachO->paSections[paSyms[iSym].n_sect - 1];
@@ -1379 +1379 @@
 
 /** @copydoc kLdrModGetImport */
-static int kldrModMachOGetImport(PKLDRMOD pMod, const void *pvBits, uint32_t iImport, char *pszName, size_t cchName)
+static int kldrModMachOGetImport(PKLDRMOD pMod, const void *pvBits, KU32 iImport, char *pszName, KSIZE cchName)
 {
     PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
@@ -1391 +1391 @@
 
 /** @copydoc kLdrModNumberOfImports */
-static int32_t kldrModMachONumberOfImports(PKLDRMOD pMod, const void *pvBits)
+static KI32 kldrModMachONumberOfImports(PKLDRMOD pMod, const void *pvBits)
 {
     PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
@@ -1449 +1449 @@
     PKLDRMODMACHO                      pModMachO = (PKLDRMODMACHO)pMod->pvData;
     const IMAGE_DEBUG_DIRECTORY    *pDbgDir;
-    uint32_t                        iDbgInfo;
-    uint32_t                        cb;
+    KU32                            iDbgInfo;
+    KU32                            cb;
     int                             rc;
 
@@ -1543 +1543 @@
     PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
     unsigned fFixed;
-    uint32_t i;
+    KU32 i;
     void *pvBase;
     int rc;
@@ -1563 +1563 @@
     else
     {
-        pvBase = (void *)(uintptr_t)pMod->aSegments[0].LinkAddress;
-        if ((uintptr_t)pvBase != pMod->aSegments[0].LinkAddress)
+        pvBase = (void *)(KUPTR)pMod->aSegments[0].LinkAddress;
+        if ((KUPTR)pvBase != pMod->aSegments[0].LinkAddress)
             return KLDR_ERR_ADDRESS_OVERFLOW;
     }
@@ -1584 +1584 @@
     {
         if (pMod->aSegments[i].RVA != NIL_KLDRADDR)
-            pMod->aSegments[i].MapAddress = (uintptr_t)pvBase + (uintptr_t)pMod->aSegments[i].RVA;
+            pMod->aSegments[i].MapAddress = (KUPTR)pvBase + (KUPTR)pMod->aSegments[i].RVA;
     }
     pModMachO->pvMapping = pvBase;
@@ -1596 +1596 @@
 {
     PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
-    uint32_t i;
+    KU32 i;
     int rc;
 
@@ -1691 +1691 @@
      * Resolve imports and apply base relocations.
      */
-    rc = kldrModMachORelocateBits(pMod, pModMachO->pvMapping, (uintptr_t)pModMachO->pvMapping, pModMachO->LinkAddress,
+    rc = kldrModMachORelocateBits(pMod, pModMachO->pvMapping, (KUPTR)pModMachO->pvMapping, pModMachO->LinkAddress,
                                   pfnGetImport, pvUser);
 
@@ -1717 +1717 @@
 static int  kldrModMachOObjDoImports(PKLDRMODMACHO pModMachO, PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser)
 {
-    const uint32_t cSyms = pModMachO->cSymbols;
-    uint32_t iSym;
+    const KU32 cSyms = pModMachO->cSymbols;
+    KU32 iSym;
     int rc;
 
@@ -1745 +1745 @@
             {
                 const char *pszSymbol;
-                size_t cchSymbol;
-                uint32_t fKind = KLDRSYMKIND_REQ_FLAT;
+                KSIZE cchSymbol;
+                KU32 fKind = KLDRSYMKIND_REQ_FLAT;
                 KLDRADDR Value;
 
@@ -1754 +1754 @@
 
                 /* Get the symbol name and try resolve it. */
-                if ((uint32_t)paSyms[iSym].n_un.n_strx >= pModMachO->cchStrings)
+                if ((KU32)paSyms[iSym].n_un.n_strx >= pModMachO->cchStrings)
                     return KLDR_ERR_MACHO_BAD_SYMBOL;
                 pszSymbol = &pModMachO->pchStrings[paSyms[iSym].n_un.n_strx];
@@ -1769 +1769 @@
 
                 /* Update the symbol. */
-                paSyms[iSym].n_value = (uint32_t)Value;
+                paSyms[iSym].n_value = (KU32)Value;
                 if (paSyms[iSym].n_value != Value)
                 {
@@ -1796 +1796 @@
             {
                 const char *pszSymbol;
-                size_t cchSymbol;
-                uint32_t fKind = KLDRSYMKIND_REQ_FLAT;
+                KSIZE cchSymbol;
+                KU32 fKind = KLDRSYMKIND_REQ_FLAT;
                 KLDRADDR Value;
 
@@ -1850 +1850 @@
 static int  kldrModMachOObjDoFixups(PKLDRMODMACHO pModMachO, void *pvMapping, KLDRADDR NewBaseAddress)
 {
-    uint32_t iSeg;
+    KU32 iSeg;
     int rc;
 
@@ -1867 +1867 @@
     {
         PKLDRMODMACHOSEG pSeg = &pModMachO->aSegments[iSeg];
-        uint32_t iSect;
+        KU32 iSect;
 
         for (iSect = 0; iSect < pSeg->cSections; iSect++)
         {
             PKLDRMODMACHOSECT pSect = &pSeg->paSections[iSect];
-            uint8_t *pbSectBits;
+            KU8 *pbSectBits;
 
             /* skip sections without fixups. */
@@ -1889 +1889 @@
              * Apply the fixups.
              */
-            pbSectBits = (uint8_t *)pvMapping + (uintptr_t)pSect->RVA;
+            pbSectBits = (KU8 *)pvMapping + (KUPTR)pSect->RVA;
             if (pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE) /** @todo this aint right. */
                 rc = kldrModMachOFixupSectionGeneric32Bit(pModMachO, pbSectBits, pSect,
@@ -1915 +1915 @@
  * @param   NewBaseAddress  The new base image address.
  */
-static int  kldrModMachOFixupSectionGeneric32Bit(PKLDRMODMACHO pModMachO, uint8_t *pbSectBits, PKLDRMODMACHOSECT pFixupSect,
-                                                 macho_nlist_32_t *paSyms, uint32_t cSyms, KLDRADDR NewBaseAddress)
+static int  kldrModMachOFixupSectionGeneric32Bit(PKLDRMODMACHO pModMachO, KU8 *pbSectBits, PKLDRMODMACHOSECT pFixupSect,
+                                                 macho_nlist_32_t *paSyms, KU32 cSyms, KLDRADDR NewBaseAddress)
 {
     const macho_relocation_info_t *paFixups = pFixupSect->paFixups;
-    const uint32_t cFixups = pFixupSect->cFixups;
-    size_t cbSectBits = (size_t)pFixupSect->cb;
-    const uint8_t *pbSectVirginBits;
-    uint32_t iFixup;
+    const KU32 cFixups = pFixupSect->cFixups;
+    KSIZE cbSectBits = (KSIZE)pFixupSect->cb;
+    const KU8 *pbSectVirginBits;
+    KU32 iFixup;
     KLDRPU uFixVirgin;
     KLDRPU uFix;
@@ -1936 +1936 @@
         if (rc)
             return rc;
-        pbSectVirginBits = (const uint8_t *)pModMachO->pvBits + pFixupSect->offFile;
+        pbSectVirginBits = (const KU8 *)pModMachO->pvBits + pFixupSect->offFile;
     }
     else
@@ -1956 +1956 @@
         {
             /* sanity */
-            if ((uint32_t)Fixup.r.r_address >= cbSectBits)
+            if ((KU32)Fixup.r.r_address >= cbSectBits)
                 return KLDR_ERR_BAD_FIXUP;
 
             /* calc fixup addresses. */
             uFix.pv = pbSectBits + Fixup.r.r_address;
-            uFixVirgin.pv = pbSectVirginBits ? (uint8_t *)pbSectVirginBits + Fixup.r.r_address : 0;
+            uFixVirgin.pv = pbSectVirginBits ? (KU8 *)pbSectVirginBits + Fixup.r.r_address : 0;
 
             /*
@@ -1994 +1994 @@
                     {
                         PKLDRMODMACHOSECT pSymSect;
-                        if ((uint32_t)pSym->n_sect - 1 > pModMachO->cSections)
+                        if ((KU32)pSym->n_sect - 1 > pModMachO->cSections)
                             return KLDR_ERR_MACHO_BAD_SYMBOL;
                         pSymSect = &pModMachO->paSections[pSym->n_sect - 1];
@@ -2032 +2032 @@
         {
             PKLDRMODMACHOSECT pSymSect;
-            uint32_t iSymSect;
+            KU32 iSymSect;
             KLDRADDR Value;
 
             /* sanity */
             KLDRMODMACHO_ASSERT(Fixup.s.r_scattered);
-            if ((uint32_t)Fixup.s.r_address >= cbSectBits)
+            if ((KU32)Fixup.s.r_address >= cbSectBits)
                 return KLDR_ERR_BAD_FIXUP;
 
             /* calc fixup addresses. */
             uFix.pv = pbSectBits + Fixup.s.r_address;
-            uFixVirgin.pv = pbSectVirginBits ? (uint8_t *)pbSectVirginBits + Fixup.s.r_address : 0;
+            uFixVirgin.pv = pbSectVirginBits ? (KU8 *)pbSectVirginBits + Fixup.s.r_address : 0;
 
             /*
@@ -2092 +2092 @@
             switch (Fixup.r.r_length)
             {
-                case 0: *uFix.pu8  = (uint8_t)SymAddr; break;
-                case 1: *uFix.pu16 = (uint16_t)SymAddr; break;
-                case 2: *uFix.pu32 = (uint32_t)SymAddr; break;
-                case 3: *uFix.pu64 = (uint64_t)SymAddr; break;
+                case 0: *uFix.pu8  = (KU8)SymAddr; break;
+                case 1: *uFix.pu16 = (KU16)SymAddr; break;
+                case 2: *uFix.pu32 = (KU32)SymAddr; break;
+                case 3: *uFix.pu64 = (KU64)SymAddr; break;
             }
         }
@@ -2123 +2123 @@
         &&  pModMachO->cSymbols)
     {
-        size_t cbSyms;
-        size_t cbSym;
+        KSIZE cbSyms;
+        KSIZE cbSym;
         void *pvSyms;
         void *pvStrings;
@@ -2163 +2163 @@
                     if (pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE_OE)
                     {
-                        uint32_t cLeft = pModMachO->cSymbols;
+                        KU32 cLeft = pModMachO->cSymbols;
                         macho_nlist_32_t *pSym = (macho_nlist_32_t *)pvSyms;
                         while (cLeft-- > 0)
                         {
                             pSym->n_un.n_strx = KLDR_E2E_U32(pSym->n_un.n_strx);
-                            pSym->n_desc = (int16_t)KLDR_E2E_U16(pSym->n_desc);
+                            pSym->n_desc = (KI16)KLDR_E2E_U16(pSym->n_desc);
                             pSym->n_value = KLDR_E2E_U32(pSym->n_value);
                             pSym++;
@@ -2175 +2175 @@
                     else if (pModMachO->Hdr.magic == IMAGE_MACHO64_SIGNATURE_OE)
                     {
-                        uint32_t cLeft = pModMachO->cSymbols;
+                        KU32 cLeft = pModMachO->cSymbols;
                         macho_nlist_64_t *pSym = (macho_nlist_64_t *)pvSyms;
                         while (cLeft-- > 0)
                         {
                             pSym->n_un.n_strx = KLDR_E2E_U32(pSym->n_un.n_strx);
-                            pSym->n_desc = (int16_t)KLDR_E2E_U16(pSym->n_desc);
+                            pSym->n_desc = (KI16)KLDR_E2E_U16(pSym->n_desc);
                             pSym->n_value = KLDR_E2E_U64(pSym->n_value);
                             pSym++;
@@ -2210 +2210 @@
  * @param   ppaFixups       Where to put the pointer to the allocated fixup array.
  */
-static int  kldrModMachOLoadFixups(PKLDRMODMACHO pModMachO, KLDRFOFF offFixups, uint32_t cFixups, macho_relocation_info_t **ppaFixups)
+static int  kldrModMachOLoadFixups(PKLDRMODMACHO pModMachO, KLDRFOFF offFixups, KU32 cFixups, macho_relocation_info_t **ppaFixups)
 {
     macho_relocation_info_t *paFixups;
-    size_t cbFixups;
+    KSIZE cbFixups;
     int rc;
 
@@ -2234 +2234 @@
             ||  pModMachO->Hdr.magic == IMAGE_MACHO64_SIGNATURE_OE)
         {
-            uint32_t iFixup;
+            KU32 iFixup;
             for (iFixup = 0; iFixup < cFixups; iFixup++)
             {
-                uint32_t *pu32 = (uint32_t *)&paFixups[iFixup];
+                KU32 *pu32 = (KU32 *)&paFixups[iFixup];
                 pu32[0] = KLDR_E2E_U32(pu32[0]);
                 pu32[1] = KLDR_E2E_U32(pu32[1]);
@@ -2265 +2265 @@
 
 /** @copydoc kLdrModCallInit */
-static int kldrModMachOCallInit(PKLDRMOD pMod, uintptr_t uHandle)
+static int kldrModMachOCallInit(PKLDRMOD pMod, KUPTR uHandle)
 {
     /* later */
@@ -2273 +2273 @@
 
 /** @copydoc kLdrModCallTerm */
-static int kldrModMachOCallTerm(PKLDRMOD pMod, uintptr_t uHandle)
+static int kldrModMachOCallTerm(PKLDRMOD pMod, KUPTR uHandle)
 {
     /* later */
@@ -2281 +2281 @@
 
 /** @copydoc kLdrModCallThread */
-static int kldrModMachOCallThread(PKLDRMOD pMod, uintptr_t uHandle, unsigned fAttachingOrDetaching)
+static int kldrModMachOCallThread(PKLDRMOD pMod, KUPTR uHandle, unsigned fAttachingOrDetaching)
 {
     /* Relevant for Mach-O? */
@@ -2300 +2300 @@
 {
     PKLDRMODMACHO  pModMachO = (PKLDRMODMACHO)pMod->pvData;
-    uint32_t    i;
+    KU32        i;
     int         rc;
 
@@ -2306 +2306 @@
      * Zero the entire buffer first to simplify things.
      */
-    kLdrHlpMemSet(pvBits, 0, (size_t)pModMachO->cbImage);
+    kLdrHlpMemSet(pvBits, 0, (KSIZE)pModMachO->cbImage);
 
     /*
@@ -2325 +2325 @@
                 continue;
             rc = kLdrRdrRead(pMod->pRdr,
-                             (uint8_t *)pvBits + (pMod->aSegments[i].LinkAddress - pModMachO->LinkAddress),
+                             (KU8 *)pvBits + (pMod->aSegments[i].LinkAddress - pModMachO->LinkAddress),
                              pMod->aSegments[i].cbFile,
                              pMod->aSegments[i].offFile);