Ignore:
Timestamp:
Aug 27, 2007, 9:54:05 PM (18 years ago)
Author:
bird
Message:

Use the new type system.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/kStuff/kLdr/kLdrModPE.c

    r3537 r3567  
    5858 */
    5959#define KLDRMODPE_RVA2TYPE(pvBits, uRVA, type) \
    60         ( (type) ((uintptr_t)(pvBits) + (uintptr_t)(uRVA)) )
     60        ( (type) ((KUPTR)(pvBits) + (KUPTR)(uRVA)) )
    6161
    6262/** @def KLDRMODPE_VALID_RVA
    … …  
    8686    const void             *pvMapping;
    8787    /** Reserved flags. */
    88     uint32_t                f32Reserved;
     88    KU32                    f32Reserved;
    8989    /** The number of imported modules.
    90      * If ~(uint32_t)0 this hasn't been determined yet. */
    91     uint32_t                cImportModules;
     90     * If ~(KU32)0 this hasn't been determined yet. */
     91    KU32                    cImportModules;
    9292    /** The offset of the NT headers. */
    9393    KLDRFOFF                offHdrs;
    … …  
    102102*   Internal Functions                                                         *
    103103*******************************************************************************/
    104 static int32_t kldrModPENumberOfImports(PKLDRMOD pMod, const void *pvBits);
     104static KI32 kldrModPENumberOfImports(PKLDRMOD pMod, const void *pvBits);
    105105static int  kldrModPERelocateBits(PKLDRMOD pMod, void *pvBits, KLDRADDR NewBaseAddress, KLDRADDR OldBaseAddress,
    106106                                  PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
    … …  
    112112static void kldrModPEDoOptionalHeaderConversion(PIMAGE_OPTIONAL_HEADER64 pOptionalHeader);
    113113static int  kldrModPEDoForwarderQuery(PKLDRMODPE pModPE, const void *pvBits, const char *pszForwarder,
    114                                      PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser, PKLDRADDR puValue, uint32_t *pfKind);
     114                                     PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser, PKLDRADDR puValue, KU32 *pfKind);
    115115static int  kldrModPEDoFixups(PKLDRMODPE pModPE, void *pvMapping, KLDRADDR NewBaseAddress, KLDRADDR OldBaseAddress);
    116116static int  kldrModPEDoImports32Bit(PKLDRMODPE pModPE, void *pvMapping, const IMAGE_IMPORT_DESCRIPTOR *pImpDesc,
    … …  
    119119                                    PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
    120120static int  kldrModPEDoImports(PKLDRMODPE pModPE, void *pvMapping, PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
    121 static int  kldrModPEDoCallDLL(PKLDRMODPE pModPE, unsigned uOp, uintptr_t uHandle);
    122 static int  kldrModPEDoCallTLS(PKLDRMODPE pModPE, unsigned uOp, uintptr_t uHandle);
    123 static int32_t kldrModPEDoCall(uintptr_t uEntrypoint, uintptr_t uHandle, uint32_t uOp, void *pvReserved);
     121static int  kldrModPEDoCallDLL(PKLDRMODPE pModPE, unsigned uOp, KUPTR uHandle);
     122static int  kldrModPEDoCallTLS(PKLDRMODPE pModPE, unsigned uOp, KUPTR uHandle);
     123static KI32 kldrModPEDoCall(KUPTR uEntrypoint, KUPTR uHandle, KU32 uOp, void *pvReserved);
    124124
    125125
    … …  
    164164    struct
    165165    {
    166         uint32_t            Signature;
     166        KU32                Signature;
    167167        IMAGE_FILE_HEADER   FileHdr;
    168168    } s;
    169169    PKLDRMODPE pModPE;
    170170    PKLDRMOD pMod;
    171     size_t cb;
    172     size_t cchFilename;
     171    KSIZE cb;
     172    KSIZE cchFilename;
    173173    KLDRFOFF off;
    174     uint32_t i;
     174    KU32 i;
    175175    int rc;
    176176    *ppModPE = NULL;
    … …  
    210210
    211211    /* KLDRMOD */
    212     pMod = (PKLDRMOD)((uint8_t *)pModPE + KLDR_ALIGN_Z(KLDR_OFFSETOF(KLDRMODPE, aShdrs[s.FileHdr.NumberOfSections]), 16));
     212    pMod = (PKLDRMOD)((KU8 *)pModPE + KLDR_ALIGN_Z(KLDR_OFFSETOF(KLDRMODPE, aShdrs[s.FileHdr.NumberOfSections]), 16));
    213213    pMod->pvData = pModPE;
    214214    pMod->pRdr = pRdr;
    … …  
    253253    pModPE->pvMapping = NULL;
    254254    pModPE->f32Reserved = 0;
    255     pModPE->cImportModules = ~(uint32_t)0;
     255    pModPE->cImportModules = ~(KU32)0;
    256256    pModPE->offHdrs = offNewHdr >= 0 ? offNewHdr : 0;
    257257    pModPE->Hdrs.Signature = s.Signature;
    … …  
    432432    IMAGE_OPTIONAL_HEADER32 volatile *pOptHdr32 = (IMAGE_OPTIONAL_HEADER32 volatile *)pOptHdr;
    433433    IMAGE_OPTIONAL_HEADER64 volatile *pOptHdr64 = pOptHdr;
    434     uint32_t volatile                *pu32Dst;
    435     uint32_t volatile                *pu32Src;
    436     uint32_t volatile                *pu32SrcLast;
    437     uint32_t                          u32;
     434    KU32 volatile                    *pu32Dst;
     435    KU32 volatile                    *pu32Src;
     436    KU32 volatile                    *pu32SrcLast;
     437    KU32                              u32;
    438438
    439439    /* From LoaderFlags and out the difference is 4 * 32-bits. */
    440     pu32Dst     = (uint32_t *)&pOptHdr64->DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] - 1;
    441     pu32Src     = (uint32_t *)&pOptHdr32->DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] - 1;
    442     pu32SrcLast = (uint32_t *)&pOptHdr32->LoaderFlags;
     440    pu32Dst     = (KU32 *)&pOptHdr64->DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] - 1;
     441    pu32Src     = (KU32 *)&pOptHdr32->DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] - 1;
     442    pu32SrcLast = (KU32 *)&pOptHdr32->LoaderFlags;
    443443    while (pu32Src >= pu32SrcLast)
    444444        *pu32Dst-- = *pu32Src--;
    … …  
    472472    IMAGE_LOAD_CONFIG_DIRECTORY32 volatile *pLoadCfg32 = (IMAGE_LOAD_CONFIG_DIRECTORY32 volatile *)pLoadCfg;
    473473    IMAGE_LOAD_CONFIG_DIRECTORY64 volatile *pLoadCfg64 = pLoadCfg;
    474     uint32_t                                u32;
     474    KU32                                    u32;
    475475
    476476    pLoadCfg64->SEHandlerCount             = pLoadCfg32->SEHandlerCount;
    … …  
    557557    void       *pvBase;
    558558    int         rc;
    559     uint32_t    i;
     559    KU32        i;
    560560
    561561    /*
    … …  
    570570    else
    571571    {
    572         pvBase = (void *)(uintptr_t)pMod->aSegments[0].LinkAddress;
    573         if ((uintptr_t)pvBase != pMod->aSegments[0].LinkAddress)
     572        pvBase = (void *)(KUPTR)pMod->aSegments[0].LinkAddress;
     573        if ((KUPTR)pvBase != pMod->aSegments[0].LinkAddress)
    574574            return KLDR_ERR_ADDRESS_OVERFLOW;
    575575    }
    … …  
    588588        {
    589589            if (pMod->aSegments[i].RVA != NIL_KLDRADDR)
    590                 pMod->aSegments[i].MapAddress = (uintptr_t)pvBase + (uintptr_t)pMod->aSegments[i].RVA;
     590                pMod->aSegments[i].MapAddress = (KUPTR)pvBase + (KUPTR)pMod->aSegments[i].RVA;
    591591        }
    592592        pModPE->pvMapping = pvBase;
    … …  
    612612    PKLDRMOD    pMod = pModPE->pMod;
    613613    int         rc;
    614     uint32_t    i;
     614    KU32        i;
    615615
    616616    /*
    … …  
    690690
    691691/** @copydoc kLdrModQuerySymbol */
    692 static int kldrModPEQuerySymbol(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, uint32_t iSymbol,
    693                                 const char *pchSymbol, size_t cchSymbol, const char *pszVersion,
    694                                 PFNKLDRMODGETIMPORT pfnGetForwarder, void *pvUser, PKLDRADDR puValue, uint32_t *pfKind)
     692static int kldrModPEQuerySymbol(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, KU32 iSymbol,
     693                                const char *pchSymbol, KSIZE cchSymbol, const char *pszVersion,
     694                                PFNKLDRMODGETIMPORT pfnGetForwarder, void *pvUser, PKLDRADDR puValue, KU32 *pfKind)
    695695
    696696{
    697697    PKLDRMODPE                      pModPE = (PKLDRMODPE)pMod->pvData;
    698     const uint32_t                 *paExportRVAs;
     698    const KU32                     *paExportRVAs;
    699699    const IMAGE_EXPORT_DIRECTORY   *pExpDir;
    700     uint32_t                        iExpOrd;
    701     uint32_t                        uRVA;
     700    KU32                            iExpOrd;
     701    KU32                            uRVA;
    702702    int                             rc;
    703703
    … …  
    732732         * (The name table is sorted in ascending ordered by the linker.)
    733733         */
    734         const uint32_t *paRVANames = KLDRMODPE_RVA2TYPE(pvBits, pExpDir->AddressOfNames, const uint32_t *);
    735         const uint16_t *paOrdinals = KLDRMODPE_RVA2TYPE(pvBits, pExpDir->AddressOfNameOrdinals, const uint16_t *);
    736         int32_t         iStart = 1; /* one based binary searching is simpler. */
    737         int32_t         iEnd = pExpDir->NumberOfNames;
     734        const KU32 *paRVANames = KLDRMODPE_RVA2TYPE(pvBits, pExpDir->AddressOfNames, const KU32 *);
     735        const KU16 *paOrdinals = KLDRMODPE_RVA2TYPE(pvBits, pExpDir->AddressOfNameOrdinals, const KU16 *);
     736        KI32        iStart = 1; /* one based binary searching is simpler. */
     737        KI32        iEnd = pExpDir->NumberOfNames;
    738738
    739739        for (;;)
    740740        {
    741             int32_t     i;
     741            KI32        i;
    742742            int         diff;
    743743            const char *pszName;
    … …  
    747747            {
    748748#ifdef KLDRMODPE_STRICT /* Make sure the linker and we both did our job right. */
    749                 for (i = 0; i < (int32_t)pExpDir->NumberOfNames; i++)
     749                for (i = 0; i < (KI32)pExpDir->NumberOfNames; i++)
    750750
    751751                {
    … …  
    778778     * Lookup the address in the 'symbol' table.
    779779     */
    780     paExportRVAs = KLDRMODPE_RVA2TYPE(pvBits, pExpDir->AddressOfFunctions, const uint32_t *);
     780    paExportRVAs = KLDRMODPE_RVA2TYPE(pvBits, pExpDir->AddressOfFunctions, const KU32 *);
    781781    uRVA = paExportRVAs[iExpOrd];
    782782    if (    uRVA - pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress
    … …  
    815815 */
    816816static int kldrModPEDoForwarderQuery(PKLDRMODPE pModPE, const void *pvBits, const char *pszForwarder,
    817                                      PFNKLDRMODGETIMPORT pfnGetForwarder, void *pvUser, PKLDRADDR puValue, uint32_t *pfKind)
     817                                     PFNKLDRMODGETIMPORT pfnGetForwarder, void *pvUser, PKLDRADDR puValue, KU32 *pfKind)
    818818{
    819819    const IMAGE_IMPORT_DESCRIPTOR *paImpDir;
    820     uint32_t        iImpModule;
    821     uint32_t        cchImpModule;
     820    KU32            iImpModule;
     821    KU32            cchImpModule;
    822822    const char     *pszSymbol;
    823     uint32_t        iSymbol;
     823    KU32            iSymbol;
    824824    int             rc;
    825825
    … …  
    903903    {
    904904        const char *pszName = KLDRMODPE_RVA2TYPE(pvBits, paImpDir[iImpModule].Name, const char *);
    905         size_t      cchName = kLdrHlpStrLen(pszName);
     905        KSIZE       cchName = kLdrHlpStrLen(pszName);
    906906        if (    (   cchName == cchImpModule
    907907                 || (   cchName > cchImpModule
    … …  
    930930/** @copydoc kLdrModEnumSymbols */
    931931static int kldrModPEEnumSymbols(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress,
    932                                 uint32_t fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser)
     932                                KU32 fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser)
    933933{
    934934    PKLDRMODPE                      pModPE = (PKLDRMODPE)pMod->pvData;
    935     const uint32_t                 *paFunctions;
     935    const KU32                     *paFunctions;
    936936    const IMAGE_EXPORT_DIRECTORY   *pExpDir;
    937     const uint32_t                 *paRVANames;
    938     const uint16_t                 *paOrdinals;
    939     uint32_t                        iFunction;
    940     uint32_t                        cFunctions;
    941     uint32_t                        cNames;
     937    const KU32                     *paRVANames;
     938    const KU16                     *paOrdinals;
     939    KU32                            iFunction;
     940    KU32                            cFunctions;
     941    KU32                            cNames;
    942942    int                             rc;
    943943
    … …  
    960960     * Enumerate the ordinal exports.
    961961     */
    962     paRVANames = KLDRMODPE_RVA2TYPE(pvBits, pExpDir->AddressOfNames, const uint32_t *);
    963     paOrdinals = KLDRMODPE_RVA2TYPE(pvBits, pExpDir->AddressOfNameOrdinals, const uint16_t *);
    964     paFunctions = KLDRMODPE_RVA2TYPE(pvBits, pExpDir->AddressOfFunctions, const uint32_t *);
     962    paRVANames = KLDRMODPE_RVA2TYPE(pvBits, pExpDir->AddressOfNames, const KU32 *);
     963    paOrdinals = KLDRMODPE_RVA2TYPE(pvBits, pExpDir->AddressOfNameOrdinals, const KU16 *);
     964    paFunctions = KLDRMODPE_RVA2TYPE(pvBits, pExpDir->AddressOfFunctions, const KU32 *);
    965965    cFunctions = pExpDir->NumberOfFunctions;
    966966    cNames = pExpDir->NumberOfNames;
    … …  
    968968    {
    969969        unsigned        fFoundName;
    970         uint32_t        iName;
    971         const uint32_t  uRVA = paFunctions[iFunction];
     970        KU32            iName;
     971        const KU32      uRVA = paFunctions[iFunction];
    972972        const KLDRADDR  uValue = BaseAddress + uRVA;
    973         uint32_t        fKind = (pModPE->Hdrs.FileHeader.SizeOfOptionalHeader == sizeof(IMAGE_OPTIONAL_HEADER32)
     973        KU32            fKind = (pModPE->Hdrs.FileHeader.SizeOfOptionalHeader == sizeof(IMAGE_OPTIONAL_HEADER32)
    974974                              ? KLDRSYMKIND_32BIT : KLDRSYMKIND_64BIT)
    975975                              | KLDRSYMKIND_NO_TYPE;
    … …  
    10111011
    10121012/** @copydoc kLdrModGetImport */
    1013 static int kldrModPEGetImport(PKLDRMOD pMod, const void *pvBits, uint32_t iImport, char *pszName, size_t cchName)
     1013static int kldrModPEGetImport(PKLDRMOD pMod, const void *pvBits, KU32 iImport, char *pszName, KSIZE cchName)
    10141014{
    10151015    PKLDRMODPE                      pModPE = (PKLDRMODPE)pMod->pvData;
    10161016    const IMAGE_IMPORT_DESCRIPTOR  *pImpDesc;
    10171017    const char                     *pszImportName;
    1018     size_t                          cchImportName;
     1018    KSIZE                           cchImportName;
    10191019    int                             rc;
    10201020
    … …  
    10291029     * Simple bounds check.
    10301030     */
    1031     if (iImport >= (uint32_t)kldrModPENumberOfImports(pMod, pvBits))
     1031    if (iImport >= (KU32)kldrModPENumberOfImports(pMod, pvBits))
    10321032        return KLDR_ERR_IMPORT_ORDINAL_OUT_OF_BOUNDS;
    10331033
    … …  
    10591059
    10601060/** @copydoc kLdrModNumberOfImports */
    1061 static int32_t kldrModPENumberOfImports(PKLDRMOD pMod, const void *pvBits)
     1061static KI32 kldrModPENumberOfImports(PKLDRMOD pMod, const void *pvBits)
    10621062{
    10631063    PKLDRMODPE pModPE = (PKLDRMODPE)pMod->pvData;
    1064     if (pModPE->cImportModules == ~(uint32_t)0)
     1064    if (pModPE->cImportModules == ~(KU32)0)
    10651065    {
    10661066        /*
    … …  
    11311131    PKLDRMODPE                      pModPE = (PKLDRMODPE)pMod->pvData;
    11321132    const IMAGE_DEBUG_DIRECTORY    *pDbgDir;
    1133     uint32_t                        iDbgInfo;
    1134     uint32_t                        cb;
     1133    KU32                            iDbgInfo;
     1134    KU32                            cb;
    11351135    int                             rc;
    11361136
    … …  
    13421342     * Apply base relocations.
    13431343     */
    1344     rc = kldrModPEDoFixups(pModPE, (void *)pModPE->pvMapping, (uintptr_t)pModPE->pvMapping,
     1344    rc = kldrModPEDoFixups(pModPE, (void *)pModPE->pvMapping, (KUPTR)pModPE->pvMapping,
    13451345                           pModPE->Hdrs.OptionalHeader.ImageBase);
    13461346
    … …  
    13731373{
    13741374    const KLDRADDR                  Delta = NewBaseAddress - OldBaseAddress;
    1375     uint32_t                        cbLeft = pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size;
     1375    KU32                            cbLeft = pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size;
    13761376    const IMAGE_BASE_RELOCATION    *pBR, *pFirstBR;
    13771377
    … …  
    13961396        union
    13971397        {
    1398             uint8_t    *pu8;
    1399             uint16_t   *pu16;
    1400             uint32_t   *pu32;
    1401             uint64_t   *pu64;
     1398            KU8        *pu8;
     1399            KU16       *pu16;
     1400            KU32       *pu32;
     1401            KU64       *pu64;
    14021402        }               uChunk,
    14031403                        u;
    1404         const uint16_t *poffFixup = (const uint16_t *)(pBR + 1);
    1405         const uint32_t  cbBlock = KLDR_MIN(cbLeft, pBR->SizeOfBlock) - sizeof(IMAGE_BASE_RELOCATION); /* more caution... */
    1406         uint32_t        cFixups = cbBlock / sizeof(poffFixup[0]);
    1407         uChunk.pu8 = KLDRMODPE_RVA2TYPE(pvMapping, pBR->VirtualAddress, uint8_t *);
     1404        const KU16 *poffFixup = (const KU16 *)(pBR + 1);
     1405        const KU32  cbBlock = KLDR_MIN(cbLeft, pBR->SizeOfBlock) - sizeof(IMAGE_BASE_RELOCATION); /* more caution... */
     1406        KU32        cFixups = cbBlock / sizeof(poffFixup[0]);
     1407        uChunk.pu8 = KLDRMODPE_RVA2TYPE(pvMapping, pBR->VirtualAddress, KU8 *);
    14081408
    14091409        /*
    … …  
    14211421                /* 1 - 16-bit, add 2nd 16-bit part of the delta. (rare) */
    14221422                case IMAGE_REL_BASED_HIGH:
    1423                     *u.pu16 += (uint16_t)(Delta >> 16);
     1423                    *u.pu16 += (KU16)(Delta >> 16);
    14241424                    break;
    14251425
    14261426                /* 2 - 16-bit, add 1st 16-bit part of the delta. (rare) */
    14271427                case IMAGE_REL_BASED_LOW:
    1428                     *u.pu16 += (uint16_t)Delta;
     1428                    *u.pu16 += (KU16)Delta;
    14291429                    break;
    14301430
    14311431                /* 3 - 32-bit, add delta. (frequent in 32-bit images) */
    14321432                case IMAGE_REL_BASED_HIGHLOW:
    1433                     *u.pu32 += (uint32_t)Delta;
     1433                    *u.pu32 += (KU32)Delta;
    14341434                    break;
    14351435
    … …  
    14371437                case IMAGE_REL_BASED_HIGHADJ:
    14381438                {
    1439                     int32_t i32;
     1439                    KI32 i32;
    14401440                    if (cFixups <= 1)
    14411441                        return KLDR_ERR_PE_BAD_FIXUP;
    14421442
    1443                     i32 = (uint32_t)*u.pu16 << 16;
     1443                    i32 = (KU32)*u.pu16 << 16;
    14441444                    i32 |= *++poffFixup; cFixups--; /* the addend argument */
    1445                     i32 += (uint32_t)Delta;
     1445                    i32 += (KU32)Delta;
    14461446                    i32 += 0x8000;
    1447                     *u.pu16 = (uint16_t)(i32 >> 16);
     1447                    *u.pu16 = (KU16)(i32 >> 16);
    14481448                    break;
    14491449                }
    … …  
    14521452                case IMAGE_REL_BASED_MIPS_JMPADDR:
    14531453                    *u.pu32 = (*u.pu32 & 0xc0000000)
    1454                             | ((uint32_t)((*u.pu32 << 2) + (uint32_t)Delta) >> 2);
     1454                            | ((KU32)((*u.pu32 << 2) + (KU32)Delta) >> 2);
    14551455                    break;
    14561456
    … …  
    14781478                /* 10 - 64-bit, add delta. (frequently in 64-bit images) */
    14791479                case IMAGE_REL_BASED_DIR64:
    1480                     *u.pu64 += (uint64_t)Delta;
     1480                    *u.pu64 += (KU64)Delta;
    14811481                    break;
    14821482
    … …  
    14841484                case IMAGE_REL_BASED_HIGH3ADJ:
    14851485                {
    1486                     int64_t i64;
     1486                    KI64 i64;
    14871487                    if (cFixups <= 2)
    14881488                        return KLDR_ERR_PE_BAD_FIXUP;
    14891489
    1490                     i64 = (uint64_t)*u.pu16 << 32
    1491                         | ((uint32_t)poffFixup[2] << 16)
     1490                    i64 = (KU64)*u.pu16 << 32
     1491                        | ((KU32)poffFixup[2] << 16)
    14921492                        | poffFixup[1];
    14931493                    i64 += Delta;
    14941494                    i64 += 0x80008000UL;
    1495                     *u.pu16 = (uint16_t)(i64 >> 32);
     1495                    *u.pu16 = (KU16)(i64 >> 32);
    14961496                    /* skip the addends arguments */
    14971497                    poffFixup += 2;
    … …  
    15171517         */
    15181518        cbLeft -= pBR->SizeOfBlock;
    1519         pBR = (PIMAGE_BASE_RELOCATION)((uintptr_t)pBR + pBR->SizeOfBlock);
     1519        pBR = (PIMAGE_BASE_RELOCATION)((KUPTR)pBR + pBR->SizeOfBlock);
    15201520    }
    15211521
    … …  
    15681568{
    15691569    PKLDRMOD pMod = pModPE->pMod;
    1570     uint32_t iImp;
     1570    KU32 iImp;
    15711571
    15721572    /*
    … …  
    15841584        {
    15851585            KLDRADDR    Value;
    1586             uint32_t    fKind = KLDRSYMKIND_REQ_FLAT;
     1586            KU32        fKind = KLDRSYMKIND_REQ_FLAT;
    15871587            int         rc;
    15881588
    … …  
    16051605
    16061606            /* Apply it. */
    1607             pFirstThunk->u1.Function = (uint32_t)Value;
     1607            pFirstThunk->u1.Function = (KU32)Value;
    16081608            if (pFirstThunk->u1.Function != Value)
    16091609            {
    … …  
    16361636{
    16371637    PKLDRMOD pMod = pModPE->pMod;
    1638     uint32_t iImp;
     1638    KU32 iImp;
    16391639
    16401640    /*
    … …  
    16521652        {
    16531653            KLDRADDR    Value;
    1654             uint32_t    fKind = KLDRSYMKIND_REQ_FLAT;
     1654            KU32        fKind = KLDRSYMKIND_REQ_FLAT;
    16551655            int         rc;
    16561656
    16571657            /* Ordinal or name import? */
    16581658            if (IMAGE_SNAP_BY_ORDINAL64(pThunk->u1.Ordinal))
    1659                 rc = pfnGetImport(pMod, iImp, (uint32_t)IMAGE_ORDINAL64(pThunk->u1.Ordinal), NULL, 0, NULL, &Value, &fKind, pvUser);
     1659                rc = pfnGetImport(pMod, iImp, (KU32)IMAGE_ORDINAL64(pThunk->u1.Ordinal), NULL, 0, NULL, &Value, &fKind, pvUser);
    16601660            else if (KLDRMODPE_VALID_RVA(pModPE, pThunk->u1.Ordinal))
    16611661            {
    … …  
    16871687
    16881688/** @copydoc kLdrModCallInit */
    1689 static int kldrModPECallInit(PKLDRMOD pMod, uintptr_t uHandle)
     1689static int kldrModPECallInit(PKLDRMOD pMod, KUPTR uHandle)
    16901690{
    16911691    PKLDRMODPE pModPE = (PKLDRMODPE)pMod->pvData;
    … …  
    17231723 * @param   uHandle         The module handle to present.
    17241724 */
    1725 static int  kldrModPEDoCallDLL(PKLDRMODPE pModPE, unsigned uOp, uintptr_t uHandle)
     1725static int  kldrModPEDoCallDLL(PKLDRMODPE pModPE, unsigned uOp, KUPTR uHandle)
    17261726{
    17271727    int rc;
    … …  
    17361736     * Invoke the entrypoint and convert the boolean result to a kLdr status code.
    17371737     */
    1738     rc = kldrModPEDoCall((uintptr_t)pModPE->pvMapping + pModPE->Hdrs.OptionalHeader.AddressOfEntryPoint,
     1738    rc = kldrModPEDoCall((KUPTR)pModPE->pvMapping + pModPE->Hdrs.OptionalHeader.AddressOfEntryPoint,
    17391739                         uHandle, uOp, NULL);
    17401740    if (rc)
    … …  
    17591759 * @param   uHandle         The module handle to present.
    17601760 */
    1761 static int  kldrModPEDoCallTLS(PKLDRMODPE pModPE, unsigned uOp, uintptr_t uHandle)
     1761static int  kldrModPEDoCallTLS(PKLDRMODPE pModPE, unsigned uOp, KUPTR uHandle)
    17621762{
    17631763    /** @todo implement TLS support. */
    … …  
    17751775 * @param   pvReserved      The third argument, reserved argument. (figure this one out)
    17761776 */
    1777 static int32_t kldrModPEDoCall(uintptr_t uEntrypoint, uintptr_t uHandle, uint32_t uOp, void *pvReserved)
    1778 {
    1779     int32_t rc;
     1777static KI32 kldrModPEDoCall(KUPTR uEntrypoint, KUPTR uHandle, KU32 uOp, void *pvReserved)
     1778{
     1779    KI32 rc;
    17801780
    17811781/** @todo try/except */
    … …  
    18231823     */
    18241824    /** @todo Deal with GCC / MSC differences in some sensible way. */
    1825     int (*pfn)(uintptr_t uHandle, uint32_t uOp, void *pvReserved);
    1826     pfn = (int (*)(uintptr_t uHandle, uint32_t uOp, void *pvReserved))uEntrypoint;
     1825    int (*pfn)(KUPTR uHandle, KU32 uOp, void *pvReserved);
     1826    pfn = (int (*)(KUPTR uHandle, KU32 uOp, void *pvReserved))uEntrypoint;
    18271827    rc = pfn(uHandle, uOp, NULL);
    18281828
    … …  
    18361836
    18371837/** @copydoc kLdrModCallTerm */
    1838 static int kldrModPECallTerm(PKLDRMOD pMod, uintptr_t uHandle)
     1838static int kldrModPECallTerm(PKLDRMOD pMod, KUPTR uHandle)
    18391839{
    18401840    PKLDRMODPE  pModPE = (PKLDRMODPE)pMod->pvData;
    … …  
    18581858
    18591859/** @copydoc kLdrModCallThread */
    1860 static int kldrModPECallThread(PKLDRMOD pMod, uintptr_t uHandle, unsigned fAttachingOrDetaching)
     1860static int kldrModPECallThread(PKLDRMOD pMod, KUPTR uHandle, unsigned fAttachingOrDetaching)
    18611861{
    18621862    PKLDRMODPE  pModPE = (PKLDRMODPE)pMod->pvData;
    … …  
    18961896{
    18971897    PKLDRMODPE  pModPE = (PKLDRMODPE)pMod->pvData;
    1898     uint32_t    i;
     1898    KU32        i;
    18991899    int         rc;
    19001900
    … …  
    19161916            continue;
    19171917        rc = kLdrRdrRead(pMod->pRdr,
    1918                          (uint8_t *)pvBits + (pMod->aSegments[i].LinkAddress - pModPE->Hdrs.OptionalHeader.ImageBase),
     1918                         (KU8 *)pvBits + (pMod->aSegments[i].LinkAddress - pModPE->Hdrs.OptionalHeader.ImageBase),
    19191919                         pMod->aSegments[i].cbFile,
    19201920                         pMod->aSegments[i].offFile);
Note: See TracChangeset for help on using the changeset viewer.