Changeset 3567 for trunk


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

Use the new type system.

Location:
trunk/kStuff/kLdr
Files:
29 edited

Legend:

Unmodified
Added
Removed

  • trunk/kStuff/kLdr/Makefile.kmk

    r3537 r3567  
    6666 TEMPLATE_TST_LDFLAGS =
    6767endif
    68 TEMPLATE_TST_INCS = .
     68TEMPLATE_TST_INCS = . ../include
    6969
    7070
    … …  
    112112 kLdr_LDFLAGS = -nostdlib
    113113endif
    114 kLdr_INCS = .
     114kLdr_INCS = . ../include
    115115kLdr_SOURCES = \
    116116        kLdr.c \
    … …  
    152152kLdrStatic_TEMPLATE = kStuffLIB
    153153kLdrStatic_SDKS.win = WINPSDK W2K3DDK
    154 kLdrStatic_INCS = .
     154kLdrStatic_INCS = . ../include
    155155kLdrStatic_DEFS.win = __WIN__
    156156kLdrStatic_DEFS.os2 = __OS2__
    … …  
    179179kLdrExeStub-win_SDKS.x86 = WIN32SDK
    180180kLdrExeStub-win_SDKS.amd64 = WIN64SDK
    181 kLdrExeStub-win_INCS = .
     181kLdrExeStub-win_INCS = . ../include
    182182kLdrExeStub-win_DEFS = __WIN__
    183183kLdrExeStub-win_CFLAGS = -W3 -Zl

  • trunk/kStuff/kLdr/kLdr.h

    r3537 r3567  
    4242
    4343/** The kLdr address type. */
    44 typedef uint64_t KLDRADDR;
     44typedef KU64 KLDRADDR;
    4545/** Pointer to a kLdr address. */
    4646typedef KLDRADDR *PKLDRADDR;
    … …  
    4949
    5050/** NIL address. */
    51 #define NIL_KLDRADDR    (~(uint64_t)0)
     51#define NIL_KLDRADDR    (~(KU64)0)
    5252
    5353/** @def PRI_KLDRADDR
    … …  
    6161
    6262/** The kLdr size type. */
    63 typedef uint64_t KLDRSIZE;
     63typedef KU64 KLDRSIZE;
    6464/** Pointer to a kLdr size. */
    6565typedef KLDRSIZE *PKLDRSIZE;
    … …  
    9393typedef union KLDRU
    9494{
    95     int8_t          i8;     /**< int8_t view. */
    96     uint8_t         u8;     /**< uint8_t view. */
    97     int16_t         i16;    /**< int16_t view. */
    98     uint16_t        u16;    /**< uint16_t view. */
    99     int32_t         i32;    /**< int32_t view. */
    100     uint32_t        u32;    /**< uint32_t view. */
    101     int64_t         i64;    /**< int64_t view. */
    102     uint64_t        u64;    /**< uint64_t view. */
    103 
    104     int8_t          ai8[8]; /**< int8_t array view . */
    105     uint8_t         au8[8]; /**< uint8_t array view. */
    106     int16_t         ai16[4];/**< int16_t array view . */
    107     uint16_t        au16[4];/**< uint16_t array view. */
    108     int32_t         ai32[2];/**< int32_t array view . */
    109     uint32_t        au32[2];/**< uint32_t array view. */
     95    KI8             i8;     /**< KI8 view. */
     96    KU8             u8;     /**< KU8 view. */
     97    KI16            i16;    /**< KI16 view. */
     98    KU16            u16;    /**< KU16 view. */
     99    KI32            i32;    /**< KI32 view. */
     100    KU32            u32;    /**< KU32 view. */
     101    KI64            i64;    /**< KI64 view. */
     102    KU64            u64;    /**< KU64 view. */
     103
     104    KI8             ai8[8]; /**< KI8 array view . */
     105    KU8             au8[8]; /**< KU8 array view. */
     106    KI16            ai16[4];/**< KI16 array view . */
     107    KU16            au16[4];/**< KU16 array view. */
     108    KI32            ai32[2];/**< KI32 array view . */
     109    KU32            au32[2];/**< KU32 array view. */
    110110
    111111    signed char     ch;     /**< signed char view. */
    … …  
    133133typedef union KLDRPU
    134134{
    135     int8_t         *pi8;    /**< int8_t view. */
    136     uint8_t        *pu8;    /**< uint8_t view. */
    137     int16_t        *pi16;   /**< int16_t view. */
    138     uint16_t       *pu16;   /**< uint16_t view. */
    139     int32_t        *pi32;   /**< int32_t view. */
    140     uint32_t       *pu32;   /**< uint32_t view. */
    141     int64_t        *pi64;   /**< int64_t view. */
    142     uint64_t       *pu64;   /**< uint64_t view. */
     135    KI8            *pi8;    /**< KI8 view. */
     136    KU8            *pu8;    /**< KU8 view. */
     137    KI16           *pi16;   /**< KI16 view. */
     138    KU16           *pu16;   /**< KU16 view. */
     139    KI32           *pi32;   /**< KI32 view. */
     140    KU32           *pu32;   /**< KU32 view. */
     141    KI64           *pi64;   /**< KI64 view. */
     142    KU64           *pu64;   /**< KU64 view. */
    143143
    144144    signed char    *pch;    /**< signed char view. */
    … …  
    232232    int     (* pfnDestroy)( PKLDRRDR pRdr);
    233233    /** @copydoc kLdrRdrRead */
    234     int     (* pfnRead)(    PKLDRRDR pRdr, void *pvBuf, size_t cb, KLDRFOFF off);
     234    int     (* pfnRead)(    PKLDRRDR pRdr, void *pvBuf, KSIZE cb, KLDRFOFF off);
    235235    /** @copydoc kLdrRdrAllMap */
    236236    int     (* pfnAllMap)(  PKLDRRDR pRdr, const void **ppvBits);
    … …  
    244244    const char * (* pfnName)(PKLDRRDR pRdr);
    245245    /** @copydoc kLdrRdrPageSize */
    246     size_t  (* pfnPageSize)(PKLDRRDR pRdr);
     246    KSIZE   (* pfnPageSize)(PKLDRRDR pRdr);
    247247    /** @copydoc kLdrRdrMap */
    248     int     (* pfnMap)(     PKLDRRDR pRdr, void **ppvBase, uint32_t cSegments, PCKLDRSEG paSegments, unsigned fFixed);
     248    int     (* pfnMap)(     PKLDRRDR pRdr, void **ppvBase, KU32 cSegments, PCKLDRSEG paSegments, unsigned fFixed);
    249249    /** @copydoc kLdrRdrRefresh */
    250     int     (* pfnRefresh)( PKLDRRDR pRdr, void *pvBase, uint32_t cSegments, PCKLDRSEG paSegments);
     250    int     (* pfnRefresh)( PKLDRRDR pRdr, void *pvBase, KU32 cSegments, PCKLDRSEG paSegments);
    251251    /** @copydoc kLdrRdrProtect */
    252     int     (* pfnProtect)( PKLDRRDR pRdr, void *pvBase, uint32_t cSegments, PCKLDRSEG paSegments, unsigned fUnprotectOrProtect);
     252    int     (* pfnProtect)( PKLDRRDR pRdr, void *pvBase, KU32 cSegments, PCKLDRSEG paSegments, unsigned fUnprotectOrProtect);
    253253    /** @copydoc kLdrRdrUnmap */
    254     int     (* pfnUnmap)(   PKLDRRDR pRdr, void *pvBase, uint32_t cSegments, PCKLDRSEG paSegments);
     254    int     (* pfnUnmap)(   PKLDRRDR pRdr, void *pvBase, KU32 cSegments, PCKLDRSEG paSegments);
    255255    /** @copydoc kLdrRdrDone */
    256256    void    (* pfnDone)(    PKLDRRDR pRdr);
    257257    /** The usual non-zero dummy that makes sure we've initialized all members. */
    258     uint32_t u32Dummy;
     258    KU32 u32Dummy;
    259259} KLDRRDROPS;
    260260/** Pointer to file provider operations. */
    … …  
    270270{
    271271    /** Magic number (KLDRRDR_MAGIC). */
    272     uint32_t     u32Magic;
     272    KU32         u32Magic;
    273273    /** Pointer to the file provider operations. */
    274274    PCKLDRRDROPS pOps;
    … …  
    282282int     kLdrRdrOpen(    PPKLDRRDR ppRdr, const char *pszFilename);
    283283int     kLdrRdrClose(   PKLDRRDR pRdr);
    284 int     kLdrRdrRead(    PKLDRRDR pRdr, void *pvBuf, size_t cb, KLDRFOFF off);
     284int     kLdrRdrRead(    PKLDRRDR pRdr, void *pvBuf, KSIZE cb, KLDRFOFF off);
    285285int     kLdrRdrAllMap(  PKLDRRDR pRdr, const void **ppvBits);
    286286int     kLdrRdrAllUnmap(PKLDRRDR pRdr, const void *pvBits);
    … …  
    288288KLDRFOFF kLdrRdrTell(    PKLDRRDR pRdr);
    289289const char *kLdrRdrName(PKLDRRDR pRdr);
    290 size_t  kLdrRdrPageSize(PKLDRRDR pRdr);
    291 int     kLdrRdrMap(     PKLDRRDR pRdr, void **ppvBase, uint32_t cSegments, PCKLDRSEG paSegments, unsigned fFixed);
    292 int     kLdrRdrRefresh( PKLDRRDR pRdr, void *pvBase, uint32_t cSegments, PCKLDRSEG paSegments);
    293 int     kLdrRdrProtect( PKLDRRDR pRdr, void *pvBase, uint32_t cSegments, PCKLDRSEG paSegments, unsigned fUnprotectOrProtect);
    294 int     kLdrRdrUnmap(   PKLDRRDR pRdr, void *pvBase, uint32_t cSegments, PCKLDRSEG paSegments);
     290KSIZE   kLdrRdrPageSize(PKLDRRDR pRdr);
     291int     kLdrRdrMap(     PKLDRRDR pRdr, void **ppvBase, KU32 cSegments, PCKLDRSEG paSegments, unsigned fFixed);
     292int     kLdrRdrRefresh( PKLDRRDR pRdr, void *pvBase, KU32 cSegments, PCKLDRSEG paSegments);
     293int     kLdrRdrProtect( PKLDRRDR pRdr, void *pvBase, KU32 cSegments, PCKLDRSEG paSegments, unsigned fUnprotectOrProtect);
     294int     kLdrRdrUnmap(   PKLDRRDR pRdr, void *pvBase, KU32 cSegments, PCKLDRSEG paSegments);
    295295void    kLdrRdrDone(    PKLDRRDR pRdr);
    296296
    … …  
    475475    const char     *pchName;
    476476    /** The length of the segment name. */
    477     uint32_t        cchName;
     477    KU32            cchName;
    478478    /** The flat selector to use for the segment (i.e. data/code).
    479479     * Primarily a way for the user to specify selectors for the LX/LE and NE interpreters. */
    480     uint16_t        SelFlat;
     480    KU16            SelFlat;
    481481    /** The 16-bit selector to use for the segment.
    482482     * Primarily a way for the user to specify selectors for the LX/LE and NE interpreters. */
    483     uint16_t        Sel16bit;
     483    KU16            Sel16bit;
    484484    /** Segment flags. */
    485     uint32_t        fFlags;
     485    KU32            fFlags;
    486486    /** The segment protection. */
    487487    KLDRPROT        enmProt;
    … …  
    505505    KLDRADDR        RVA;
    506506    /** The size of the segment including the alignment gap up to the next segment when mapped. */
    507     size_t          cbMapped;
     507    KSIZE           cbMapped;
    508508    /** The address the segment was mapped at by kLdrModMap().
    509509     * Set to 0 if not mapped. */
    510     uintptr_t       MapAddress;
     510    KUPTR           MapAddress;
    511511} KLDRSEG;
    512512
    … …  
    616616{
    617617    /** Magic number (KLDRMOD_MAGIC). */
    618     uint32_t            u32Magic;
     618    KU32                u32Magic;
    619619    /** The format of this module. */
    620620    KLDRFMT             enmFmt;
    … …  
    629629    KLDRENDIAN          enmEndian;
    630630    /** The filename length (bytes). */
    631     uint32_t            cchFilename;
     631    KU32                cchFilename;
    632632    /** The filename. */
    633633    const char         *pszFilename;
    … …  
    635635    const char         *pszName;
    636636    /** The module name length (bytes). */
    637     uint32_t            cchName;
     637    KU32                cchName;
    638638    /** The number of segments in the module. */
    639     uint32_t            cSegments;
     639    KU32                cSegments;
    640640    /** Pointer to the loader methods.
    641641     * Not meant for calling directly thru! */
    … …  
    660660/** Special import module ordinal value used to indicate that there is no
    661661 * specific module associated with the requested symbol. */
    662 #define NIL_KLDRMOD_IMPORT                  (~(uint32_t)0)
     662#define NIL_KLDRMOD_IMPORT                  (~(KU32)0)
    663663
    664664/** Special symbol ordinal value used to indicate that the symbol
    665665 * only has a string name. */
    666 #define NIL_KLDRMOD_SYM_ORDINAL             (~(uint32_t)0)
     666#define NIL_KLDRMOD_SYM_ORDINAL             (~(KU32)0)
    667667
    668668
    … …  
    724724 * @param   pvUser      The user parameter specified to the relocation function.
    725725 */
    726 typedef int FNKLDRMODGETIMPORT(PKLDRMOD pMod, uint32_t iImport, uint32_t iSymbol, const char *pchSymbol, size_t cchSymbol,
    727                                const char *pszVersion, PKLDRADDR puValue, uint32_t *pfKind, void *pvUser);
     726typedef int FNKLDRMODGETIMPORT(PKLDRMOD pMod, KU32 iImport, KU32 iSymbol, const char *pchSymbol, KSIZE cchSymbol,
     727                               const char *pszVersion, PKLDRADDR puValue, KU32 *pfKind, void *pvUser);
    728728/** Pointer to a import callback. */
    729729typedef FNKLDRMODGETIMPORT *PFNKLDRMODGETIMPORT;
    … …  
    747747 * @param   pvUser      The user parameter specified to kLdrModEnumSymbols().
    748748 */
    749 typedef int FNKLDRMODENUMSYMS(PKLDRMOD pMod, uint32_t iSymbol, const char *pchSymbol, size_t cchSymbol, const char *pszVersion,
    750                               KLDRADDR uValue, uint32_t fKind, void *pvUser);
     749typedef int FNKLDRMODENUMSYMS(PKLDRMOD pMod, KU32 iSymbol, const char *pchSymbol, KSIZE cchSymbol, const char *pszVersion,
     750                              KLDRADDR uValue, KU32 fKind, void *pvUser);
    751751/** Pointer to a symbol enumerator callback. */
    752752typedef FNKLDRMODENUMSYMS *PFNKLDRMODENUMSYMS;
    … …  
    771771 * @param   pvUser      The user parameter specified to kLdrModEnumDbgInfo.
    772772 */
    773 typedef int FNKLDRENUMDBG(PKLDRMOD pMod, uint32_t iDbgInfo, KLDRDBGINFOTYPE enmType, int16_t iMajorVer, int16_t iMinorVer,
     773typedef int FNKLDRENUMDBG(PKLDRMOD pMod, KU32 iDbgInfo, KLDRDBGINFOTYPE enmType, KI16 iMajorVer, KI16 iMinorVer,
    774774                          KLDRFOFF offFile, KLDRADDR LinkAddress, KLDRSIZE cb, const char *pszExtFile, void *pvUser);
    775775/** Pointer to a debug info enumerator callback. */
    … …  
    792792 * @param   pvUser      The user parameter specified to kLdrModEnumDbgInfo.
    793793 */
    794 typedef int FNKLDRENUMRSRC(PKLDRMOD pMod, uint32_t idType, const char *pszType, uint32_t idName, const char *pszName,
    795                            uint32_t idLang, KLDRADDR AddrRsrc, KLDRSIZE cbRsrc, void *pvUser);
     794typedef int FNKLDRENUMRSRC(PKLDRMOD pMod, KU32 idType, const char *pszType, KU32 idName, const char *pszName,
     795                           KU32 idLang, KLDRADDR AddrRsrc, KLDRSIZE cbRsrc, void *pvUser);
    796796/** Pointer to a resource enumerator callback. */
    797797typedef FNKLDRENUMRSRC *PFNKLDRENUMRSRC;
    798798
    799799/** NIL resource name ID. */
    800 #define NIL_KLDRMOD_RSRC_NAME_ID    ( ~(uint32_t)0 )
     800#define NIL_KLDRMOD_RSRC_NAME_ID    ( ~(KU32)0 )
    801801/** NIL resource type ID. */
    802 #define NIL_KLDRMOD_RSRC_TYPE_ID    ( ~(uint32_t)0 )
     802#define NIL_KLDRMOD_RSRC_TYPE_ID    ( ~(KU32)0 )
    803803/** @name Language ID
    804804 *
    … …  
    808808 * @{ */
    809809/** NIL language ID. */
    810 #define NIL_KLDR_LANG_ID                ( ~(uint32_t)0 )
     810#define NIL_KLDR_LANG_ID                ( ~(KU32)0 )
    811811/** Special language id value for matching any language. */
    812 #define KLDR_LANG_ID_ANY                ( ~(uint32_t)1 )
     812#define KLDR_LANG_ID_ANY                ( ~(KU32)1 )
    813813/** Special language id value indicating language neutral. */
    814 #define KLDR_LANG_ID_NEUTRAL            ( ~(uint32_t)2 )
     814#define KLDR_LANG_ID_NEUTRAL            ( ~(KU32)2 )
    815815/** Special language id value indicating user default language. */
    816 #define KLDR_LANG_ID_USER_DEFAULT       ( ~(uint32_t)3 )
     816#define KLDR_LANG_ID_USER_DEFAULT       ( ~(KU32)3 )
    817817/** Special language id value indicating system default language. */
    818 #define KLDR_LANG_ID_SYS_DEFAULT        ( ~(uint32_t)4 )
     818#define KLDR_LANG_ID_SYS_DEFAULT        ( ~(KU32)4 )
    819819/** Special language id value indicating default custom locale. */
    820 #define KLDR_LANG_ID_CUSTOM_DEFAULT     ( ~(uint32_t)5 )
     820#define KLDR_LANG_ID_CUSTOM_DEFAULT     ( ~(KU32)5 )
    821821/** Special language id value indicating unspecified custom locale. */
    822 #define KLDR_LANG_ID_CUSTOM_UNSPECIFIED ( ~(uint32_t)6 )
     822#define KLDR_LANG_ID_CUSTOM_UNSPECIFIED ( ~(KU32)6 )
    823823/** Special language id value indicating default custom MUI locale. */
    824 #define KLDR_LANG_ID_UI_CUSTOM_DEFAULT  ( ~(uint32_t)7 )
     824#define KLDR_LANG_ID_UI_CUSTOM_DEFAULT  ( ~(KU32)7 )
    825825/** @} */
    826826
    … …  
    829829int     kLdrModOpenFromRdr(PKLDRRDR pRdr, PPKLDRMOD ppMod);
    830830int     kLdrModOpenNative(const char *pszFilename, PPKLDRMOD ppMod);
    831 int     kLdrModOpenNativeByHandle(uintptr_t uHandle, PPKLDRMOD ppMod);
     831int     kLdrModOpenNativeByHandle(KUPTR uHandle, PPKLDRMOD ppMod);
    832832int     kLdrModClose(PKLDRMOD pMod);
    833833
    834 int     kLdrModQuerySymbol(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, uint32_t iSymbol,
    835                            const char *pchSymbol, size_t cchSymbol, const char *pszVersion,
    836                            PFNKLDRMODGETIMPORT pfnGetForwarder, void *pvUser, PKLDRADDR puValue, uint32_t *pfKind);
     834int     kLdrModQuerySymbol(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, KU32 iSymbol,
     835                           const char *pchSymbol, KSIZE cchSymbol, const char *pszVersion,
     836                           PFNKLDRMODGETIMPORT pfnGetForwarder, void *pvUser, PKLDRADDR puValue, KU32 *pfKind);
    837837int     kLdrModEnumSymbols(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress,
    838                            uint32_t fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser);
    839 int     kLdrModGetImport(PKLDRMOD pMod, const void *pvBits, uint32_t iImport, char *pszName, size_t cchName);
    840 int32_t kLdrModNumberOfImports(PKLDRMOD pMod, const void *pvBits);
     838                           KU32 fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser);
     839int     kLdrModGetImport(PKLDRMOD pMod, const void *pvBits, KU32 iImport, char *pszName, KSIZE cchName);
     840KI32    kLdrModNumberOfImports(PKLDRMOD pMod, const void *pvBits);
    841841int     kLdrModCanExecuteOn(PKLDRMOD pMod, const void *pvBits, KLDRARCH enmArch, KLDRCPU enmCpu);
    842842int     kLdrModGetStackInfo(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, PKLDRSTACKINFO pStackInfo);
    843843int     kLdrModQueryMainEntrypoint(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, PKLDRADDR pMainEPAddress);
    844 int     kLdrModQueryResource(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, uint32_t idType, const char *pszType,
    845                              uint32_t idName, const char *pszName, uint32_t idLang, PKLDRADDR pAddrRsrc, size_t *pcbRsrc);
    846 int     kLdrModEnumResources(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, uint32_t idType, const char *pszType,
    847                              uint32_t idName, const char *pszName, uint32_t idLang, PFNKLDRENUMRSRC pfnCallback, void *pvUser);
     844int     kLdrModQueryResource(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, KU32 idType, const char *pszType,
     845                             KU32 idName, const char *pszName, KU32 idLang, PKLDRADDR pAddrRsrc, KSIZE *pcbRsrc);
     846int     kLdrModEnumResources(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, KU32 idType, const char *pszType,
     847                             KU32 idName, const char *pszName, KU32 idLang, PFNKLDRENUMRSRC pfnCallback, void *pvUser);
    848848int     kLdrModEnumDbgInfo(PKLDRMOD pMod, const void *pvBits, PFNKLDRENUMDBG pfnCallback, void *pvUser);
    849849int     kLdrModHasDbgInfo(PKLDRMOD pMod, const void *pvBits);
    … …  
    859859int     kLdrModReload(PKLDRMOD pMod);
    860860int     kLdrModFixupMapping(PKLDRMOD pMod, PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
    861 int     kLdrModCallInit(PKLDRMOD pMod, uintptr_t uHandle);
    862 int     kLdrModCallTerm(PKLDRMOD pMod, uintptr_t uHandle);
    863 int     kLdrModCallThread(PKLDRMOD pMod, uintptr_t uHandle, unsigned fAttachingOrDetaching);
     861int     kLdrModCallInit(PKLDRMOD pMod, KUPTR uHandle);
     862int     kLdrModCallTerm(PKLDRMOD pMod, KUPTR uHandle);
     863int     kLdrModCallThread(PKLDRMOD pMod, KUPTR uHandle, unsigned fAttachingOrDetaching);
    864864/** @} */
    865865
    … …  
    907907
    908908    /** @copydoc kLdrModQuerySymbol */
    909     int (* pfnQuerySymbol)(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, uint32_t iSymbol,
    910                            const char *pchSymbol, size_t cchSymbol, const char *pszVersion,
    911                            PFNKLDRMODGETIMPORT pfnGetForwarder, void *pvUser, PKLDRADDR puValue, uint32_t *pfKind);
     909    int (* pfnQuerySymbol)(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, KU32 iSymbol,
     910                           const char *pchSymbol, KSIZE cchSymbol, const char *pszVersion,
     911                           PFNKLDRMODGETIMPORT pfnGetForwarder, void *pvUser, PKLDRADDR puValue, KU32 *pfKind);
    912912    /** @copydoc kLdrModEnumSymbols */
    913     int (* pfnEnumSymbols)(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, uint32_t fFlags,
     913    int (* pfnEnumSymbols)(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, KU32 fFlags,
    914914                           PFNKLDRMODENUMSYMS pfnCallback, void *pvUser);
    915915    /** @copydoc kLdrModGetImport */
    916     int (* pfnGetImport)(PKLDRMOD pMod, const void *pvBits, uint32_t iImport, char *pszName, size_t cchName);
     916    int (* pfnGetImport)(PKLDRMOD pMod, const void *pvBits, KU32 iImport, char *pszName, KSIZE cchName);
    917917    /** @copydoc kLdrModNumberOfImports */
    918     int32_t (* pfnNumberOfImports)(PKLDRMOD pMod, const void *pvBits);
     918    KI32 (* pfnNumberOfImports)(PKLDRMOD pMod, const void *pvBits);
    919919    /** @copydoc kLdrModCanExecuteOn */
    920920    int (* pfnCanExecuteOn)(PKLDRMOD pMod, const void *pvBits, KLDRARCH enmArch, KLDRCPU enmCpu);
    … …  
    924924    int (* pfnQueryMainEntrypoint)(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, PKLDRADDR pMainEPAddress);
    925925    /** @copydoc kLdrModQueryResource */
    926     int (* pfnQueryResource)(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, uint32_t idType, const char *pszType,
    927                              uint32_t idName, const char *pszName, uint32_t idLang, PKLDRADDR pAddrRsrc, size_t *pcbRsrc);
     926    int (* pfnQueryResource)(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, KU32 idType, const char *pszType,
     927                             KU32 idName, const char *pszName, KU32 idLang, PKLDRADDR pAddrRsrc, KSIZE *pcbRsrc);
    928928    /** @copydoc kLdrModEnumResources */
    929     int (* pfnEnumResources)(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, uint32_t idType, const char *pszType,
    930                              uint32_t idName, const char *pszName, uint32_t idLang, PFNKLDRENUMRSRC pfnCallback, void *pvUser);
     929    int (* pfnEnumResources)(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, KU32 idType, const char *pszType,
     930                             KU32 idName, const char *pszName, KU32 idLang, PFNKLDRENUMRSRC pfnCallback, void *pvUser);
    931931    /** @copydoc kLdrModEnumDbgInfo */
    932932    int (* pfnEnumDbgInfo)(PKLDRMOD pMod, const void *pvBits, PFNKLDRENUMDBG pfnCallback, void *pvUser);
    … …  
    946946    int (* pfnFixupMapping)(PKLDRMOD pMod, PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
    947947    /** @copydoc kLdrModCallInit */
    948     int (* pfnCallInit)(PKLDRMOD pMod, uintptr_t uHandle);
     948    int (* pfnCallInit)(PKLDRMOD pMod, KUPTR uHandle);
    949949    /** @copydoc kLdrModCallTerm */
    950     int (* pfnCallTerm)(PKLDRMOD pMod, uintptr_t uHandle);
     950    int (* pfnCallTerm)(PKLDRMOD pMod, KUPTR uHandle);
    951951    /** @copydoc kLdrModCallThread */
    952     int (* pfnCallThread)(PKLDRMOD pMod, uintptr_t uHandle, unsigned fAttachingOrDetaching);
     952    int (* pfnCallThread)(PKLDRMOD pMod, KUPTR uHandle, unsigned fAttachingOrDetaching);
    953953    /** @copydoc kLdrModSize */
    954954    KLDRADDR (* pfnSize)(PKLDRMOD pMod);
    … …  
    961961    int (* pfnMostlyDone)(PKLDRMOD pMod);
    962962    /** Dummy which should be assigned a non-zero value. */
    963     uint32_t uEndOfStructure;
     963    KU32 uEndOfStructure;
    964964} KLDRMODOPS;
    965965
    … …  
    10341034
    10351035int     kLdrDyldLoad(const char *pszDll, const char *pszPrefix, const char *pszSuffix, KLDRDYLDSEARCH enmSearch,
    1036                      unsigned fFlags, PHKLDRMOD phMod, char *pszErr, size_t cchErr);
     1036                     unsigned fFlags, PHKLDRMOD phMod, char *pszErr, KSIZE cchErr);
    10371037int     kLdrDyldUnload(HKLDRMOD hMod);
    10381038int     kLdrDyldFindByName(const char *pszDll, const char *pszPrefix, const char *pszSuffix, KLDRDYLDSEARCH enmSearch,
    10391039                           unsigned fFlags, PHKLDRMOD phMod);
    1040 int     kLdrDyldFindByAddress(uintptr_t Address, PHKLDRMOD phMod, uint32_t *piSegment, uintptr_t *poffSegment);
    1041 int     kLdrDyldGetName(HKLDRMOD hMod, char *pszName, size_t cchName);
    1042 int     kLdrDyldGetFilename(HKLDRMOD hMod, char *pszFilename, size_t cchFilename);
    1043 int     kLdrDyldQuerySymbol(HKLDRMOD hMod, uint32_t uSymbolOrdinal, const char *pszSymbolName,
    1044                             const char *pszSymbolVersion, uintptr_t *pValue, uint32_t *pfKind);
    1045 int     kLdrDyldQueryResource(HKLDRMOD hMod, uint32_t idType, const char *pszType, uint32_t idName,
    1046                               const char *pszName, uint32_t idLang, void **pvRsrc, size_t *pcbRsrc);
    1047 int     kLdrDyldEnumResources(HKLDRMOD hMod, uint32_t idType, const char *pszType, uint32_t idName,
    1048                               const char *pszName, uint32_t idLang, PFNKLDRENUMRSRC pfnCallback, void *pvUser);
     1040int     kLdrDyldFindByAddress(KUPTR Address, PHKLDRMOD phMod, KU32 *piSegment, KUPTR *poffSegment);
     1041int     kLdrDyldGetName(HKLDRMOD hMod, char *pszName, KSIZE cchName);
     1042int     kLdrDyldGetFilename(HKLDRMOD hMod, char *pszFilename, KSIZE cchFilename);
     1043int     kLdrDyldQuerySymbol(HKLDRMOD hMod, KU32 uSymbolOrdinal, const char *pszSymbolName,
     1044                            const char *pszSymbolVersion, KUPTR *pValue, KU32 *pfKind);
     1045int     kLdrDyldQueryResource(HKLDRMOD hMod, KU32 idType, const char *pszType, KU32 idName,
     1046                              const char *pszName, KU32 idLang, void **pvRsrc, KSIZE *pcbRsrc);
     1047int     kLdrDyldEnumResources(HKLDRMOD hMod, KU32 idType, const char *pszType, KU32 idName,
     1048                              const char *pszName, KU32 idLang, PFNKLDRENUMRSRC pfnCallback, void *pvUser);
    10491049
    10501050/** @name OS/2 like API
    … …  
    10551055# define KLDROS2API
    10561056#endif
    1057 int     kLdrDosLoadModule(char *pszObject, size_t cbObject, const char *pszModule, PHKLDRMOD phMod);
     1057int     kLdrDosLoadModule(char *pszObject, KSIZE cbObject, const char *pszModule, PHKLDRMOD phMod);
    10581058int     kLdrDosFreeModule(HKLDRMOD hMod);
    10591059int     kLdrDosQueryModuleHandle(const char *pszModname, PHKLDRMOD phMod);
    1060 int     kLdrDosQueryModuleName(HKLDRMOD hMod, size_t cchName, char *pszName);
    1061 int     kLdrDosQueryProcAddr(HKLDRMOD hMod, uint32_t iOrdinal, const char *pszProcName, void **ppvProcAddr);
    1062 int     kLdrDosQueryProcType(HKLDRMOD hMod, uint32_t iOrdinal, const char *pszProcName, uint32_t *pfProcType);
    1063 int     kLdrDosQueryModFromEIP(PHKLDRMOD phMod, uint32_t *piObject, size_t cbName, char *pszName, uintptr_t *poffObject, uintptr_t ulEIP);
     1060int     kLdrDosQueryModuleName(HKLDRMOD hMod, KSIZE cchName, char *pszName);
     1061int     kLdrDosQueryProcAddr(HKLDRMOD hMod, KU32 iOrdinal, const char *pszProcName, void **ppvProcAddr);
     1062int     kLdrDosQueryProcType(HKLDRMOD hMod, KU32 iOrdinal, const char *pszProcName, KU32 *pfProcType);
     1063int     kLdrDosQueryModFromEIP(PHKLDRMOD phMod, KU32 *piObject, KSIZE cbName, char *pszName, KUPTR *poffObject, KUPTR ulEIP);
    10641064int     kLdrDosReplaceModule(const char *pszOldModule, const char *pszNewModule, const char *pszBackupModule);
    1065 int     kLdrDosGetResource(HKLDRMOD hMod, uint32_t idType, uint32_t idName, void **pvResAddr);
    1066 int     kLdrDosQueryResourceSize(HKLDRMOD hMod, uint32_t idType, uint32_t idName, uint32_t *pcb);
     1065int     kLdrDosGetResource(HKLDRMOD hMod, KU32 idType, KU32 idName, void **pvResAddr);
     1066int     kLdrDosQueryResourceSize(HKLDRMOD hMod, KU32 idType, KU32 idName, KU32 *pcb);
    10671067int     kLdrDosFreeResource(void *pvResAddr);
    10681068/** @} */
    … …  
    10851085#endif
    10861086HKLDRMOD KLDRWINAPI kLdrWLoadLibrary(const char *pszFilename);
    1087 HKLDRMOD KLDRWINAPI kLdrWLoadLibraryEx(const char *pszFilename, void *hFileReserved, uint32_t fFlags);
    1088 uint32_t KLDRWINAPI kLdrWGetModuleFileName(HKLDRMOD hMod, char *pszModName, size_t cchModName);
     1087HKLDRMOD KLDRWINAPI kLdrWLoadLibraryEx(const char *pszFilename, void *hFileReserved, KU32 fFlags);
     1088KU32     KLDRWINAPI kLdrWGetModuleFileName(HKLDRMOD hMod, char *pszModName, KSIZE cchModName);
    10891089HKLDRMOD KLDRWINAPI kLdrWGetModuleHandle(const char *pszFilename);
    1090 int      KLDRWINAPI kLdrWGetModuleHandleEx(uint32_t fFlags, const char *pszFilename, HKLDRMOD hMod);
     1090int      KLDRWINAPI kLdrWGetModuleHandleEx(KU32 fFlags, const char *pszFilename, HKLDRMOD hMod);
    10911091void *   KLDRWINAPI kLdrWGetProcAddress(HKLDRMOD hMod, const char *pszProcName);
    1092 uint32_t KLDRWINAPI kLdrWGetDllDirectory(size_t cchDir, char *pszDir);
     1092KU32     KLDRWINAPI kLdrWGetDllDirectory(KSIZE cchDir, char *pszDir);
    10931093int      KLDRWINAPI kLdrWSetDllDirectory(const char *pszDir);
    10941094int      KLDRWINAPI kLdrWFreeLibrary(HKLDRMOD hMod);
    … …  
    11001100typedef struct KLDRWRSRCLOADED *HKLDRWRSRCLOADED;
    11011101HKLDRWRSRCFOUND  KLDRWINAPI kLdrWFindResource(HKLDRMOD hMod, const char *pszType, const char *pszName);
    1102 HKLDRWRSRCFOUND  KLDRWINAPI kLdrWFindResourceEx(HKLDRMOD hMod, const char *pszType, const char *pszName, uint16_t idLang);
    1103 uint32_t         KLDRWINAPI kLdrWSizeofResource(HKLDRMOD hMod, HKLDRWRSRCFOUND hFoundRsrc);
     1102HKLDRWRSRCFOUND  KLDRWINAPI kLdrWFindResourceEx(HKLDRMOD hMod, const char *pszType, const char *pszName, KU16 idLang);
     1103KU32             KLDRWINAPI kLdrWSizeofResource(HKLDRMOD hMod, HKLDRWRSRCFOUND hFoundRsrc);
    11041104HKLDRWRSRCLOADED KLDRWINAPI kLdrWLoadResource(HKLDRMOD hMod, HKLDRWRSRCFOUND hFoundRsrc);
    11051105void    *KLDRWINAPI kLdrWLockResource(HKLDRMOD hMod, HKLDRWRSRCLOADED hLoadedRsrc);
    11061106int      KLDRWINAPI kLdrWFreeResource(HKLDRMOD hMod, HKLDRWRSRCLOADED hLoadedRsrc);
    11071107
    1108 typedef int (KLDRWINAPI *PFNKLDRWENUMRESTYPE)(HKLDRMOD hMod, const char *pszType, uintptr_t uUser);
    1109 int      KLDRWINAPI kLdrWEnumResourceTypes(HKLDRMOD hMod, PFNKLDRWENUMRESTYPE pfnEnum, uintptr_t uUser);
    1110 int      KLDRWINAPI kLdrWEnumResourceTypesEx(HKLDRMOD hMod, PFNKLDRWENUMRESTYPE pfnEnum, uintptr_t uUser, uint32_t fFlags, uint16_t idLang);
    1111 
    1112 typedef int (KLDRWINAPI *PFNKLDRWENUMRESNAME)(HKLDRMOD hMod, const char *pszType, char *pszName, uintptr_t uUser);
    1113 int      KLDRWINAPI kLdrWEnumResourceNames(HKLDRMOD hMod, const char *pszType, PFNKLDRWENUMRESNAME pfnEnum, uintptr_t uUser);
    1114 int      KLDRWINAPI kLdrWEnumResourceNamesEx(HKLDRMOD hMod, const char *pszType, PFNKLDRWENUMRESNAME pfnEnum, uintptr_t uUser, uint32_t fFlags, uint16_t idLang);
    1115 
    1116 typedef int (KLDRWINAPI *PFNKLDRWENUMRESLANG)(HKLDRMOD hMod, const char *pszType, const char *pszName, uint16_t idLang, uintptr_t uUser);
    1117 int      KLDRWINAPI kLdrWEnumResourceLanguages(HKLDRMOD hMod, const char *pszType, const char *pszName, PFNKLDRWENUMRESLANG pfnEnum, uintptr_t uUser);
     1108typedef int (KLDRWINAPI *PFNKLDRWENUMRESTYPE)(HKLDRMOD hMod, const char *pszType, KUPTR uUser);
     1109int      KLDRWINAPI kLdrWEnumResourceTypes(HKLDRMOD hMod, PFNKLDRWENUMRESTYPE pfnEnum, KUPTR uUser);
     1110int      KLDRWINAPI kLdrWEnumResourceTypesEx(HKLDRMOD hMod, PFNKLDRWENUMRESTYPE pfnEnum, KUPTR uUser, KU32 fFlags, KU16 idLang);
     1111
     1112typedef int (KLDRWINAPI *PFNKLDRWENUMRESNAME)(HKLDRMOD hMod, const char *pszType, char *pszName, KUPTR uUser);
     1113int      KLDRWINAPI kLdrWEnumResourceNames(HKLDRMOD hMod, const char *pszType, PFNKLDRWENUMRESNAME pfnEnum, KUPTR uUser);
     1114int      KLDRWINAPI kLdrWEnumResourceNamesEx(HKLDRMOD hMod, const char *pszType, PFNKLDRWENUMRESNAME pfnEnum, KUPTR uUser, KU32 fFlags, KU16 idLang);
     1115
     1116typedef int (KLDRWINAPI *PFNKLDRWENUMRESLANG)(HKLDRMOD hMod, const char *pszType, const char *pszName, KU16 idLang, KUPTR uUser);
     1117int      KLDRWINAPI kLdrWEnumResourceLanguages(HKLDRMOD hMod, const char *pszType, const char *pszName, PFNKLDRWENUMRESLANG pfnEnum, KUPTR uUser);
    11181118int      KLDRWINAPI kLdrWEnumResourceLanguagesEx(HKLDRMOD hMod, const char *pszType, const char *pszName,
    1119                                                  PFNKLDRWENUMRESLANG pfnEnum, uintptr_t uUser, uint32_t fFlags, uint16_t idLang);
     1119                                                 PFNKLDRWENUMRESLANG pfnEnum, KUPTR uUser, KU32 fFlags, KU16 idLang);
    11201120/** @} */
    11211121
    … …  
    11301130{
    11311131    /** Load & search flags, some which will become defaults. */
    1132     uint32_t        fFlags;
     1132    KU32            fFlags;
    11331133    /** The default search method. */
    11341134    KLDRDYLDSEARCH  enmSearch;
    … …  
    11401140    char            szDefSuffix[16];
    11411141    /** The LD_LIBRARY_PATH prefix for the process.. */
    1142     char            szLibPath[4096 - sizeof(uint32_t) - sizeof(KLDRDYLDSEARCH) - 16 - 16 - 260];
     1142    char            szLibPath[4096 - sizeof(KU32) - sizeof(KLDRDYLDSEARCH) - 16 - 16 - 260];
    11431143} KLDREXEARGS, *PKLDREXEARGS;
    11441144/** Pointer to a const argument package from the stub. */

  • trunk/kStuff/kLdr/kLdrBase.h

    r3537 r3567  
    2828#define ___kLdrBase_h___
    2929
     30#include <k/kDefs.h>
     31#include <k/kTypes.h>
     32
    3033
    3134/** @defgroup grp_kLdrBase  kLdrBase - Base Definitions And Typedefs
    3235 * @{ */
    33 
    34 /*
    35  * kLdr depend on size_t, [u]intNN_t, [u]intptr_t and some related constants.
    36  * If KLDR_ALREADY_INCLUDED_STD_TYPES or KCOMMON_ALREADY_INCLUDED_STD_TYPES
    37  * is defined, these has already been defined.
    38  */
    39 #if !defined(KLDR_ALREADY_INCLUDED_STD_TYPES) && !defined(KCOMMON_ALREADY_INCLUDED_STD_TYPES)
    40 # define KCOMMON_ALREADY_INCLUDED_STD_TYPES 1
    41 # include <sys/types.h>
    42 # include <stddef.h>
    43 # ifdef _MSC_VER
    44    typedef signed char          int8_t;
    45    typedef unsigned char        uint8_t;
    46    typedef signed short         int16_t;
    47    typedef unsigned short       uint16_t;
    48    typedef signed int           int32_t;
    49    typedef unsigned int         uint32_t;
    50    typedef signed __int64       int64_t;
    51    typedef unsigned __int64     uint64_t;
    52    typedef int64_t              intmax_t;
    53    typedef uint64_t             uintmax_t;
    54 #  define UINT8_C(c)            (c)
    55 #  define UINT16_C(c)           (c)
    56 #  define UINT32_C(c)           (c ## U)
    57 #  define UINT64_C(c)           (c ## ULL)
    58 #  define INT8_C(c)             (c)
    59 #  define INT16_C(c)            (c)
    60 #  define INT32_C(c)            (c)
    61 #  define INT64_C(c)            (c ## LL)
    62 #  define INT8_MIN              (INT8_C(-0x7f) - 1)
    63 #  define INT16_MIN             (INT16_C(-0x7fff) - 1)
    64 #  define INT32_MIN             (INT32_C(-0x7fffffff) - 1)
    65 #  define INT64_MIN             (INT64_C(-0x7fffffffffffffff) - 1)
    66 #  define INT8_MAX              INT8_C(0x7f)
    67 #  define INT16_MAX             INT16_C(0x7fff)
    68 #  define INT32_MAX             INT32_C(0x7fffffff)
    69 #  define INT64_MAX             INT64_C(0x7fffffffffffffff)
    70 #  define UINT8_MAX             UINT8_C(0xff)
    71 #  define UINT16_MAX            UINT16_C(0xffff)
    72 #  define UINT32_MAX            UINT32_C(0xffffffff)
    73 #  define UINT64_MAX            UINT64_C(0xffffffffffffffff)
    74 # else
    75 #  include <stdint.h>
    76 # endif
    77 #endif /* !KLDR_ALREADY_INCLUDED_STD_TYPES && !KCOMMON_ALREADY_INCLUDED_STD_TYPES */
    7836
    7937/** Get the minimum of two values. */
    … …  
    8240#define KLDR_MAX(a, b)              ((a) >= (b) ? (a) : (b))
    8341/** Calculate the offset of a structure member. */
    84 #define KLDR_OFFSETOF(strct, memb)  ( (size_t)( &((strct *)0)->memb ) )
    85 /** Align a size_t value. */
    86 #define KLDR_ALIGN_Z(val, align)    ( ((val) + ((align) - 1)) & ~(size_t)((align) - 1) )
     42#define KLDR_OFFSETOF(strct, memb)  ( (KSIZE)( &((strct *)0)->memb ) )
     43/** Align a KSIZE value. */
     44#define KLDR_ALIGN_Z(val, align)    ( ((val) + ((align) - 1)) & ~(KSIZE)((align) - 1) )
    8745/** Align a void * value. */
    88 #define KLDR_ALIGN_P(pv, align)     ( (void *)( ((uintptr_t)(pv) + ((align) - 1)) & ~(uintptr_t)((align) - 1) ) )
    89 /** Align a size_t value. */
     46#define KLDR_ALIGN_P(pv, align)     ( (void *)( ((KUPTR)(pv) + ((align) - 1)) & ~(KUPTR)((align) - 1) ) )
     47/** Align a KSIZE value. */
    9048#define KLDR_ALIGN_ADDR(val, align) ( ((val) + ((align) - 1)) & ~(KLDRADDR)((align) - 1) )
    9149/** Number of elements in an array. */
    … …  
    11068/** @def KLDR_E2E_U16
    11169 * Convert the endian of an unsigned 16-bit value. */
    112 # define KLDR_E2E_U16(u16)      ( (uint16_t) (((u16) >> 8) | ((u16) << 8)) )
     70# define KLDR_E2E_U16(u16)      ( (KU16) (((u16) >> 8) | ((u16) << 8)) )
    11371/** @def KLDR_E2E_U32
    11472 * Convert the endian of an unsigned 32-bit value. */
    115 # define KLDR_E2E_U32(u32)      (   ( ((u32) & UINT32_C(0xff000000)) >> 24 ) \
    116                                   | ( ((u32) & UINT32_C(0x00ff0000)) >>  8 ) \
    117                                   | ( ((u32) & UINT32_C(0x0000ff00)) <<  8 ) \
    118                                   | ( ((u32) & UINT32_C(0x000000ff)) << 24 ) \
     73# define KLDR_E2E_U32(u32)      (   ( ((u32) & KU32_C(0xff000000)) >> 24 ) \
     74                                  | ( ((u32) & KU32_C(0x00ff0000)) >>  8 ) \
     75                                  | ( ((u32) & KU32_C(0x0000ff00)) <<  8 ) \
     76                                  | ( ((u32) & KU32_C(0x000000ff)) << 24 ) \
    11977                                )
    12078/** @def KLDR_E2E_U64
    12179 * Convert the endian of an unsigned 64-bit value. */
    122 # define KLDR_E2E_U64(u64)      (   ( ((u64) & UINT64_C(0xff00000000000000)) >> 56 ) \
    123                                   | ( ((u64) & UINT64_C(0x00ff000000000000)) >> 40 ) \
    124                                   | ( ((u64) & UINT64_C(0x0000ff0000000000)) >> 24 ) \
    125                                   | ( ((u64) & UINT64_C(0x000000ff00000000)) >>  8 ) \
    126                                   | ( ((u64) & UINT64_C(0x00000000ff000000)) <<  8 ) \
    127                                   | ( ((u64) & UINT64_C(0x0000000000ff0000)) << 24 ) \
    128                                   | ( ((u64) & UINT64_C(0x000000000000ff00)) << 40 ) \
    129                                   | ( ((u64) & UINT64_C(0x00000000000000ff)) << 56 ) \
     80# define KLDR_E2E_U64(u64)      (   ( ((u64) & KU64_C(0xff00000000000000)) >> 56 ) \
     81                                  | ( ((u64) & KU64_C(0x00ff000000000000)) >> 40 ) \
     82                                  | ( ((u64) & KU64_C(0x0000ff0000000000)) >> 24 ) \
     83                                  | ( ((u64) & KU64_C(0x000000ff00000000)) >>  8 ) \
     84                                  | ( ((u64) & KU64_C(0x00000000ff000000)) <<  8 ) \
     85                                  | ( ((u64) & KU64_C(0x0000000000ff0000)) << 24 ) \
     86                                  | ( ((u64) & KU64_C(0x000000000000ff00)) << 40 ) \
     87                                  | ( ((u64) & KU64_C(0x00000000000000ff)) << 56 ) \
    13088                                )
    13189
    … …  
    143101 * Unsigned 64-bit big-endian to host endian. */
    144102#ifdef KLDR_LITTLE_ENDIAN
    145 # define KLDR_LE2H_U16(u16)  ((uint16_t)(u16))
    146 # define KLDR_LE2H_U32(u32)  ((uint32_t)(u32))
    147 # define KLDR_LE2H_U64(u64)  ((uint32_t)(u32))
     103# define KLDR_LE2H_U16(u16)  ((KU16)(u16))
     104# define KLDR_LE2H_U32(u32)  ((KU32)(u32))
     105# define KLDR_LE2H_U64(u64)  ((KU32)(u32))
    148106# define KLDR_BE2H_U16(u16)  KLDR_E2E_U16(u16)
    149107# define KLDR_BE2H_U32(u32)  KLDR_E2E_U32(u32)
    … …  
    153111# define KLDR_LE2H_U32(u32)  KLDR_E2E_U32(u32)
    154112# define KLDR_LE2H_U32(u64)  KLDR_E2E_U64(u64)
    155 # define KLDR_BE2H_U16(u16)  ((uint16_t)(u16))
    156 # define KLDR_BE2H_U32(u32)  ((uint32_t)(u32))
    157 # define KLDR_BE2H_U64(u64)  ((uint32_t)(u32))
     113# define KLDR_BE2H_U16(u16)  ((KU16)(u16))
     114# define KLDR_BE2H_U32(u32)  ((KU32)(u32))
     115# define KLDR_BE2H_U64(u64)  ((KU32)(u32))
    158116#else
    159117# error "KLDR_BIG_ENDIAN or KLDR_LITTLE_ENDIAN is supposed to be defined."

  • trunk/kStuff/kLdr/kLdrDyld.c

    r3537 r3567  
    9696
    9797/** The default flags. */
    98 uint32_t        kLdrDyldFlags = 0;
     98KU32            kLdrDyldFlags = 0;
    9999/** The default search method. */
    100100KLDRDYLDSEARCH  kLdrDyldSearch = KLDRDYLD_SEARCH_HOST;
    … …  
    110110void           *g_pvkLdrDyldMainStack = NULL;
    111111/** The size of the main stack object. */
    112 size_t          g_cbkLdrDyldMainStack = 0;
     112KSIZE           g_cbkLdrDyldMainStack = 0;
    113113/** @} */
    114114
    … …  
    123123static PPKLDRDYLDMOD    g_papStackMods;
    124124/** The number of used entries in the g_papStackMods array. */
    125 static uint32_t         g_cStackMods;
     125static KU32             g_cStackMods;
    126126/** The number of entries allocated for the g_papStackMods array. */
    127 static uint32_t         g_cStackModsAllocated;
     127static KU32             g_cStackModsAllocated;
    128128/** Number of active load calls. */
    129 static uint32_t         g_cActiveLoadCalls;
     129static KU32             g_cActiveLoadCalls;
    130130/** Number of active unload calls. */
    131 static uint32_t         g_cActiveUnloadCalls;
     131static KU32             g_cActiveUnloadCalls;
    132132/** Total number of load calls. */
    133 static uint32_t         g_cTotalLoadCalls;
     133static KU32             g_cTotalLoadCalls;
    134134/** Total mumber of unload calls. */
    135 static uint32_t         g_cTotalUnloadCalls;
     135static KU32             g_cTotalUnloadCalls;
    136136/** Boolean flag indicating that GC is active. */
    137 static uint32_t         g_fActiveGC;
     137static KU32             g_fActiveGC;
    138138
    139139
    … …  
    145145 * @internal
    146146 * @{ */
    147 void       kldrDyldDoLoadExeStackSwitch(PKLDRDYLDMOD pExe, void *pvStack, size_t cbStack);
     147void       kldrDyldDoLoadExeStackSwitch(PKLDRDYLDMOD pExe, void *pvStack, KSIZE cbStack);
    148148static int kldrDyldDoLoad(const char *pszDll, const char *pszPrefix, const char *pszSuffix, KLDRDYLDSEARCH enmSearch,
    149                           unsigned fFlags, PPKLDRDYLDMOD ppMod, char *pszErr, size_t cchErr);
     149                          unsigned fFlags, PPKLDRDYLDMOD ppMod, char *pszErr, KSIZE cchErr);
    150150static int kldrDyldDoLoad2(PKLDRDYLDMOD pLoadedMod, const char *pszPrefix, const char *pszSuffix,
    151151                           KLDRDYLDSEARCH enmSearch, unsigned fFlags);
    … …  
    155155static int kldrDyldDoFindByName(const char *pszDll, const char *pszPrefix, const char *pszSuffix, KLDRDYLDSEARCH enmSearch,
    156156                              unsigned fFlags, PPKLDRDYLDMOD ppMod);
    157 static int kldrDyldDoFindByAddress(uintptr_t Address, PPKLDRDYLDMOD ppMod, uint32_t *piSegment, uintptr_t *poffSegment);
    158 static int kldrDyldDoGetName(PKLDRDYLDMOD pMod, char *pszName, size_t cchName);
    159 static int kldrDyldDoGetFilename(PKLDRDYLDMOD pMod, char *pszFilename, size_t cchFilename);
    160 static int kldrDyldDoQuerySymbol(PKLDRDYLDMOD pMod, uint32_t uSymbolOrdinal, const char *pszSymbolName, uintptr_t *pValue, uint32_t *pfKind);
     157static int kldrDyldDoFindByAddress(KUPTR Address, PPKLDRDYLDMOD ppMod, KU32 *piSegment, KUPTR *poffSegment);
     158static int kldrDyldDoGetName(PKLDRDYLDMOD pMod, char *pszName, KSIZE cchName);
     159static int kldrDyldDoGetFilename(PKLDRDYLDMOD pMod, char *pszFilename, KSIZE cchFilename);
     160static int kldrDyldDoQuerySymbol(PKLDRDYLDMOD pMod, KU32 uSymbolOrdinal, const char *pszSymbolName, KUPTR *pValue, KU32 *pfKind);
    161161/** @} */
    162162
    … …  
    171171 * @internal
    172172 * @{ */
    173 static uint32_t     kldrDyldStackNewFrame(PKLDRDYLDMOD pMod);
     173static KU32         kldrDyldStackNewFrame(PKLDRDYLDMOD pMod);
    174174static int          kldrDyldStackAddModule(PKLDRDYLDMOD pMod);
    175175static int          kldrDyldStackFrameCompleted(void);
    176176static void         kldrDyldStackCleanupOne(PKLDRDYLDMOD pMod, int rc);
    177 static void         kldrDyldStackDropFrame(uint32_t iLoad1st, uint32_t iLoadEnd, int rc);
     177static void         kldrDyldStackDropFrame(KU32 iLoad1st, KU32 iLoadEnd, int rc);
    178178/** @} */
    179179
    180 static int          kldrDyldCopyError(int rc, char *pszErr, size_t cchErr);
     180static int          kldrDyldCopyError(int rc, char *pszErr, KSIZE cchErr);
    181181
    182182
    … …  
    235235{
    236236    void *pvStack;
    237     size_t cbStack;
     237    KSIZE cbStack;
    238238    PKLDRDYLDMOD pExe;
    239239    int rc;
    … …  
    325325 */
    326326int     kLdrDyldLoad(const char *pszDll, const char *pszPrefix, const char *pszSuffix, KLDRDYLDSEARCH enmSearch,
    327                      unsigned fFlags, PHKLDRMOD phMod, char *pszErr, size_t cchErr)
     327                     unsigned fFlags, PHKLDRMOD phMod, char *pszErr, KSIZE cchErr)
    328328{
    329329    int rc;
    … …  
    434434 * @param   poffSegment     Where to store the offset into the segment. (optional)
    435435 */
    436 int     kLdrDyldFindByAddress(uintptr_t Address, PHKLDRMOD phMod, uint32_t *piSegment, uintptr_t *poffSegment)
     436int     kLdrDyldFindByAddress(KUPTR Address, PHKLDRMOD phMod, KU32 *piSegment, KUPTR *poffSegment)
    437437{
    438438    int rc;
    … …  
    441441    *phMod = NIL_HKLDRMOD;
    442442    if (piSegment)
    443         *piSegment = ~(uint32_t)0;
     443        *piSegment = ~(KU32)0;
    444444    if (poffSegment)
    445         *poffSegment = ~(uintptr_t)0;
     445        *poffSegment = ~(KUPTR)0;
    446446
    447447    /* get sem & do work */
    … …  
    468468 * @see kLdrDyldGetFilename
    469469 */
    470 int     kLdrDyldGetName(HKLDRMOD hMod, char *pszName, size_t cchName)
     470int     kLdrDyldGetName(HKLDRMOD hMod, char *pszName, KSIZE cchName)
    471471{
    472472    int rc;
    … …  
    499499 * @see kLdrDyldGetName
    500500 */
    501 int     kLdrDyldGetFilename(HKLDRMOD hMod, char *pszFilename, size_t cchFilename)
     501int     kLdrDyldGetFilename(HKLDRMOD hMod, char *pszFilename, KSIZE cchFilename)
    502502{
    503503    int rc;
    … …  
    532532 * @param   pfKind              Where to put the symbol kind flags. Optional if pValue is non-zero.
    533533 */
    534 int     kLdrDyldQuerySymbol(HKLDRMOD hMod, uint32_t uSymbolOrdinal, const char *pszSymbolName,
    535                             const char *pszSymbolVersion, uintptr_t *pValue, uint32_t *pfKind)
     534int     kLdrDyldQuerySymbol(HKLDRMOD hMod, KU32 uSymbolOrdinal, const char *pszSymbolName,
     535                            const char *pszSymbolVersion, KUPTR *pValue, KU32 *pfKind)
    536536{
    537537    int rc;
    … …  
    592592 */
    593593static int kldrDyldDoLoad(const char *pszDll, const char *pszPrefix, const char *pszSuffix, KLDRDYLDSEARCH enmSearch,
    594                           unsigned fFlags, PPKLDRDYLDMOD ppMod, char *pszErr, size_t cchErr)
     594                          unsigned fFlags, PPKLDRDYLDMOD ppMod, char *pszErr, KSIZE cchErr)
    595595{
    596596    int rc;
    … …  
    692692     * Load prerequisites.
    693693     */
    694     uint32_t i;
    695     uint32_t iLoad1st = kldrDyldStackNewFrame(pLoadedMod);
     694    KU32 i;
     695    KU32 iLoad1st = kldrDyldStackNewFrame(pLoadedMod);
    696696    int rc = kldrDyldDoLoadPrerequisites(pLoadedMod, pszPrefix, pszSuffix, enmSearch, fFlags);
    697     uint32_t iLoadEnd = kldrDyldStackFrameCompleted();
     697    KU32 iLoadEnd = kldrDyldStackFrameCompleted();
    698698    if (rc)
    699699    {
    … …  
    882882            if (cEntries < sizeof(s_aEntries) / sizeof(s_aEntries[0]))
    883883            {
    884                 s_aEntries[cEntries].cLeft = ~(uint32_t)0;
     884                s_aEntries[cEntries].cLeft = ~(KU32)0;
    885885                s_aEntries[cEntries].pMod = pMod->papPrereqs[pMod->cPrereqs - s_aEntries[i].cLeft];
    886886                s_aEntries[i].cLeft--;
    … …  
    10241024 * @param   pLoadMod        The module being loaded (only used for asserting).
    10251025 */
    1026 static uint32_t kldrDyldStackNewFrame(PKLDRDYLDMOD pLoadMod)
     1026static KU32 kldrDyldStackNewFrame(PKLDRDYLDMOD pLoadMod)
    10271027{
    10281028    /*
    … …  
    10841084    if (g_cStackMods + 1 > g_cStackModsAllocated)
    10851085    {
    1086         uint32_t cNew = g_cStackModsAllocated ? g_cStackModsAllocated * 2 : 128;
     1086        KU32 cNew = g_cStackModsAllocated ? g_cStackModsAllocated * 2 : 128;
    10871087        void *pvOld = g_papStackMods;
    10881088        void *pvNew = kldrHlpAlloc(cNew * sizeof(g_papStackMods[0]));
    … …  
    11991199 * @param   rc              Used for state verification.
    12001200 */
    1201 static void kldrDyldStackDropFrame(uint32_t iLoad1st, uint32_t iLoadEnd, int rc)
    1202 {
    1203     uint32_t i;
     1201static void kldrDyldStackDropFrame(KU32 iLoad1st, KU32 iLoadEnd, int rc)
     1202{
     1203    KU32 i;
    12041204    KLDRDYLD_ASSERT(iLoad1st <= g_cStackMods);
    12051205    KLDRDYLD_ASSERT(iLoadEnd == g_cStackMods);
    … …  
    13181318                case KLDRSTATE_PENDING_TERMINATION:
    13191319                {
    1320                     const uint32_t cTotalLoadCalls = g_cTotalLoadCalls;
    1321                     const uint32_t cTotalUnloadCalls = g_cTotalUnloadCalls;
     1320                    const KU32 cTotalLoadCalls = g_cTotalLoadCalls;
     1321                    const KU32 cTotalUnloadCalls = g_cTotalUnloadCalls;
    13221322                    kldrDyldModCallTerm(pMod);
    13231323                    fRestart = cTotalLoadCalls != g_cTotalLoadCalls
    … …  
    14011401 * @internal
    14021402 */
    1403 static int kldrDyldDoFindByAddress(uintptr_t Address, PPKLDRDYLDMOD ppMod, uint32_t *piSegment, uintptr_t *poffSegment)
     1403static int kldrDyldDoFindByAddress(KUPTR Address, PPKLDRDYLDMOD ppMod, KU32 *piSegment, KUPTR *poffSegment)
    14041404{
    14051405    /* Scan the segments of each module in the load list. */
    … …  
    14071407    while (pMod)
    14081408    {
    1409         uint32_t iSeg;
     1409        KU32 iSeg;
    14101410        for (iSeg = 0; iSeg < pMod->pMod->cSegments; iSeg++)
    14111411        {
    … …  
    14171417                    *piSegment = iSeg;
    14181418                if (poffSegment)
    1419                     *poffSegment = (uintptr_t)off;
     1419                    *poffSegment = (KUPTR)off;
    14201420                return 0;
    14211421            }
    … …  
    14341434 * @internal
    14351435 */
    1436 static int kldrDyldDoGetName(PKLDRDYLDMOD pMod, char *pszName, size_t cchName)
     1436static int kldrDyldDoGetName(PKLDRDYLDMOD pMod, char *pszName, KSIZE cchName)
    14371437{
    14381438    return kldrDyldModGetName(pMod, pszName, cchName);
    … …  
    14441444 * @internal
    14451445 */
    1446 static int kldrDyldDoGetFilename(PKLDRDYLDMOD pMod, char *pszFilename, size_t cchFilename)
     1446static int kldrDyldDoGetFilename(PKLDRDYLDMOD pMod, char *pszFilename, KSIZE cchFilename)
    14471447{
    14481448    return kldrDyldModGetFilename(pMod, pszFilename, cchFilename);
    … …  
    14541454 * @internal
    14551455 */
    1456 static int kldrDyldDoQuerySymbol(PKLDRDYLDMOD pMod, uint32_t uSymbolOrdinal, const char *pszSymbolName, uintptr_t *pValue, uint32_t *pfKind)
     1456static int kldrDyldDoQuerySymbol(PKLDRDYLDMOD pMod, KU32 uSymbolOrdinal, const char *pszSymbolName, KUPTR *pValue, KU32 *pfKind)
    14571457{
    14581458    return kldrDyldModQuerySymbol(pMod, uSymbolOrdinal, pszSymbolName, pValue, pfKind);
    … …  
    14851485 * @param   cchErr  The size of the destination buffer.
    14861486 */
    1487 static int kldrDyldCopyError(int rc, char *pszErr, size_t cchErr)
    1488 {
    1489     size_t cchToCopy;
     1487static int kldrDyldCopyError(int rc, char *pszErr, KSIZE cchErr)
     1488{
     1489    KSIZE cchToCopy;
    14901490
    14911491    /* if no error string, format the rc into a string. */

  • trunk/kStuff/kLdr/kLdrDyldFind.c

    r3537 r3567  
    8282{
    8383    const char *pszName;
    84     size_t      cchName;
     84    KSIZE       cchName;
    8585
    8686    const char *pszPrefix;
    87     size_t      cchPrefix;
     87    KSIZE       cchPrefix;
    8888
    8989    const char *pszSuffix;
    90     size_t      cchSuffix;
    91 
    92     size_t      cchMaxLength;
     90    KSIZE       cchSuffix;
     91
     92    KSIZE       cchMaxLength;
    9393
    9494    KLDRDYLDSEARCH  enmSearch;
    95     uint32_t        fFlags;
     95    KU32            fFlags;
    9696    PPKLDRRDR       ppRdr;
    9797} KLDRDYLDFINDARGS, *PKLDRDYLDFINDARGS;
    … …  
    205205                                   KLDRDYLDSEARCH enmSearch, unsigned fFlags, PPKLDRRDR ppRdr);
    206206static int kldrDyldFindTryOpen(const char *pszFilename, PPKLDRRDR ppRdr);
    207 static int kldrDyldFindTryOpenPath(const char *pchPath, size_t cchPath, PCKLDRDYLDFINDARGS pArgs);
     207static int kldrDyldFindTryOpenPath(const char *pchPath, KSIZE cchPath, PCKLDRDYLDFINDARGS pArgs);
    208208static int kldrDyldFindEnumeratePath(const char *pszSearchPath, PCKLDRDYLDFINDARGS pArgs);
    209209static int kldrDyldFindGetDefaults(KLDRDYLDSEARCH *penmSearch, const char **pszPrefix,
    210                                    const char **pszSuffix, const char *pszName, uint32_t fFlags);
     210                                   const char **pszSuffix, const char *pszName, KU32 fFlags);
    211211
    212212
    … …  
    218218int kldrDyldFindInit(void)
    219219{
    220     size_t  cch;
     220    KSIZE   cch;
    221221    int     rc;
    222222    char    szTmp[sizeof(kLdrDyldDefSuffix)];
    … …  
    377377        {
    378378            const char     *pszFilename = kLdrRdrName(pRdr);
    379             const size_t    cchFilename = kLdrHlpStrLen(pszFilename);
     379            const KSIZE     cchFilename = kLdrHlpStrLen(pszFilename);
    380380            PKLDRDYLDMOD    pCur;
    381381            for (pCur = kLdrDyldHead; pCur; pCur = pCur->Load.pNext)
    … …  
    391391        {
    392392            const char     *pszFilename = kLdrRdrName(pRdr);
    393             const size_t    cchFilename = kLdrHlpStrLen(pszFilename);
     393            const KSIZE     cchFilename = kLdrHlpStrLen(pszFilename);
    394394            PKLDRDYLDMOD    pCur;
    395395            for (pCur = kLdrDyldHead; pCur; pCur = pCur->Load.pNext)
    … …  
    590590    if (!kLdrDyldExePath[0])
    591591    {
    592         size_t cch;
     592        KSIZE cch;
    593593        kldrHlpGetEnv("KLDR_EXE_PATH", kLdrDyldExePath, sizeof(kLdrDyldExePath) - 10);
    594594        cch = kLdrHlpStrLen(kLdrDyldExePath);
    … …  
    637637 * @returns See kldrDyldFindTryOpen
    638638 */
    639 static int kldrDyldFindTryOpenPath(const char *pchPath, size_t cchPath, PCKLDRDYLDFINDARGS pArgs)
     639static int kldrDyldFindTryOpenPath(const char *pchPath, KSIZE cchPath, PCKLDRDYLDFINDARGS pArgs)
    640640{
    641641    static char s_szFilename[1024];
    … …  
    721721    {
    722722        const char *pszEnd;
    723         size_t      cchPath;
     723        KSIZE       cchPath;
    724724
    725725        /*
    … …  
    780780 */
    781781static int kldrDyldFindGetDefaults(KLDRDYLDSEARCH *penmSearch, const char **ppszPrefix, const char **ppszSuffix,
    782                                    const char *pszName, uint32_t fFlags)
     782                                   const char *pszName, KU32 fFlags)
    783783{
    784784    unsigned fCaseSensitive;
    … …  
    836836    if (*ppszSuffix)
    837837    {
    838         const size_t cchName = kLdrHlpStrLen(pszName);
    839         const size_t cchSuffix = kLdrHlpStrLen(*ppszSuffix);
     838        const KSIZE cchName = kLdrHlpStrLen(pszName);
     839        const KSIZE cchSuffix = kLdrHlpStrLen(*ppszSuffix);
    840840        if (    cchName > cchSuffix
    841841            &&  (   fCaseSensitive
    … …  
    908908            /* do a filename based search. */
    909909            const char     *pszFilename = kLdrRdrName(pRdr);
    910             const size_t    cchFilename = kLdrHlpStrLen(pszFilename);
     910            const KSIZE     cchFilename = kLdrHlpStrLen(pszFilename);
    911911            PKLDRDYLDMOD    pCur;
    912912            rc = KLDR_ERR_MODULE_NOT_FOUND;
    … …  
    926926    else
    927927    {
    928         const size_t    cchName = kLdrHlpStrLen(pszName);
    929         const size_t    cchPrefix = pszPrefix ? kLdrHlpStrLen(pszPrefix) : 0;
    930         const size_t    cchSuffix = pszSuffix ? kLdrHlpStrLen(pszSuffix) : 0;
     928        const KSIZE     cchName = kLdrHlpStrLen(pszName);
     929        const KSIZE     cchPrefix = pszPrefix ? kLdrHlpStrLen(pszPrefix) : 0;
     930        const KSIZE     cchSuffix = pszSuffix ? kLdrHlpStrLen(pszSuffix) : 0;
    931931        const char     *pszNameSuffix = kldrHlpGetSuff(pszName);
    932932        PKLDRDYLDMOD    pCur = kLdrDyldHead;

  • trunk/kStuff/kLdr/kLdrDyldMod.c

    r3537 r3567  
    6767 * @param   ppMod   Where to put the pointer to the new module on success.
    6868 */
    69 int kldrDyldModCreate(PKLDRRDR pRdr, uint32_t fFlags, PPKLDRDYLDMOD ppMod)
     69int kldrDyldModCreate(PKLDRRDR pRdr, KU32 fFlags, PPKLDRDYLDMOD ppMod)
    7070{
    7171    PKLDRDYLDMOD pMod;
    … …  
    198198 * @remark  This function ain't finalized yet.
    199199 */
    200 int kldrDyldModCreateNative(uintptr_t hNativeModule)
     200int kldrDyldModCreateNative(KUPTR hNativeModule)
    201201{
    202202#if 0
    … …  
    275275    if (pMod->papPrereqs)
    276276    {
    277         uint32_t i = pMod->cPrereqs;
     277        KU32 i = pMod->cPrereqs;
    278278        while (i-- > 0)
    279279        {
    … …  
    609609 * @param   pMod    The module in  question.
    610610 */
    611 static uint32_t kldrDyldModUnloadPrerequisitesOne(PKLDRDYLDMOD pMod)
     611static KU32 kldrDyldModUnloadPrerequisitesOne(PKLDRDYLDMOD pMod)
    612612{
    613613    PKLDRDYLDMOD    pMod2;
    614     uint32_t        cToUnload = 0;
    615     uint32_t        i;
     614    KU32            cToUnload = 0;
     615    KU32            i;
    616616
    617617    KLDRDYLDMOD_ASSERT(pMod->papPrereqs || !pMod->cPrereqs);
    … …  
    683683void kldrDyldModUnloadPrerequisites(PKLDRDYLDMOD pMod)
    684684{
    685     uint32_t        cToUnload;
     685    KU32            cToUnload;
    686686
    687687    /* sanity */
    … …  
    738738                                 KLDRDYLDSEARCH enmSearch, unsigned fFlags)
    739739{
    740     int32_t     cPrereqs;
    741     uint32_t    i;
    742     int         rc = 0;
     740    KI32    cPrereqs;
     741    KU32    i;
     742    int     rc = 0;
    743743
    744744    /* sanity */
    … …  
    932932 * pvUser points to the KLDRDYLDMOD.
    933933 */
    934 static int kldrDyldModFixupGetImportCallback(PKLDRMOD pMod, uint32_t iImport, uint32_t iSymbol,
    935                                              const char *pchSymbol, size_t cchSymbol, const char *pszVersion,
    936                                              PKLDRADDR puValue, uint32_t *pfKind, void *pvUser)
     934static int kldrDyldModFixupGetImportCallback(PKLDRMOD pMod, KU32 iImport, KU32 iSymbol,
     935                                             const char *pchSymbol, KSIZE cchSymbol, const char *pszVersion,
     936                                             PKLDRADDR puValue, KU32 *pfKind, void *pvUser)
    937937{
    938938    static int s_cRecursiveCalls = 0;
    … …  
    979979        while (pBindMod)
    980980        {
    981             uint32_t fKind;
     981            KU32 fKind;
    982982            KLDRADDR uValue;
    983983            rc = kLdrModQuerySymbol(pBindMod->pMod, NULL, KLDRMOD_BASEADDRESS_MAP,
    … …  
    10581058
    10591059    pMod->enmState = KLDRSTATE_INITIALIZING;
    1060     rc = kLdrModCallInit(pMod->pMod, (uintptr_t)pMod->hMod);
     1060    rc = kLdrModCallInit(pMod->pMod, (KUPTR)pMod->hMod);
    10611061    if (!rc)
    10621062    {
    … …  
    10901090
    10911091    pMod->enmState = KLDRSTATE_TERMINATING;
    1092     kLdrModCallTerm(pMod->pMod, (uintptr_t)pMod->hMod);
     1092    kLdrModCallTerm(pMod->pMod, (KUPTR)pMod->hMod);
    10931093    pMod->enmState = KLDRSTATE_PENDING_GC;
    10941094    /* unlinking on destruction. */
    … …  
    11061106    KLDRDYLDMOD_ASSERT(pMod->enmState == KLDRSTATE_GOOD);
    11071107
    1108     return kLdrModCallThread(pMod->pMod, (uintptr_t)pMod->hMod, 1 /* attach */);
     1108    return kLdrModCallThread(pMod->pMod, (KUPTR)pMod->hMod, 1 /* attach */);
    11091109}
    11101110
    … …  
    11201120    KLDRDYLDMOD_ASSERT(pMod->enmState == KLDRSTATE_GOOD);
    11211121
    1122     kLdrModCallThread(pMod->pMod, (uintptr_t)pMod->hMod, 0 /* detach */);
     1122    kLdrModCallThread(pMod->pMod, (KUPTR)pMod->hMod, 0 /* detach */);
    11231123}
    11241124
    … …  
    11321132 * @param   pcbStack    Where to store the size of the stack.
    11331133 */
    1134 int kldrDyldModGetMainStack(PKLDRDYLDMOD pMod, void **ppvStack, size_t *pcbStack)
     1134int kldrDyldModGetMainStack(PKLDRDYLDMOD pMod, void **ppvStack, KSIZE *pcbStack)
    11351135{
    11361136    int rc = 0;
    … …  
    11481148        {
    11491149            /* check if there is a stack size override/default. */
    1150             size_t cbDefOverride;
     1150            KSIZE cbDefOverride;
    11511151            if (kldrHlpGetEnvUZ("KLDR_MAIN_STACK_SIZE", &cbDefOverride))
    11521152                cbDefOverride = 0;
    … …  
    11571157                ||  StackInfo.cbStack < cbDefOverride)
    11581158            {
    1159                 size_t cbStack = (size_t)KLDR_MAX(StackInfo.cbStack, cbDefOverride);
     1159                KSIZE cbStack = (KSIZE)KLDR_MAX(StackInfo.cbStack, cbDefOverride);
    11601160
    11611161                g_pvkLdrDyldMainStack = kldrDyldOSAllocStack(cbStack);
    … …  
    11741174
    11751175                g_fkLdrDyldMainStackAllocated = 0;
    1176                 g_pvkLdrDyldMainStack = (void *)(uintptr_t)StackInfo.Address;
    1177                 KLDRDYLDMOD_ASSERT((uintptr_t)g_pvkLdrDyldMainStack == StackInfo.Address);
    1178 
    1179                 g_cbkLdrDyldMainStack = (size_t)StackInfo.cbStack;
     1176                g_pvkLdrDyldMainStack = (void *)(KUPTR)StackInfo.Address;
     1177                KLDRDYLDMOD_ASSERT((KUPTR)g_pvkLdrDyldMainStack == StackInfo.Address);
     1178
     1179                g_cbkLdrDyldMainStack = (KSIZE)StackInfo.cbStack;
    11801180                KLDRDYLDMOD_ASSERT(StackInfo.cbStack == g_cbkLdrDyldMainStack);
    11811181            }
    … …  
    12091209    KLDRADDR    MainEPAddress;
    12101210    void       *pvStack;
    1211     size_t      cbStack;
     1211    KSIZE      cbStack;
    12121212    KLDRDYLDMOD_ASSERT(pMod->fExecutable);
    12131213
    … …  
    12181218    if (rc)
    12191219        return rc;
    1220     return kldrDyldOSStartExe((uintptr_t)MainEPAddress, pvStack, cbStack);
     1220    return kldrDyldOSStartExe((KUPTR)MainEPAddress, pvStack, cbStack);
    12211221}
    12221222
    … …  
    12301230 * @param   cchName         The size of the name buffer.
    12311231 */
    1232 int kldrDyldModGetName(PKLDRDYLDMOD pMod, char *pszName, size_t cchName)
    1233 {
    1234     size_t cch = KLDR_MIN(cchName, pMod->pMod->cchName + 1);
     1232int kldrDyldModGetName(PKLDRDYLDMOD pMod, char *pszName, KSIZE cchName)
     1233{
     1234    KSIZE cch = KLDR_MIN(cchName, pMod->pMod->cchName + 1);
    12351235    if (cch)
    12361236    {
    … …  
    12501250 * @param   cchFilename     The size of the filename buffer.
    12511251 */
    1252 int kldrDyldModGetFilename(PKLDRDYLDMOD pMod, char *pszFilename, size_t cchFilename)
    1253 {
    1254     size_t cch = KLDR_MIN(cchFilename, pMod->pMod->cchFilename + 1);
     1252int kldrDyldModGetFilename(PKLDRDYLDMOD pMod, char *pszFilename, KSIZE cchFilename)
     1253{
     1254    KSIZE cch = KLDR_MIN(cchFilename, pMod->pMod->cchFilename + 1);
    12551255    if (cch)
    12561256    {
    … …  
    12721272 * @param   pfKind          Where to store the symbol kind. optional.
    12731273 */
    1274 int kldrDyldModQuerySymbol(PKLDRDYLDMOD pMod, uint32_t uSymbolOrdinal, const char *pszSymbolName,
    1275                            uintptr_t *puValue, uint32_t *pfKind)
     1274int kldrDyldModQuerySymbol(PKLDRDYLDMOD pMod, KU32 uSymbolOrdinal, const char *pszSymbolName,
     1275                           KUPTR *puValue, KU32 *pfKind)
    12761276{
    12771277    int         rc;
    12781278    KLDRADDR    uValue = 0;
    1279     uint32_t    fKind = 0;
     1279    KU32        fKind = 0;
    12801280
    12811281    rc = kLdrModQuerySymbol(pMod->pMod, NULL, KLDRMOD_BASEADDRESS_MAP,
    … …  
    12871287        if (puValue)
    12881288        {
    1289             *puValue = (uintptr_t)uValue;
     1289            *puValue = (KUPTR)uValue;
    12901290            KLDRDYLDMOD_ASSERT(*puValue == uValue);
    12911291        }

  • trunk/kStuff/kLdr/kLdrDyldOS.c

    r3537 r3567  
    5151 *                  If 0, a OS specific default stack size will be employed.
    5252 */
    53 void *kldrDyldOSAllocStack(size_t cb)
     53void *kldrDyldOSAllocStack(KSIZE cb)
    5454{
    5555#ifdef __OS2__
    … …  
    8787 * @param   cbStack         The size of the stack object.
    8888 */
    89 int kldrDyldOSStartExe(uintptr_t uMainEPAddress, void *pvStack, size_t cbStack)
     89int kldrDyldOSStartExe(KUPTR uMainEPAddress, void *pvStack, KSIZE cbStack)
    9090{
    9191#if defined(__OS2__)
    … …  
    116116
    117117
    118 void kldrDyldDoLoadExeStackSwitch(PKLDRDYLDMOD pExe, void *pvStack, size_t cbStack)
     118void kldrDyldDoLoadExeStackSwitch(PKLDRDYLDMOD pExe, void *pvStack, KSIZE cbStack)
    119119{
    120120    /*kldrHlpAssert(!"not implemented");*/

  • trunk/kStuff/kLdr/kLdrHlp-gcc.c

    r3537 r3567  
    3434
    3535
    36 void *memchr(const void *pv, int ch, size_t cb)
     36void *memchr(const void *pv, int ch, KSIZE cb)
    3737{
    3838    const char *pb = pv;
    … …  
    4747
    4848
    49 int memcmp(const void *pv1, const void *pv2, size_t cb)
     49int memcmp(const void *pv1, const void *pv2, KSIZE cb)
    5050{
    5151    /*
    … …  
    5353     */
    5454    if (    cb > 16
    55         &&  !((uintptr_t)pv1 & (sizeof(void *) - 1))
    56         &&  !((uintptr_t)pv2 & (sizeof(void *) - 1)) )
    57     {
    58         const uintptr_t *pu1 = pv1;
    59         const uintptr_t *pu2 = pv2;
    60         while (cb >= sizeof(uintptr_t))
    61         {
    62             const uintptr_t u1 = *pu1++;
    63             const uintptr_t u2 = *pu2++;
     55        &&  !((KUPTR)pv1 & (sizeof(void *) - 1))
     56        &&  !((KUPTR)pv2 & (sizeof(void *) - 1)) )
     57    {
     58        const KUPTR *pu1 = pv1;
     59        const KUPTR *pu2 = pv2;
     60        while (cb >= sizeof(KUPTR))
     61        {
     62            const KUPTR u1 = *pu1++;
     63            const KUPTR u2 = *pu2++;
    6464            if (u1 != u2)
    6565                return u1 > u2 ? 1 : -1;
    66             cb -= sizeof(uintptr_t);
     66            cb -= sizeof(KUPTR);
    6767        }
    6868        if (!cb)
    … …  
    9191
    9292
    93 void *memcpy(void *pv1, const void *pv2, size_t cb)
     93void *memcpy(void *pv1, const void *pv2, KSIZE cb)
    9494{
    9595    void *pv1Start = pv1;
    … …  
    9999     */
    100100    if (    cb > 16
    101         &&  !((uintptr_t)pv1 & (sizeof(void *) - 1))
    102         &&  !((uintptr_t)pv2 & (sizeof(void *) - 1)) )
    103     {
    104         uintptr_t       *pu1 = pv1;
    105         const uintptr_t *pu2 = pv2;
    106         while (cb >= sizeof(uintptr_t))
    107         {
    108             cb -= sizeof(uintptr_t);
     101        &&  !((KUPTR)pv1 & (sizeof(void *) - 1))
     102        &&  !((KUPTR)pv2 & (sizeof(void *) - 1)) )
     103    {
     104        KUPTR       *pu1 = pv1;
     105        const KUPTR *pu2 = pv2;
     106        while (cb >= sizeof(KUPTR))
     107        {
     108            cb -= sizeof(KUPTR);
    109109            *pu1++ = *pu2++;
    110110        }
    … …  
    129129}
    130130
    131 void *memset(void *pv, int ch, size_t cb)
     131void *memset(void *pv, int ch, KSIZE cb)
    132132{
    133133    void *pvStart = pv;
    … …  
    137137     */
    138138    if (    cb > 16
    139         &&  !((uintptr_t)pv & (sizeof(void *) - 1)))
    140     {
    141         uintptr_t  *pu = pv;
    142         uintptr_t   u = ch | (ch << 8);
     139        &&  !((KUPTR)pv & (sizeof(void *) - 1)))
     140    {
     141        KUPTR  *pu = pv;
     142        KUPTR   u = ch | (ch << 8);
    143143        u |= u << 16;
    144144#if defined(__AMD64__)
    … …  
    146146#endif
    147147
    148         while (cb >= sizeof(uintptr_t))
    149         {
    150             cb -= sizeof(uintptr_t);
     148        while (cb >= sizeof(KUPTR))
     149        {
     150            cb -= sizeof(KUPTR);
    151151            *pu++ = u;
    152152        }
    … …  
    180180
    181181
    182 int strncmp(const char *psz1, const char *psz2, size_t cch)
     182int strncmp(const char *psz1, const char *psz2, KSIZE cch)
    183183{
    184184    while (cch-- > 0)
    … …  
    207207}
    208208
    209 size_t strlen(const char *psz)
     209KSIZE strlen(const char *psz)
    210210{
    211211    const char *pszStart = psz;

  • trunk/kStuff/kLdr/kLdrHlp.c

    r3537 r3567  
    5454 * @param   cchVal      The size of the buffer pointed to by pszVal.
    5555 */
    56 int     kldrHlpGetEnv(const char *pszVar, char *pszVal, size_t cchVal)
     56int     kldrHlpGetEnv(const char *pszVar, char *pszVal, KSIZE cchVal)
    5757{
    5858#ifdef __OS2__
    … …  
    6464    if (!rc)
    6565    {
    66         size_t cch = kLdrHlpStrLen((const char *)pszValue);
     66        KSIZE cch = kLdrHlpStrLen((const char *)pszValue);
    6767        if (cchVal > cch)
    6868            kLdrHlpMemCopy(pszVal, pszValue, cch + 1);
    … …  
    9696
    9797/**
    98  * Gets an environment variable and converts it to a size_t.
     98 * Gets an environment variable and converts it to a KSIZE.
    9999 *
    100100 * @returns 0 and *pcb on success.
    … …  
    103103 * @param   pcb     Where to put the value.
    104104 */
    105 int     kldrHlpGetEnvUZ(const char *pszVar, size_t *pcb)
    106 {
    107     size_t      cb;
     105int     kldrHlpGetEnvUZ(const char *pszVar, KSIZE *pcb)
     106{
     107    KSIZE       cb;
    108108    unsigned    uBase;
    109109    char        szVal[64];
    110     size_t      cchVal = sizeof(szVal);
     110    KSIZE       cchVal = sizeof(szVal);
    111111    const char *psz;
    112112    int         rc;

  • trunk/kStuff/kLdr/kLdrHlp.h

    r3537 r3567  
    105105# endif
    106106# ifdef kLdrHlpStrChr_needed
    107 int     kLdrHlpStrNComp(const char *psz1, const char *psz2, size_t cch);
     107int     kLdrHlpStrNComp(const char *psz1, const char *psz2, KSIZE cch);
    108108# endif
    109109# ifdef kLdrHlpMemChr_needed
    110 void   *kLdrHlpMemChr(const void *pv, int ch, size_t cb);
     110void   *kLdrHlpMemChr(const void *pv, int ch, KSIZE cb);
    111111# endif
    112112# ifdef kLdrHlpMemMove_needed
    113 void   *kLdrHlpMemMove(void *pv1, const void *pv2, size_t cb);
     113void   *kLdrHlpMemMove(void *pv1, const void *pv2, KSIZE cb);
    114114# endif
    115115
    … …  
    169169#endif
    170170
    171 size_t  kLdrHlpStrNLen(const char *psz, size_t cchMax);
    172 int     kLdrHlpMemIComp(const void *pv1, const void *pv2, size_t cb);
     171KSIZE   kLdrHlpStrNLen(const char *psz, KSIZE cchMax);
     172int     kLdrHlpMemIComp(const void *pv1, const void *pv2, KSIZE cb);
    173173int     kLdrHlpStrIComp(const char *pv1, const char *pv2);
    174174
    … …  
    178178void    kldrHlpSemRelease(void);
    179179
    180 int     kldrHlpPageAlloc(void **ppv, size_t cb, KLDRPROT enmProt, unsigned fFixed);
    181 int     kldrHlpPageProtect(void *pv, size_t cb, KLDRPROT enmProt);
    182 int     kldrHlpPageFree(void *pv, size_t cb);
     180int     kldrHlpPageAlloc(void **ppv, KSIZE cb, KLDRPROT enmProt, unsigned fFixed);
     181int     kldrHlpPageProtect(void *pv, KSIZE cb, KLDRPROT enmProt);
     182int     kldrHlpPageFree(void *pv, KSIZE cb);
    183183
    184184int     kldrHlpHeapInit(void);
    185185void    kldrHlpHeapTerm(void);
    186 void    kldrHlpHeapDonate(void *pv, size_t cb);
    187 void *  kldrHlpAlloc(size_t cb);
    188 void *  kldrHlpAllocZ(size_t cb);
     186void    kldrHlpHeapDonate(void *pv, KSIZE cb);
     187void *  kldrHlpAlloc(KSIZE cb);
     188void *  kldrHlpAllocZ(KSIZE cb);
    189189void    kldrHlpFree(void *pv);
    190190
    191 int     kldrHlpGetEnv(const char *pszVar, char *pszVal, size_t cchVal);
    192 int     kldrHlpGetEnvUZ(const char *pszVar, size_t *pcb);
     191int     kldrHlpGetEnv(const char *pszVar, char *pszVal, KSIZE cchVal);
     192int     kldrHlpGetEnvUZ(const char *pszVar, KSIZE *pcb);
    193193char   *kldrHlpGetFilename(const char *pszFilename);
    194194char   *kldrHlpGetSuff(const char *pszFilename);
    … …  
    197197void    kldrHlpExit(int rc);
    198198void    kldrHlpSleep(unsigned cMillies);
    199 char   *kldrHlpInt2Ascii(char *psz, size_t cch, long lVal, unsigned iBase);
     199char   *kldrHlpInt2Ascii(char *psz, KSIZE cch, long lVal, unsigned iBase);
    200200void    kldrHlpAssertMsg(const char *pszExpr, const char *pszFile, unsigned iLine, const char *pszFunction);
    201201
    … …  
    233233        if ((cb)) \
    234234        { \
    235             uint8_t             __b; \
    236             uint8_t volatile *  __pb = (uint8_t volatile *)(buf); \
    237             size_t              __cbPage1 = 0x1000 - ((uintptr_t)(__pb) & 0xfff); /* ASSUMES page size! */ \
     235            KU8             __b; \
     236            KU8 volatile *  __pb = (KU8 volatile *)(buf); \
     237            KSIZE           __cbPage1 = 0x1000 - ((KUPTR)(__pb) & 0xfff); /* ASSUMES page size! */ \
    238238            __b = *__pb; *__pb = 0xff; *__pb = __b; \
    239239            if ((cb) > __cbPage1) \
    240240            { \
    241                 size_t  __cb = (cb) - __cbPage1; \
     241                KSIZE   __cb = (cb) - __cbPage1; \
    242242                __pb -= __cbPage1; \
    243243                for (;;) \

  • trunk/kStuff/kLdr/kLdrHlpHeap.c

    r3537 r3567  
    5858    struct KLDRHEAPBLOCK   *pPrev;
    5959    /** The size of this block including this header. */
    60     size_t                  cb;
     60    KSIZE                   cb;
    6161    /** The flags. */
    62     size_t                  fFlags;
     62    KSIZE                   fFlags;
    6363} KLDRHEAPBLOCK, *PKLDRHEAPBLOCK;
    6464
    6565/** Indicates whether the block is free (set) or allocated (clear). */
    66 #define KLDRHEAPBLOCK_FLAG_FREE     ((size_t)1)
     66#define KLDRHEAPBLOCK_FLAG_FREE     ((KSIZE)1)
    6767/** Valid flag mask. */
    68 #define KLDRHEAPBLOCK_FLAG_MASK     ((size_t)1)
     68#define KLDRHEAPBLOCK_FLAG_MASK     ((KSIZE)1)
    6969
    7070/** Checks if the block is freed. */
    … …  
    7575 * Assumes pB1 < pB2. */
    7676#define KLDRHEAPBLOCK_IS_ADJACENT(pB1, pB2) \
    77     ( ((uintptr_t)(pB1) + (pB1)->cb) == (uintptr_t)(pB2) )
     77    ( ((KUPTR)(pB1) + (pB1)->cb) == (KUPTR)(pB2) )
    7878
    7979/** The block alignment. */
    … …  
    9393        KLDRHEAP_ASSERT(!((pBlock)->fFlags & ~KLDRHEAPBLOCK_FLAG_MASK)); \
    9494        KLDRHEAP_ASSERT(!((pBlock)->cb & (KLDRHEAPBLOCK_ALIGNMENT - 1))); \
    95         KLDRHEAP_ASSERT((uintptr_t)(pBlock)->pPrev < (uintptr_t)(pBlock)); \
    96         KLDRHEAP_ASSERT((uintptr_t)(pBlock)->pNext > (uintptr_t)(pBlock) || !(pBlock)->pNext); \
     95        KLDRHEAP_ASSERT((KUPTR)(pBlock)->pPrev < (KUPTR)(pBlock)); \
     96        KLDRHEAP_ASSERT((KUPTR)(pBlock)->pNext > (KUPTR)(pBlock) || !(pBlock)->pNext); \
    9797    } while (0)
    9898
    … …  
    100100    do { \
    101101        KLDRHEAP_ASSERT_BLOCK(pHeap, &(pFree)->Core); \
    102         KLDRHEAP_ASSERT((uintptr_t)(pFree)->pPrev < (uintptr_t)(pFree)); \
    103         KLDRHEAP_ASSERT((uintptr_t)(pFree)->pNext > (uintptr_t)(pFree) || !(pFree)->pNext); \
     102        KLDRHEAP_ASSERT((KUPTR)(pFree)->pPrev < (KUPTR)(pFree)); \
     103        KLDRHEAP_ASSERT((KUPTR)(pFree)->pNext > (KUPTR)(pFree) || !(pFree)->pNext); \
    104104    } while (0)
    105105
    … …  
    133133    void   *pvBase;
    134134    /** The length of the segment (in bytes). */
    135     size_t  cb;
     135    KSIZE   cb;
    136136} KLDRHEAPSEG, *PKLDRHEAPSEG;
    137137
    … …  
    144144    struct KLDRHEAPSEGS    *pNext;
    145145    /** The number of segments used. */
    146     uint32_t                cSegs;
     146    KU32                    cSegs;
    147147    /** Array of chunks. */
    148148    KLDRHEAPSEG             aSegs[64];
    … …  
    181181static int      kLdrHeapInit(PKLDRHEAPANCHOR pHeap);
    182182static void     kLdrHeapDelete(PKLDRHEAPANCHOR pHeap);
    183 static void *   kLdrHeapAlloc(PKLDRHEAPANCHOR pHeap, size_t cb);
     183static void *   kLdrHeapAlloc(PKLDRHEAPANCHOR pHeap, KSIZE cb);
    184184static void     kLdrHeapFree(PKLDRHEAPANCHOR pHeap, void *pv);
    185 static void     kLdrHeapDonate(PKLDRHEAPANCHOR pHeap, void *pv, size_t cb);
    186 static int      kLdrHeapSegAlloc(PKLDRHEAPSEG pSeg, size_t cb);
     185static void     kLdrHeapDonate(PKLDRHEAPANCHOR pHeap, void *pv, KSIZE cb);
     186static int      kLdrHeapSegAlloc(PKLDRHEAPSEG pSeg, KSIZE cb);
    187187static void     kLdrHeapSegFree(PKLDRHEAPSEG pSeg);
    188188
    … …  
    214214 * @param   cb      The requested heap block size.
    215215 */
    216 void *kldrHlpAlloc(size_t cb)
     216void *kldrHlpAlloc(KSIZE cb)
    217217{
    218218    return kLdrHeapAlloc(&g_Heap, cb);
    … …  
    226226 * @param   cb      The requested heap block size.
    227227 */
    228 void *kldrHlpAllocZ(size_t cb)
     228void *kldrHlpAllocZ(KSIZE cb)
    229229{
    230230    void *pv = kLdrHeapAlloc(&g_Heap, cb);
    … …  
    252252 * @param   cb      The amount of memory.
    253253 */
    254 void kldrHlpHeapDonate(void *pv, size_t cb)
     254void kldrHlpHeapDonate(void *pv, KSIZE cb)
    255255{
    256256    kLdrHeapDonate(&g_Heap, pv, cb);
    … …  
    293293    {
    294294        /* find the tail. */
    295         uint32_t        iSeg;
     295        KU32            iSeg;
    296296        PKLDRHEAPSEGS   pSegs = pHeap->SegsHead.pNext;
    297297        if (!pSegs)
    … …  
    322322 * Internal heap block allocator.
    323323 */
    324 static void *   kldrHeapAllocSub(PKLDRHEAPANCHOR pHeap, size_t cb)
     324static void *   kldrHeapAllocSub(PKLDRHEAPANCHOR pHeap, KSIZE cb)
    325325{
    326326    /*
    327327     * Find a fitting free block.
    328328     */
    329     const size_t    cbReq = KLDR_ALIGN_Z(cb + sizeof(KLDRHEAPBLOCK), KLDRHEAPBLOCK_ALIGNMENT);
     329    const KSIZE     cbReq = KLDR_ALIGN_Z(cb + sizeof(KLDRHEAPBLOCK), KLDRHEAPBLOCK_ALIGNMENT);
    330330    PKLDRHEAPFREE   pCur = pHeap->pFreeHead;
    331331    while (pCur)
    … …  
    376376        pCur->Core.cb -= cbReq;
    377377
    378         pNew = (PKLDRHEAPBLOCK)((uintptr_t)pCur + pCur->Core.cb);
     378        pNew = (PKLDRHEAPBLOCK)((KUPTR)pCur + pCur->Core.cb);
    379379        pNew->fFlags = 0;
    380380        pNew->cb = cbReq;
    … …  
    415415 * @param   cb      The requested heap block size.
    416416 */
    417 static void *   kLdrHeapAlloc(PKLDRHEAPANCHOR pHeap, size_t cb)
     417static void *   kLdrHeapAlloc(PKLDRHEAPANCHOR pHeap, KSIZE cb)
    418418{
    419419    void *pv;
    … …  
    563563 * @param cb    Size of the donated memory.
    564564 */
    565 static void     kLdrHeapDonate(PKLDRHEAPANCHOR pHeap, void *pv, size_t cb)
     565static void     kLdrHeapDonate(PKLDRHEAPANCHOR pHeap, void *pv, KSIZE cb)
    566566{
    567567    PKLDRHEAPBLOCK pBlock;
    … …  
    576576     * Align the donation on a heap block boundrary.
    577577     */
    578     if ((uintptr_t)pv & (KLDRHEAPBLOCK_ALIGNMENT - 1))
    579     {
    580         cb -= (uintptr_t)pv & 31;
     578    if ((KUPTR)pv & (KLDRHEAPBLOCK_ALIGNMENT - 1))
     579    {
     580        cb -= (KUPTR)pv & 31;
    581581        pv = KLDR_ALIGN_P(pv, KLDRHEAPBLOCK_ALIGNMENT);
    582582    }
    583     cb &= ~(size_t)(KLDRHEAPBLOCK_ALIGNMENT - 1);
     583    cb &= ~(KSIZE)(KLDRHEAPBLOCK_ALIGNMENT - 1);
    584584
    585585    /*
    … …  
    593593
    594594    /* insert */
    595     if ((uintptr_t)pBlock < (uintptr_t)pHeap->pHead)
     595    if ((KUPTR)pBlock < (KUPTR)pHeap->pHead)
    596596    {
    597597        /* head */
    … …  
    600600        pHeap->pHead = pBlock;
    601601    }
    602     else if ((uintptr_t)pBlock > (uintptr_t)pHeap->pTail)
     602    else if ((KUPTR)pBlock > (KUPTR)pHeap->pTail)
    603603    {
    604604        if (pHeap->pTail)
    … …  
    624624        {
    625625            KLDRHEAP_ASSERT_BLOCK(pHeap, pCur);
    626             if ((uintptr_t)pCur > (uintptr_t)pBlock)
     626            if ((KUPTR)pCur > (KUPTR)pBlock)
    627627                break;
    628628            pPrev = pCur;
    … …  
    650650 * @param   cbMin   The minimum segment size.
    651651 */
    652 static int kLdrHeapSegAlloc(PKLDRHEAPSEG pSeg, size_t cbMin)
     652static int kLdrHeapSegAlloc(PKLDRHEAPSEG pSeg, KSIZE cbMin)
    653653{
    654654#ifdef __OS2__
    655655    APIRET rc;
    656656
    657     pSeg->cb = (cbMin + 0xffff) & ~(size_t)0xffff;
     657    pSeg->cb = (cbMin + 0xffff) & ~(KSIZE)0xffff;
    658658    pSeg->pvBase = NULL;
    659659    rc = DosAllocMem(&pSeg->pvBase, pSeg->cb, PAG_COMMIT | PAG_READ | PAG_WRITE | OBJ_ANY);
    … …  
    668668
    669669#elif defined(__WIN__)
    670     pSeg->cb = (cbMin + 0xffff) & ~(size_t)0xffff;
     670    pSeg->cb = (cbMin + 0xffff) & ~(KSIZE)0xffff;
    671671    pSeg->pvBase = VirtualAlloc(NULL, pSeg->cb, MEM_COMMIT, PAGE_READWRITE);
    672672    if (!pSeg->pvBase)

  • trunk/kStuff/kLdr/kLdrHlpMem.c

    r3537 r3567  
    5252static void            *g_pvStub = NULL;
    5353/** The size of the stub object - 0 if no stub. */
    54 static size_t           g_cbStub = 0;
     54static KSIZE            g_cbStub = 0;
    5555
    5656#elif defined(__WIN__)
    … …  
    107107 * @param   enmProt     The new protection. Copy-on-write is invalid.
    108108 */
    109 int     kldrHlpPageAlloc(void **ppv, size_t cb, KLDRPROT enmProt, unsigned fFixed)
     109int     kldrHlpPageAlloc(void **ppv, KSIZE cb, KLDRPROT enmProt, unsigned fFixed)
    110110{
    111111#ifdef __OS2__
    … …  
    162162 * @param   enmProt     The new protection. Copy-on-write is invalid.
    163163 */
    164 int     kldrHlpPageProtect(void *pv, size_t cb, KLDRPROT enmProt)
     164int     kldrHlpPageProtect(void *pv, KSIZE cb, KLDRPROT enmProt)
    165165{
    166166#ifdef __OS2__
    … …  
    184184            if (rc)
    185185                return rc;
    186             pv = (void *)((uintptr_t)pv + 0x1000);
     186            pv = (void *)((KUPTR)pv + 0x1000);
    187187            cb -= 0x1000;
    188188        }
    … …  
    215215 * @param   cb          The byte count requested from kldrHlpPageAlloc().
    216216 */
    217 int     kldrHlpPageFree(void *pv, size_t cb)
     217int     kldrHlpPageFree(void *pv, KSIZE cb)
    218218{
    219219#ifdef __OS2__
    … …  
    223223     * Deal with any portion overlapping with the stub.
    224224     */
    225     uintptr_t offStub = (uintptr_t)pv - (uintptr_t)g_pvStub;
     225    KUPTR offStub = (KUPTR)pv - (KUPTR)g_pvStub;
    226226    if (offStub < g_cbStub)
    227227    {
    228228        /* decommit the pages in the stub. */
    229         size_t cbStub = KLDR_MIN(g_cbStub - offStub, cb);
     229        KSIZE cbStub = KLDR_MIN(g_cbStub - offStub, cb);
    230230        rc = DosSetMem(pv, cbStub, PAG_DECOMMIT);
    231231        if (rc)
    … …  
    236236                if (!DosSetMem(pv, 0x1000, PAG_DECOMMIT))
    237237                    rc = 0;
    238                 pv = (void *)((uintptr_t)pv + 0x1000);
     238                pv = (void *)((KUPTR)pv + 0x1000);
    239239                cbStub -= 0x1000;
    240240                cb -= 0x1000;
    … …  
    251251            if (!cb)
    252252                return 0;
    253             pv = (void *)((uintptr_t)pv + cbStub);
     253            pv = (void *)((KUPTR)pv + cbStub);
    254254        }
    255255    }

  • trunk/kStuff/kLdr/kLdrHlpStr.c

    r3537 r3567  
    4242 * @param   iBase       The base to format it. (2,8,10 or 16)
    4343 */
    44 char *kldrHlpInt2Ascii(char *psz, size_t cch, long lVal, unsigned iBase)
     44char *kldrHlpInt2Ascii(char *psz, KSIZE cch, long lVal, unsigned iBase)
    4545{
    4646    static const char s_szDigits[] = "0123456789abcdefghijklmnopqrstuvwxyz";
    … …  
    8181
    8282
    83 size_t  kLdrHlpStrNLen(const char *psz, size_t cchMax)
     83KSIZE  kLdrHlpStrNLen(const char *psz, KSIZE cchMax)
    8484{
    8585    const char * const pszStart = psz;
    … …  
    9090
    9191
    92 int     kLdrHlpMemIComp(const void *pv1, const void *pv2, size_t cb)
     92int     kLdrHlpMemIComp(const void *pv1, const void *pv2, KSIZE cb)
    9393{
    94     const uint8_t *pb1 = (const uint8_t *)pv1;
    95     const uint8_t *pb2 = (const uint8_t *)pv2;
     94    const KU8 *pb1 = (const KU8 *)pv1;
     95    const KU8 *pb2 = (const KU8 *)pv2;
    9696    while (cb-- > 0)
    9797    {
    9898        if (*pb1 != *pb2)
    9999        {
    100             const uint8_t u1 = *pb1 >= 'a' && *pb1 <= 'z' ? *pb1 - 'a' : *pb1;
    101             const uint8_t u2 = *pb2 >= 'a' && *pb2 <= 'z' ? *pb2 - 'a' : *pb2;
     100            const KU8 u1 = *pb1 >= 'a' && *pb1 <= 'z' ? *pb1 - 'a' : *pb1;
     101            const KU8 u2 = *pb2 >= 'a' && *pb2 <= 'z' ? *pb2 - 'a' : *pb2;
    102102            if (u1 != u2)
    103103                return (int)*pb1 - (int)*pb2;
    … …  
    112112int     kLdrHlpStrIComp(const char *pv1, const char *pv2)
    113113{
    114     const uint8_t *pb1 = (const uint8_t *)pv1;
    115     const uint8_t *pb2 = (const uint8_t *)pv2;
     114    const KU8 *pb1 = (const KU8 *)pv1;
     115    const KU8 *pb2 = (const KU8 *)pv2;
    116116    for (;;)
    117117    {
    118118        if (*pb1 != *pb2)
    119119        {
    120             const uint8_t u1 = *pb1 >= 'a' && *pb1 <= 'z' ? *pb1 - 'a' : *pb1;
    121             const uint8_t u2 = *pb2 >= 'a' && *pb2 <= 'z' ? *pb2 - 'a' : *pb2;
     120            const KU8 u1 = *pb1 >= 'a' && *pb1 <= 'z' ? *pb1 - 'a' : *pb1;
     121            const KU8 u2 = *pb2 >= 'a' && *pb2 <= 'z' ? *pb2 - 'a' : *pb2;
    122122            if (u1 != u2)
    123123                return (int)*pb1 - (int)*pb2;
    … …  
    147147
    148148#ifdef kLdrHlpMemChr_needed
    149 void   *kLdrHlpMemChr(const void *pv, int ch, size_t cb)
     149void   *kLdrHlpMemChr(const void *pv, int ch, KSIZE cb)
    150150{
    151     const uint8_t *pb = (const uint8_t *)pv;
    152     const uint8_t  b = (uint8_t)ch;
     151    const KU8 *pb = (const KU8 *)pv;
     152    const KU8  b = (KU8)ch;
    153153    while (cb-- > 0)
    154154    {
    … …  
    163163
    164164#ifdef kLdrHlpMemMove_needed
    165 void   *kLdrHlpMemMove(void *pv1, const void *pv2, size_t cb)
     165void   *kLdrHlpMemMove(void *pv1, const void *pv2, KSIZE cb)
    166166{
    167     uint8_t        *pbDst = (uint8_t *)pv1;
    168     const uint8_t  *pbSrc = (const uint8_t *)pv2;
     167    KU8            *pbDst = (KU8 *)pv1;
     168    const KU8      *pbSrc = (const KU8 *)pv2;
    169169    while (cb-- > 0)
    170170    {
    171         const uint8_t b = *pbSrc++;
     171        const KU8 b = *pbSrc++;
    172172        *pbDst++ = b;
    173173    }
    … …  
    178178
    179179#ifdef kLdrHlpStrNComp_needed
    180 int     kLdrHlpStrNComp(const char *psz1, const char *psz2, size_t cch)
     180int     kLdrHlpStrNComp(const char *psz1, const char *psz2, KSIZE cch)
    181181{
    182182    while (cch-- > 0)
    … …  
    191191    return 0;
    192192}
    193 #endif 
     193#endif
    194194

  • trunk/kStuff/kLdr/kLdrInternal.h

    r3537 r3567  
    5050 * @{ */
    5151/** ELF signature ("\x7fELF"). */
    52 #define IMAGE_ELF_SIGNATURE         KLDR_LE2H_U32(0x7f | ('E' << 8) | ((uint32_t)'L' << 16) | ((uint32_t)'F' << 24))
     52#define IMAGE_ELF_SIGNATURE         KLDR_LE2H_U32(0x7f | ('E' << 8) | ((KU32)'L' << 16) | ((KU32)'F' << 24))
    5353/** PE signature ("PE\0\0"). */
    5454#define IMAGE_NT_SIGNATURE          KLDR_LE2H_U32('P' | ('E' << 8))
    … …  
    6262#define IMAGE_DOS_SIGNATURE         KLDR_LE2H_U16('M' | ('Z' << 8))
    6363/** The FAT signature (universal binaries). */
    64 #define IMAGE_FAT_SIGNATURE         UINT32_C(0xcafebabe)
     64#define IMAGE_FAT_SIGNATURE         KU32_C(0xcafebabe)
    6565/** The FAT signature (universal binaries), other endian. */
    66 #define IMAGE_FAT_SIGNATURE_OE      UINT32_C(0xbebafeca)
     66#define IMAGE_FAT_SIGNATURE_OE      KU32_C(0xbebafeca)
    6767/** The 32-bit Mach-O signature. */
    68 #define IMAGE_MACHO32_SIGNATURE     UINT32_C(0xfeedface)
     68#define IMAGE_MACHO32_SIGNATURE     KU32_C(0xfeedface)
    6969/** The 32-bit Mach-O signature, other endian. */
    70 #define IMAGE_MACHO32_SIGNATURE_OE  UINT32_C(0xcefaedfe)
     70#define IMAGE_MACHO32_SIGNATURE_OE  KU32_C(0xcefaedfe)
    7171/** The 64-bit Mach-O signature. */
    72 #define IMAGE_MACHO64_SIGNATURE     UINT32_C(0xfeedfacf)
     72#define IMAGE_MACHO64_SIGNATURE     KU32_C(0xfeedfacf)
    7373/** The 64-bit Mach-O signature, other endian. */
    74 #define IMAGE_MACHO64_SIGNATURE_OE  UINT32_C(0xfefaedfe)
     74#define IMAGE_MACHO64_SIGNATURE_OE  KU32_C(0xfefaedfe)
    7575/** @} */
    7676
    … …  
    245245{
    246246    /** Magic number. */
    247     uint32_t            u32MagicHead;
     247    KU32                u32MagicHead;
    248248    /** The module state. */
    249249    KLDRSTATE           enmState;
    … …  
    253253    HKLDRMOD            hMod;
    254254    /** The total number of references. */
    255     uint32_t            cRefs;
     255    KU32                cRefs;
    256256    /** The number of dependency references. */
    257     uint32_t            cDepRefs;
     257    KU32                cDepRefs;
    258258    /** The number of dynamic load references. */
    259     uint32_t            cDynRefs;
     259    KU32                cDynRefs;
    260260    /** Set if this is the executable module.
    261261     * When clear, the module is a shared object or relocatable object. */
    262     uint32_t            fExecutable : 1;
     262    KU32                fExecutable : 1;
    263263    /** Global DLL (set) or specific DLL (clear). */
    264     uint32_t            fGlobalOrSpecific : 1;
     264    KU32                fGlobalOrSpecific : 1;
    265265    /** Whether the module contains bindable symbols in the global unix namespace. */
    266     uint32_t            fBindable : 1;
     266    KU32                fBindable : 1;
    267267    /** Set if linked into the global init list. */
    268     uint32_t            fInitList : 1;
     268    KU32                fInitList : 1;
    269269    /** Already loaded or checked prerequisites.
    270270     * This flag is used when loading prerequisites, when set it means that
    271271     * this module is already seen and shouldn't be processed again. */
    272     uint32_t            fAlreadySeen : 1;
     272    KU32                fAlreadySeen : 1;
    273273    /** Set if the module is currently mapped.
    274274     * This is used to avoid unnecessary calls to kLdrModUnmap during cleanup. */
    275     uint32_t            fMapped : 1;
     275    KU32                fMapped : 1;
    276276    /** Set if TLS allocation has been done. (part of the mapping). */
    277     uint32_t            fAllocatedTLS : 1;
     277    KU32                fAllocatedTLS : 1;
    278278    /** Reserved for future use. */
    279     uint32_t            f25Reserved : 25;
     279    KU32                f25Reserved : 25;
    280280    /** The load list linkage. */
    281281    struct
    … …  
    309309
    310310    /** The number of prerequisite modules in the prereq array. */
    311     uint32_t            cPrereqs;
     311    KU32                cPrereqs;
    312312    /** Pointer to an array of prerequisite module pointers.
    313313     * This array is only filled when in the states starting with
    … …  
    317317
    318318    /** Magic number. */
    319     uint32_t            u32MagicTail;
     319    KU32                u32MagicTail;
    320320} KLDRDYLDMOD, *PKLDRDYLDMOD, **PPKLDRDYLDMOD;
    321321
    … …  
    344344int kldrDyldFailure(int rc, const char *pszFormat, ...);
    345345
    346 int kldrDyldOSStartExe(uintptr_t uMainEntrypoint, void *pvStack, size_t cbStack);
    347 void *kldrDyldOSAllocStack(size_t cb);
     346int kldrDyldOSStartExe(KUPTR uMainEntrypoint, void *pvStack, KSIZE cbStack);
     347void *kldrDyldOSAllocStack(KSIZE cb);
    348348
    349349int kldrDyldFindInit(void);
    … …  
    357357
    358358
    359 int kldrDyldModCreate(PKLDRRDR pRdr, uint32_t fFlags, PPKLDRDYLDMOD ppMod);
     359int kldrDyldModCreate(PKLDRRDR pRdr, KU32 fFlags, PPKLDRDYLDMOD ppMod);
    360360void kldrDyldModDestroy(PKLDRDYLDMOD pMod);
    361361void kldrDyldModAddRef(PKLDRDYLDMOD pMod);
    … …  
    381381int kldrDyldModAttachThread(PKLDRDYLDMOD pMod);
    382382void kldrDyldModDetachThread(PKLDRDYLDMOD pMod);
    383 int kldrDyldModGetMainStack(PKLDRDYLDMOD pMod, void **ppvStack, size_t *pcbStack);
     383int kldrDyldModGetMainStack(PKLDRDYLDMOD pMod, void **ppvStack, KSIZE *pcbStack);
    384384int kldrDyldModStartExe(PKLDRDYLDMOD pMod);
    385385
    386 int kldrDyldModGetName(PKLDRDYLDMOD pMod, char *pszName, size_t cchName);
    387 int kldrDyldModGetFilename(PKLDRDYLDMOD pMod, char *pszFilename, size_t cchFilename);
    388 int kldrDyldModQuerySymbol(PKLDRDYLDMOD pMod, uint32_t uSymbolOrdinal, const char *pszSymbolName, uintptr_t *puValue, uint32_t *pfKind);
     386int kldrDyldModGetName(PKLDRDYLDMOD pMod, char *pszName, KSIZE cchName);
     387int kldrDyldModGetFilename(PKLDRDYLDMOD pMod, char *pszFilename, KSIZE cchFilename);
     388int kldrDyldModQuerySymbol(PKLDRDYLDMOD pMod, KU32 uSymbolOrdinal, const char *pszSymbolName, KUPTR *puValue, KU32 *pfKind);
    389389
    390390
    … …  
    421421extern void            *g_pvkLdrDyldMainStack;
    422422/** The size of the main stack object. */
    423 extern size_t           g_cbkLdrDyldMainStack;
     423extern KSIZE            g_cbkLdrDyldMainStack;
    424424
    425425/** The global error buffer. */

  • trunk/kStuff/kLdr/kLdrMod.c

    r3537 r3567  
    140140    union
    141141    {
    142         uint32_t    u32;
    143         uint16_t    u16;
    144         uint16_t    au16[2];
    145         uint8_t     au8[4];
     142        KU32        u32;
     143        KU16        u16;
     144        KU16        au16[2];
     145        KU8         au8[4];
    146146    }           u;
    147147    KLDRFOFF    offHdr = 0;
    … …  
    258258 *                          On output the symbol kind. (optional)
    259259 */
    260 int     kLdrModQuerySymbol(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, uint32_t iSymbol,
    261                            const char *pchSymbol, size_t cchSymbol, const char *pszVersion,
    262                            PFNKLDRMODGETIMPORT pfnGetForwarder, void *pvUser, PKLDRADDR puValue, uint32_t *pfKind)
     260int     kLdrModQuerySymbol(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, KU32 iSymbol,
     261                           const char *pchSymbol, KSIZE cchSymbol, const char *pszVersion,
     262                           PFNKLDRMODGETIMPORT pfnGetForwarder, void *pvUser, PKLDRADDR puValue, KU32 *pfKind)
    263263{
    264264    KLDRMOD_VALIDATE(pMod);
    … …  
    288288 * @param   pvUser          The user argument to the callback function.
    289289 */
    290 int     kLdrModEnumSymbols(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, uint32_t fFlags,
     290int     kLdrModEnumSymbols(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, KU32 fFlags,
    291291                           PFNKLDRMODENUMSYMS pfnCallback, void *pvUser)
    292292{
    … …  
    310310 * @param   cchName         The size of the name buffer.
    311311 */
    312 int     kLdrModGetImport(PKLDRMOD pMod, const void *pvBits, uint32_t iImport, char *pszName, size_t cchName)
     312int     kLdrModGetImport(PKLDRMOD pMod, const void *pvBits, KU32 iImport, char *pszName, KSIZE cchName)
    313313{
    314314    KLDRMOD_VALIDATE(pMod);
    … …  
    325325 *                          This can be used by some module interpreters to reduce memory consumption.
    326326 */
    327 int32_t kLdrModNumberOfImports(PKLDRMOD pMod, const void *pvBits)
     327KI32 kLdrModNumberOfImports(PKLDRMOD pMod, const void *pvBits)
    328328{
    329329    KLDRMOD_VALIDATE(pMod);
    … …  
    417417 * @param   pvUser          The user argument for the callback.
    418418 */
    419 int     kLdrModQueryResource(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, uint32_t idType, const char *pszType,
    420                              uint32_t idName, const char *pszName, uint32_t idLang, PKLDRADDR pAddrRsrc, size_t *pcbRsrc)
     419int     kLdrModQueryResource(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, KU32 idType, const char *pszType,
     420                             KU32 idName, const char *pszName, KU32 idLang, PKLDRADDR pAddrRsrc, KSIZE *pcbRsrc)
    421421{
    422422    KLDRMOD_VALIDATE(pMod);
    … …  
    453453 * @param   pvUser          The user argument for the callback.
    454454 */
    455 int     kLdrModEnumResources(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, uint32_t idType, const char *pszType,
    456                              uint32_t idName, const char *pszName, uint32_t idLang, PFNKLDRENUMRSRC pfnCallback, void *pvUser)
     455int     kLdrModEnumResources(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, KU32 idType, const char *pszType,
     456                             KU32 idName, const char *pszName, KU32 idLang, PFNKLDRENUMRSRC pfnCallback, void *pvUser)
    457457{
    458458    KLDRMOD_VALIDATE(pMod);
    … …  
    615615 * @param   uHandle         The module handle to use if any of the init functions requires the module handle.
    616616 */
    617 int     kLdrModCallInit(PKLDRMOD pMod, uintptr_t uHandle)
     617int     kLdrModCallInit(PKLDRMOD pMod, KUPTR uHandle)
    618618{
    619619    KLDRMOD_VALIDATE(pMod);
    … …  
    631631 * @remark  Termination function failure will be ignored by the module interpreter.
    632632 */
    633 int     kLdrModCallTerm(PKLDRMOD pMod, uintptr_t uHandle)
     633int     kLdrModCallTerm(PKLDRMOD pMod, KUPTR uHandle)
    634634{
    635635    KLDRMOD_VALIDATE(pMod);
    … …  
    650650 * @remark  Detach function failure will be ignored by the module interpreter.
    651651 */
    652 int     kLdrModCallThread(PKLDRMOD pMod, uintptr_t uHandle, unsigned fAttachingOrDetaching)
     652int     kLdrModCallThread(PKLDRMOD pMod, KUPTR uHandle, unsigned fAttachingOrDetaching)
    653653{
    654654    KLDRMOD_VALIDATE(pMod);

  • trunk/kStuff/kLdr/kLdrModELF32.h

    r3537 r3567  
    3737 */
    3838
    39 typedef uint32_t        Elf32_Addr;
    40 typedef uint16_t        Elf32_Half;
    41 typedef uint32_t        Elf32_Off;
    42 typedef int32_t         Elf32_Sword;
    43 typedef uint32_t        Elf32_Word;
    44 typedef uint32_t        Elf32_Size;
     39typedef KU32    Elf32_Addr;
     40typedef KU16    Elf32_Half;
     41typedef KU32    Elf32_Off;
     42typedef KI32            Elf32_Sword;
     43typedef KU32    Elf32_Word;
     44typedef KU32    Elf32_Size;
    4545typedef Elf32_Off       Elf32_Hashelt;
    4646

  • trunk/kStuff/kLdr/kLdrModELF64.h

    r3537 r3567  
    3737 */
    3838
    39 typedef uint64_t        Elf64_Addr;
    40 typedef uint32_t        Elf64_Half;
    41 typedef uint64_t        Elf64_Off;
    42 typedef int64_t         Elf64_Sword;
    43 typedef uint64_t        Elf64_Word;
    44 typedef uint64_t        Elf64_Size;
    45 typedef uint16_t        Elf64_Quarter;
     39typedef KU64    Elf64_Addr;
     40typedef KU32    Elf64_Half;
     41typedef KU64    Elf64_Off;
     42typedef KI64    Elf64_Sword;
     43typedef KU64    Elf64_Word;
     44typedef KU64    Elf64_Size;
     45typedef KU16    Elf64_Quarter;
    4646
    4747/*

  • trunk/kStuff/kLdr/kLdrModELFCommon.h

    r3537 r3567  
    4444
    4545typedef struct {
    46         uint32_t        n_namesz;       /* Length of name. */
    47         uint32_t        n_descsz;       /* Length of descriptor. */
    48         uint32_t        n_type;         /* Type of this note. */
     46        KU32    n_namesz;       /* Length of name. */
     47        KU32    n_descsz;       /* Length of descriptor. */
     48        KU32    n_type;         /* Type of this note. */
    4949} Elf_Note;
    5050

  • trunk/kStuff/kLdr/kLdrModLX.c

    r3537 r3567  
    6565    const void             *pvMapping;
    6666    /** The size of the mapped LX image. */
    67     size_t                  cbMapped;
     67    KSIZE                   cbMapped;
    6868    /** Reserved flags. */
    69     uint32_t                f32Reserved;
     69    KU32                    f32Reserved;
    7070
    7171    /** The offset of the LX header. */
    … …  
    7676    /** Pointer to the loader section.
    7777     * Allocated together with this strcture. */
    78     const uint8_t          *pbLoaderSection;
     78    const KU8              *pbLoaderSection;
    7979    /** Pointer to the last byte in the loader section. */
    80     const uint8_t          *pbLoaderSectionLast;
     80    const KU8              *pbLoaderSectionLast;
    8181    /** Pointer to the object table in the loader section. */
    8282    const struct o32_obj   *paObjs;
    … …  
    8686    const struct rsrc32    *paRsrcs;
    8787    /** Pointer to the resident name table in the loader section. */
    88     const uint8_t          *pbResNameTab;
     88    const KU8              *pbResNameTab;
    8989    /** Pointer to the entry table in the loader section. */
    90     const uint8_t          *pbEntryTab;
     90    const KU8              *pbEntryTab;
    9191
    9292    /** Pointer to the non-resident name table. */
    93     uint8_t                *pbNonResNameTab;
     93    KU8                    *pbNonResNameTab;
    9494    /** Pointer to the last byte in the non-resident name table. */
    95     const uint8_t          *pbNonResNameTabLast;
     95    const KU8              *pbNonResNameTabLast;
    9696
    9797    /** Pointer to the fixup section. */
    98     uint8_t                *pbFixupSection;
     98    KU8                    *pbFixupSection;
    9999    /** Pointer to the last byte in the fixup section. */
    100     const uint8_t          *pbFixupSectionLast;
     100    const KU8              *pbFixupSectionLast;
    101101    /** Pointer to the fixup page table within pvFixupSection. */
    102     const uint32_t         *paoffPageFixups;
     102    const KU32             *paoffPageFixups;
    103103    /** Pointer to the fixup record table within pvFixupSection. */
    104     const uint8_t          *pbFixupRecs;
     104    const KU8              *pbFixupRecs;
    105105    /** Pointer to the import module name table within pvFixupSection. */
    106     const uint8_t          *pbImportMods;
     106    const KU8              *pbImportMods;
    107107    /** Pointer to the import module name table within pvFixupSection. */
    108     const uint8_t          *pbImportProcs;
     108    const KU8              *pbImportProcs;
    109109} KLDRMODLX, *PKLDRMODLX;
    110110
    … …  
    117117                                 PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
    118118static int kldrModLXDoCreate(PKLDRRDR pRdr, KLDRFOFF offNewHdr, PKLDRMODLX *ppModLX);
    119 static const uint8_t *kldrModLXDoNameTableLookupByOrdinal(const uint8_t *pbNameTable, int32_t cbNameTable, uint32_t iOrdinal);
    120 static int kldrModLXDoNameLookup(PKLDRMODLX pModLX, const char *pchSymbol, uint32_t cchSymbol, uint32_t *piSymbol);
    121 static const uint8_t *kldrModLXDoNameTableLookupByName(const uint8_t *pbNameTable, int32_t cbNameTable,
    122                                                        const char *pchSymbol, size_t cchSymbol);
     119static const KU8 *kldrModLXDoNameTableLookupByOrdinal(const KU8 *pbNameTable, KI32 cbNameTable, KU32 iOrdinal);
     120static int kldrModLXDoNameLookup(PKLDRMODLX pModLX, const char *pchSymbol, KU32 cchSymbol, KU32 *piSymbol);
     121static const KU8 *kldrModLXDoNameTableLookupByName(const KU8 *pbNameTable, KI32 cbNameTable,
     122                                                       const char *pchSymbol, KSIZE cchSymbol);
    123123static int kldrModLXDoLoadBits(PKLDRMODLX pModLX, void *pvBits);
    124 static int kldrModLXDoIterDataUnpacking(uint8_t *pbDst, const uint8_t *pbSrc, int cbSrc);
    125 static int kldrModLXDoIterData2Unpacking(uint8_t *pbDst, const uint8_t *pbSrc, int cbSrc);
    126 static void kLdrModLXMemCopyW(uint8_t *pbDst, const uint8_t *pbSrc, int cb);
     124static int kldrModLXDoIterDataUnpacking(KU8 *pbDst, const KU8 *pbSrc, int cbSrc);
     125static int kldrModLXDoIterData2Unpacking(KU8 *pbDst, const KU8 *pbSrc, int cbSrc);
     126static void kLdrModLXMemCopyW(KU8 *pbDst, const KU8 *pbSrc, int cb);
    127127static int kldrModLXDoProtect(PKLDRMODLX pModLX, void *pvBits, unsigned fUnprotectOrProtect);
    128 static int kldrModLXDoCallDLL(PKLDRMODLX pModLX, unsigned uOp, uintptr_t uHandle);
     128static int kldrModLXDoCallDLL(PKLDRMODLX pModLX, unsigned uOp, KUPTR uHandle);
    129129static int kldrModLXDoForwarderQuery(PKLDRMODLX pModLX, const struct e32_entry *pEntry,
    130                                      PFNKLDRMODGETIMPORT pfnGetForwarder, void *pvUser, PKLDRADDR puValue, uint32_t *pfKind);
     130                                     PFNKLDRMODGETIMPORT pfnGetForwarder, void *pvUser, PKLDRADDR puValue, KU32 *pfKind);
    131131static int kldrModLXDoLoadFixupSection(PKLDRMODLX pModLX);
    132 static int32_t kldrModLXDoCall(uintptr_t uEntrypoint, uintptr_t uHandle, uint32_t uOp, void *pvReserved);
    133 static int kldrModLXDoReloc(uint8_t *pbPage, int off, KLDRADDR PageAddress, const struct r32_rlc *prlc,
    134                             int iSelector, KLDRADDR uValue, uint32_t fKind);
     132static KI32 kldrModLXDoCall(KUPTR uEntrypoint, KUPTR uHandle, KU32 uOp, void *pvReserved);
     133static int kldrModLXDoReloc(KU8 *pbPage, int off, KLDRADDR PageAddress, const struct r32_rlc *prlc,
     134                            int iSelector, KLDRADDR uValue, KU32 fKind);
    135135
    136136
    … …  
    176176    PKLDRMODLX pModLX;
    177177    PKLDRMOD pMod;
    178     size_t cb;
    179     size_t cchFilename;
    180     uint32_t off, offEnd;
    181     uint32_t i;
     178    KSIZE cb;
     179    KSIZE cchFilename;
     180    KU32 off, offEnd;
     181    KU32 i;
    182182    int rc;
    183183    int fCanOptimizeMapping;
    184     uint32_t NextRVA;
     184    KU32 NextRVA;
    185185    *ppModLX = NULL;
    186186
    … …  
    206206
    207207    /* Some rough sanity checks. */
    208     offEnd = kLdrRdrSize(pRdr) >= (KLDRFOFF)~(uint32_t)16 ? ~(uint32_t)16 : (uint32_t)kLdrRdrSize(pRdr);
     208    offEnd = kLdrRdrSize(pRdr) >= (KLDRFOFF)~(KU32)16 ? ~(KU32)16 : (KU32)kLdrRdrSize(pRdr);
    209209    if (    Hdr.e32_itermap > offEnd
    210210        ||  Hdr.e32_datapage > offEnd
    … …  
    278278
    279279    /* KLDRMOD */
    280     pMod = (PKLDRMOD)((uint8_t *)pModLX + KLDR_ALIGN_Z(sizeof(KLDRMODLX), 8));
     280    pMod = (PKLDRMOD)((KU8 *)pModLX + KLDR_ALIGN_Z(sizeof(KLDRMODLX), 8));
    281281    pMod->pvData = pModLX;
    282282    pMod->pRdr = pRdr;
    … …  
    361361    if (rc)
    362362        return rc;
    363     ((uint8_t *)pModLX->pbLoaderSectionLast)[1] = 0;
    364     ((uint8_t *)pModLX->pbLoaderSectionLast)[2] = 0;
     363    ((KU8 *)pModLX->pbLoaderSectionLast)[1] = 0;
     364    ((KU8 *)pModLX->pbLoaderSectionLast)[2] = 0;
    365365    if (pModLX->Hdr.e32_objcnt)
    366366        pModLX->paObjs = (const struct o32_obj *)pModLX->pbLoaderSection;
    … …  
    386386    if (!pMod->pszName)
    387387        return KLDR_ERR_LX_NO_SONAME;
    388     pMod->cchName = *(const uint8_t *)pMod->pszName++;
     388    pMod->cchName = *(const KU8 *)pMod->pszName++;
    389389    if (pMod->cchName != kLdrHlpStrLen(pMod->pszName))
    390390        return KLDR_ERR_LX_BAD_SONAME;
    … …  
    403403            return KLDR_ERR_LX_BAD_OBJECT_TABLE;
    404404        if (    pModLX->paObjs[i].o32_mapsize
    405             &&  (   (uint8_t *)&pModLX->paPageMappings[pModLX->paObjs[i].o32_pagemap] > pModLX->pbLoaderSectionLast
    406                  || (uint8_t *)&pModLX->paPageMappings[pModLX->paObjs[i].o32_pagemap + pModLX->paObjs[i].o32_mapsize]
     405            &&  (   (KU8 *)&pModLX->paPageMappings[pModLX->paObjs[i].o32_pagemap] > pModLX->pbLoaderSectionLast
     406                 || (KU8 *)&pModLX->paPageMappings[pModLX->paObjs[i].o32_pagemap + pModLX->paObjs[i].o32_mapsize]
    407407                     > pModLX->pbLoaderSectionLast))
    408408            return KLDR_ERR_LX_BAD_OBJECT_TABLE;
    … …  
    564564
    565565/** @copydoc kLdrModQuerySymbol */
    566 static int kldrModLXQuerySymbol(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, uint32_t iSymbol,
    567                                 const char *pchSymbol, size_t cchSymbol, const char *pszVersion,
    568                                 PFNKLDRMODGETIMPORT pfnGetForwarder, void *pvUser, PKLDRADDR puValue, uint32_t *pfKind)
     566static int kldrModLXQuerySymbol(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, KU32 iSymbol,
     567                                const char *pchSymbol, KSIZE cchSymbol, const char *pszVersion,
     568                                PFNKLDRMODGETIMPORT pfnGetForwarder, void *pvUser, PKLDRADDR puValue, KU32 *pfKind)
    569569{
    570570    PKLDRMODLX                  pModLX = (PKLDRMODLX)pMod->pvData;
    571     uint32_t                    iOrdinal;
     571    KU32                        iOrdinal;
    572572    int                         rc;
    573573    const struct b32_bundle     *pBundle;
    … …  
    598598    while (pBundle->b32_cnt && iOrdinal <= iSymbol)
    599599    {
    600         static const size_t s_cbEntry[] = { 0, 3, 5, 5, 7 };
     600        static const KSIZE s_cbEntry[] = { 0, 3, 5, 5, 7 };
    601601
    602602        /*
    … …  
    606606        if (iSymbol < iOrdinal)
    607607        {
    608             uint32_t offObject;
    609             const struct e32_entry *pEntry = (const struct e32_entry *)((uintptr_t)(pBundle + 1)
     608            KU32 offObject;
     609            const struct e32_entry *pEntry = (const struct e32_entry *)((KUPTR)(pBundle + 1)
    610610                                                                        +   (iSymbol - (iOrdinal - pBundle->b32_cnt))
    611611                                                                          * s_cbEntry[pBundle->b32_type]);
    … …  
    674674        }
    675675        if (pBundle->b32_type == 0)
    676             pBundle = (const struct b32_bundle *)((const uint8_t *)pBundle + 2);
     676            pBundle = (const struct b32_bundle *)((const KU8 *)pBundle + 2);
    677677        else
    678             pBundle = (const struct b32_bundle *)((const uint8_t *)(pBundle + 1) + s_cbEntry[pBundle->b32_type] * pBundle->b32_cnt);
     678            pBundle = (const struct b32_bundle *)((const KU8 *)(pBundle + 1) + s_cbEntry[pBundle->b32_type] * pBundle->b32_cnt);
    679679    }
    680680
    … …  
    692692 * @param   piSymbol    Where to store the symbol ordinal.
    693693 */
    694 static int kldrModLXDoNameLookup(PKLDRMODLX pModLX, const char *pchSymbol, uint32_t cchSymbol, uint32_t *piSymbol)
     694static int kldrModLXDoNameLookup(PKLDRMODLX pModLX, const char *pchSymbol, KU32 cchSymbol, KU32 *piSymbol)
    695695{
    696696
    … …  
    703703     * Search the name tables.
    704704     */
    705     const uint8_t *pbName = kldrModLXDoNameTableLookupByName(pModLX->pbResNameTab,
    706                                                              pModLX->pbLoaderSectionLast - pModLX->pbResNameTab + 1,
    707                                                              pchSymbol, cchSymbol);
     705    const KU8 *pbName = kldrModLXDoNameTableLookupByName(pModLX->pbResNameTab,
     706                                                         pModLX->pbLoaderSectionLast - pModLX->pbResNameTab + 1,
     707                                                         pchSymbol, cchSymbol);
    708708    if (!pbName)
    709709    {
    … …  
    721721        return KLDR_ERR_SYMBOL_NOT_FOUND;
    722722
    723     *piSymbol = *(const uint16_t *)(pbName + 1 + *pbName);
     723    *piSymbol = *(const KU16 *)(pbName + 1 + *pbName);
    724724    return 0;
    725725}
    … …  
    743743 * elsewhere.
    744744 */
    745 static uint32_t kldrModLXDoHash(const char *pchSymbol, uint8_t cchSymbol)
    746 {
    747     uint32_t hash = 0;
     745static KU32 kldrModLXDoHash(const char *pchSymbol, KU8 cchSymbol)
     746{
     747    KU32 hash = 0;
    748748    int ch;
    749749
    … …  
    767767 * @param   cchSymbol       The length of the symbol name.
    768768 */
    769 static const uint8_t *kldrModLXDoNameTableLookupByName(const uint8_t *pbNameTable, int32_t cbNameTable,
    770                                                        const char *pchSymbol, size_t cchSymbol)
     769static const KU8 *kldrModLXDoNameTableLookupByName(const KU8 *pbNameTable, KI32 cbNameTable,
     770                                                   const char *pchSymbol, KSIZE cchSymbol)
    771771{
    772772    /*
    773773     * Determin the namelength up front so we can skip anything which doesn't matches the length.
    774774     */
    775     uint8_t         cbSymbol8Bit = (uint8_t)cchSymbol;
     775    KU8 cbSymbol8Bit = (KU8)cchSymbol;
    776776    if (cbSymbol8Bit != cchSymbol)
    777777        return NULL; /* too long. */
    … …  
    782782    while (*pbNameTable != 0 && cbNameTable > 0)
    783783    {
    784         const uint8_t  cbName = *pbNameTable;
     784        const KU8 cbName = *pbNameTable;
    785785
    786786        cbNameTable -= cbName + 1 + 2;
    … …  
    812812 */
    813813static int kldrModLXDoForwarderQuery(PKLDRMODLX pModLX, const struct e32_entry *pEntry,
    814                                      PFNKLDRMODGETIMPORT pfnGetForwarder, void *pvUser, PKLDRADDR puValue, uint32_t *pfKind)
     814                                     PFNKLDRMODGETIMPORT pfnGetForwarder, void *pvUser, PKLDRADDR puValue, KU32 *pfKind)
    815815{
    816816    int rc;
    817     uint32_t iSymbol;
     817    KU32 iSymbol;
    818818    const char *pchSymbol;
    819     uint8_t cchSymbol;
     819    KU8 cchSymbol;
    820820
    821821    if (!pfnGetForwarder)
    … …  
    840840    else
    841841    {
    842         const uint8_t *pbName;
     842        const KU8 *pbName;
    843843
    844844        /* load the fixup section if necessary. */
    … …  
    861861        if (pbName[1] == '#')
    862862        {
    863             uint8_t         cbLeft = *pbName;
    864             const uint8_t  *pb = pbName + 1;
    865             unsigned        uBase;
     863            KU8         cbLeft = *pbName;
     864            const KU8  *pb = pbName + 1;
     865            unsigned    uBase;
    866866
    867867            /* base detection */
    … …  
    934934{
    935935    int rc;
    936     uint32_t off;
     936    KU32 off;
    937937    void *pv;
    938938
    … …  
    950950        KLDRMODLX_ASSERT(!pModLX->paoffPageFixups);
    951951        if (pModLX->Hdr.e32_fpagetab)
    952             pModLX->paoffPageFixups = (const uint32_t *)(pModLX->pbFixupSection + pModLX->Hdr.e32_fpagetab - off);
     952            pModLX->paoffPageFixups = (const KU32 *)(pModLX->pbFixupSection + pModLX->Hdr.e32_fpagetab - off);
    953953        KLDRMODLX_ASSERT(!pModLX->pbFixupRecs);
    954954        if (pModLX->Hdr.e32_frectab)
    … …  
    969969/** @copydoc kLdrModEnumSymbols */
    970970static int kldrModLXEnumSymbols(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress,
    971                                 uint32_t fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser)
     971                                KU32 fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser)
    972972{
    973973    PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
    974974    const struct b32_bundle *pBundle;
    975     uint32_t iOrdinal;
     975    KU32 iOrdinal;
    976976    int rc = 0;
    977977
    … …  
    986986    while (pBundle->b32_cnt && iOrdinal)
    987987    {
    988         static const size_t s_cbEntry[] = { 0, 3, 5, 5, 7 };
     988        static const KSIZE s_cbEntry[] = { 0, 3, 5, 5, 7 };
    989989
    990990        /*
    … …  
    994994        {
    995995            const struct e32_entry *pEntry;
    996             size_t cbEntry;
     996            KSIZE cbEntry;
    997997            KLDRADDR BundleRVA;
    998998            unsigned cLeft;
    … …  
    10281028            {
    10291029                KLDRADDR uValue;
    1030                 uint32_t fKind;
     1030                KU32 fKind;
    10311031                int fFoundName;
    1032                 const uint8_t *pbName;
     1032                const KU8 *pbName;
    10331033
    10341034                /*
    … …  
    11181118                /* next */
    11191119                iOrdinal++;
    1120                 pEntry = (const struct e32_entry *)((uintptr_t)pEntry + cbEntry);
     1120                pEntry = (const struct e32_entry *)((KUPTR)pEntry + cbEntry);
    11211121            }
    11221122        }
    … …  
    11311131        }
    11321132        if (pBundle->b32_type == 0)
    1133             pBundle = (const struct b32_bundle *)((const uint8_t *)pBundle + 2);
     1133            pBundle = (const struct b32_bundle *)((const KU8 *)pBundle + 2);
    11341134        else
    1135             pBundle = (const struct b32_bundle *)((const uint8_t *)(pBundle + 1) + s_cbEntry[pBundle->b32_type] * pBundle->b32_cnt);
     1135            pBundle = (const struct b32_bundle *)((const KU8 *)(pBundle + 1) + s_cbEntry[pBundle->b32_type] * pBundle->b32_cnt);
    11361136    }
    11371137
    … …  
    11491149 * @param   iOrdinal    The ordinal to search for.
    11501150 */
    1151 static const uint8_t *kldrModLXDoNameTableLookupByOrdinal(const uint8_t *pbNameTable, int32_t cbNameTable, uint32_t iOrdinal)
     1151static const KU8 *kldrModLXDoNameTableLookupByOrdinal(const KU8 *pbNameTable, KI32 cbNameTable, KU32 iOrdinal)
    11521152{
    11531153    while (*pbNameTable != 0 && cbNameTable > 0)
    11541154    {
    1155         const uint8_t   cbName = *pbNameTable;
    1156         uint32_t        iName;
     1155        const KU8   cbName = *pbNameTable;
     1156        KU32        iName;
    11571157
    11581158        cbNameTable -= cbName + 1 + 2;
    … …  
    11741174
    11751175/** @copydoc kLdrModGetImport */
    1176 static int kldrModLXGetImport(PKLDRMOD pMod, const void *pvBits, uint32_t iImport, char *pszName, size_t cchName)
    1177 {
    1178     PKLDRMODLX      pModLX = (PKLDRMODLX)pMod->pvData;
    1179     const uint8_t * pb;
    1180     int             rc;
     1176static int kldrModLXGetImport(PKLDRMOD pMod, const void *pvBits, KU32 iImport, char *pszName, KSIZE cchName)
     1177{
     1178    PKLDRMODLX  pModLX = (PKLDRMODLX)pMod->pvData;
     1179    const KU8  *pb;
     1180    int         rc;
    11811181
    11821182    /*
    … …  
    12251225
    12261226/** @copydoc kLdrModNumberOfImports */
    1227 static int32_t kldrModLXNumberOfImports(PKLDRMOD pMod, const void *pvBits)
     1227static KI32 kldrModLXNumberOfImports(PKLDRMOD pMod, const void *pvBits)
    12281228{
    12291229    PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
    … …  
    12361236{
    12371237    PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
    1238     const uint32_t i = pModLX->Hdr.e32_stackobj;
     1238    const KU32 i = pModLX->Hdr.e32_stackobj;
    12391239
    12401240    if (    i
    … …  
    13411341    else
    13421342    {
    1343         pvBase = (void *)(uintptr_t)pMod->aSegments[0].LinkAddress;
    1344         if ((uintptr_t)pvBase != pMod->aSegments[0].LinkAddress)
     1343        pvBase = (void *)(KUPTR)pMod->aSegments[0].LinkAddress;
     1344        if ((KUPTR)pvBase != pMod->aSegments[0].LinkAddress)
    13451345            return KLDR_ERR_ADDRESS_OVERFLOW;
    13461346    }
    … …  
    13571357    if (!rc)
    13581358    {
    1359         uint32_t i;
     1359        KU32 i;
    13601360        for (i = 0; i < pMod->cSegments; i++)
    13611361        {
    13621362            if (pMod->aSegments[i].RVA != NIL_KLDRADDR)
    1363                 pMod->aSegments[i].MapAddress = (uintptr_t)pvBase + (uintptr_t)pMod->aSegments[i].RVA;
     1363                pMod->aSegments[i].MapAddress = (KUPTR)pvBase + (KUPTR)pMod->aSegments[i].RVA;
    13641364        }
    13651365        pModLX->pvMapping = pvBase;
    … …  
    13831383{
    13841384    const PKLDRRDR pRdr = pModLX->pMod->pRdr;
    1385     uint8_t *pbTmpPage = NULL;
     1385    KU8 *pbTmpPage = NULL;
    13861386    int rc = 0;
    1387     uint32_t i;
     1387    KU32 i;
    13881388
    13891389    /*
    … …  
    13931393    {
    13941394        const struct o32_obj * const pObj = &pModLX->paObjs[i];
    1395         const uint32_t  cPages = pModLX->pMod->aSegments[i].cbMapped / OBJPAGELEN;
    1396         uint32_t        iPage;
    1397         uint8_t        *pbPage = (uint8_t *)pvBits + (uintptr_t)pModLX->pMod->aSegments[i].RVA;
     1395        const KU32      cPages = pModLX->pMod->aSegments[i].cbMapped / OBJPAGELEN;
     1396        KU32            iPage;
     1397        KU8            *pbPage = (KU8 *)pvBits + (KUPTR)pModLX->pMod->aSegments[i].RVA;
    13981398
    13991399        /*
    … …  
    14861486 *                      contains 4 additional zero bytes.
    14871487 */
    1488 static int kldrModLXDoIterDataUnpacking(uint8_t *pbDst, const uint8_t *pbSrc, int cbSrc)
     1488static int kldrModLXDoIterDataUnpacking(KU8 *pbDst, const KU8 *pbSrc, int cbSrc)
    14891489{
    14901490    const struct LX_Iter   *pIter = (const struct LX_Iter *)pbSrc;
    … …  
    15571557 *                      contains 4 additional zero bytes.
    15581558 */
    1559 static int kldrModLXDoIterData2Unpacking(uint8_t *pbDst, const uint8_t *pbSrc, int cbSrc)
     1559static int kldrModLXDoIterData2Unpacking(KU8 *pbDst, const KU8 *pbSrc, int cbSrc)
    15601560{
    15611561    int cbDst = OBJPAGELEN;
    … …  
    17741774 * @remark  This assumes that unaligned word and dword access is fine.
    17751775 */
    1776 static void kLdrModLXMemCopyW(uint8_t *pbDst, const uint8_t *pbSrc, int cb)
     1776static void kLdrModLXMemCopyW(KU8 *pbDst, const KU8 *pbSrc, int cb)
    17771777{
    17781778    switch (pbDst - pbSrc)
    … …  
    17861786                *pbDst++ = *pbSrc++;
    17871787            for (cb >>= 1; cb > 0; cb--, pbDst += 2, pbSrc += 2)
    1788                 *(uint16_t *)pbDst = *(const uint16_t *)pbSrc;
     1788                *(KU16 *)pbDst = *(const KU16 *)pbSrc;
    17891789            break;
    17901790
    … …  
    17951795            if (cb & 2)
    17961796            {
    1797                 *(uint16_t *)pbDst = *(const uint16_t *)pbSrc;
     1797                *(KU16 *)pbDst = *(const KU16 *)pbSrc;
    17981798                pbDst += 2;
    17991799                pbSrc += 2;
    18001800            }
    18011801            for (cb >>= 2; cb > 0; cb--, pbDst += 4, pbSrc += 4)
    1802                 *(uint32_t *)pbDst = *(const uint32_t *)pbSrc;
     1802                *(KU32 *)pbDst = *(const KU32 *)pbSrc;
    18031803            break;
    18041804    }
    … …  
    18191819static int kldrModLXDoProtect(PKLDRMODLX pModLX, void *pvBits, unsigned fUnprotectOrProtect)
    18201820{
    1821     uint32_t i;
     1821    KU32 i;
    18221822    PKLDRMOD pMod = pModLX->pMod;
    18231823
    … …  
    18651865
    18661866        /* calc the address and set page protection. */
    1867         pv = (uint8_t *)pvBits + pMod->aSegments[i].RVA;
     1867        pv = (KU8 *)pvBits + pMod->aSegments[i].RVA;
    18681868
    18691869        rc = kldrHlpPageProtect(pv, pMod->aSegments[i].cbMapped, enmProt);
    … …  
    18821882{
    18831883    PKLDRMODLX  pModLX = (PKLDRMODLX)pMod->pvData;
    1884     uint32_t    i;
     1884    KU32        i;
    18851885    int         rc;
    18861886
    … …  
    19801980     * Apply fixups and resolve imports.
    19811981     */
    1982     rc = kldrModLXRelocateBits(pMod, (void *)pModLX->pvMapping, (uintptr_t)pModLX->pvMapping,
     1982    rc = kldrModLXRelocateBits(pMod, (void *)pModLX->pvMapping, (KUPTR)pModLX->pvMapping,
    19831983                               pMod->aSegments[0].LinkAddress, pfnGetImport, pvUser);
    19841984
    … …  
    19941994
    19951995/** @copydoc kLdrModCallInit */
    1996 static int kldrModLXCallInit(PKLDRMOD pMod, uintptr_t uHandle)
     1996static int kldrModLXCallInit(PKLDRMOD pMod, KUPTR uHandle)
    19971997{
    19981998    PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
    … …  
    20252025 * @param   uHandle         The module handle to present.
    20262026 */
    2027 static int kldrModLXDoCallDLL(PKLDRMODLX pModLX, unsigned uOp, uintptr_t uHandle)
     2027static int kldrModLXDoCallDLL(PKLDRMODLX pModLX, unsigned uOp, KUPTR uHandle)
    20282028{
    20292029    int rc;
    … …  
    20392039     * Invoke the entrypoint and convert the boolean result to a kLdr status code.
    20402040     */
    2041     rc = kldrModLXDoCall((uintptr_t)pModLX->pvMapping
    2042                          + (uintptr_t)pModLX->pMod->aSegments[pModLX->Hdr.e32_startobj - 1].RVA
     2041    rc = kldrModLXDoCall((KUPTR)pModLX->pvMapping
     2042                         + (KUPTR)pModLX->pMod->aSegments[pModLX->Hdr.e32_startobj - 1].RVA
    20432043                         + pModLX->Hdr.e32_eip,
    20442044                         uHandle, uOp, NULL);
    … …  
    20622062 * @param   pvReserved      The third argument, reserved argument. (figure this one out)
    20632063 */
    2064 static int32_t kldrModLXDoCall(uintptr_t uEntrypoint, uintptr_t uHandle, uint32_t uOp, void *pvReserved)
     2064static KI32 kldrModLXDoCall(KUPTR uEntrypoint, KUPTR uHandle, KU32 uOp, void *pvReserved)
    20652065{
    20662066#if defined(__X86__) || defined(__i386__) || defined(_M_IX86)
    2067     int32_t rc;
     2067    KI32 rc;
    20682068/** @todo try/except */
    20692069
    … …  
    21122112
    21132113/** @copydoc kLdrModCallTerm */
    2114 static int kldrModLXCallTerm(PKLDRMOD pMod, uintptr_t uHandle)
     2114static int kldrModLXCallTerm(PKLDRMOD pMod, KUPTR uHandle)
    21152115{
    21162116    PKLDRMODLX  pModLX = (PKLDRMODLX)pMod->pvData;
    … …  
    21332133
    21342134/** @copydoc kLdrModCallThread */
    2135 static int kldrModLXCallThread(PKLDRMOD pMod, uintptr_t uHandle, unsigned fAttachingOrDetaching)
     2135static int kldrModLXCallThread(PKLDRMOD pMod, KUPTR uHandle, unsigned fAttachingOrDetaching)
    21362136{
    21372137    /* no thread attach/detach callout. */
    … …  
    21742174{
    21752175    PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
    2176     uint32_t iSeg;
     2176    KU32 iSeg;
    21772177    int rc;
    21782178
    … …  
    22022202        const struct o32_obj * const pObj = &pModLX->paObjs[iSeg];
    22032203        KLDRADDR        PageAddress = NewBaseAddress + pModLX->pMod->aSegments[iSeg].RVA;
    2204         uint32_t        iPage;
    2205         uint8_t        *pbPage = (uint8_t *)pvBits + (uintptr_t)pModLX->pMod->aSegments[iSeg].RVA;
     2204        KU32            iPage;
     2205        KU8            *pbPage = (KU8 *)pvBits + (KUPTR)pModLX->pMod->aSegments[iSeg].RVA;
    22062206
    22072207        /*
    … …  
    22102210        for (iPage = 0, rc = 0; !rc && iPage < pObj->o32_mapsize; iPage++, pbPage += OBJPAGELEN, PageAddress += OBJPAGELEN)
    22112211        {
    2212             const uint8_t * const   pbFixupRecEnd = pModLX->pbFixupRecs + pModLX->paoffPageFixups[iPage + pObj->o32_pagemap];
    2213             const uint8_t          *pb            = pModLX->pbFixupRecs + pModLX->paoffPageFixups[iPage + pObj->o32_pagemap - 1];
    2214             KLDRADDR                uValue;
    2215             int                     iSelector;
    2216             uint32_t                fKind;
     2212            const KU8 * const   pbFixupRecEnd = pModLX->pbFixupRecs + pModLX->paoffPageFixups[iPage + pObj->o32_pagemap];
     2213            const KU8          *pb            = pModLX->pbFixupRecs + pModLX->paoffPageFixups[iPage + pObj->o32_pagemap - 1];
     2214            KLDRADDR            uValue;
     2215            int                 iSelector;
     2216            KU32                fKind;
    22172217
    22182218            /* sanity */
    … …  
    22312231                union _rel
    22322232                {
    2233                     const uint8_t *          pb;
    2234                     const struct r32_rlc    *prlc;
     2233                    const KU8 *             pb;
     2234                    const struct r32_rlc   *prlc;
    22352235                } u;
    22362236
    … …  
    22482248                    case NRRINT:
    22492249                    {
    2250                         uint16_t iTrgObject;
    2251                         uint32_t offTrgObject;
     2250                        KU16 iTrgObject;
     2251                        KU32 offTrgObject;
    22522252
    22532253                        /* the object */
    22542254                        if (u.prlc->nr_flags & NR16OBJMOD)
    22552255                        {
    2256                             iTrgObject = *(const uint16_t *)pb;
     2256                            iTrgObject = *(const KU16 *)pb;
    22572257                            pb += 2;
    22582258                        }
    … …  
    22682268                            if (u.prlc->nr_flags & NR32BITOFF)
    22692269                            {
    2270                                 offTrgObject = *(const uint32_t *)pb;
     2270                                offTrgObject = *(const KU32 *)pb;
    22712271                                pb += 4;
    22722272                            }
    22732273                            else
    22742274                            {
    2275                                 offTrgObject = *(const uint16_t *)pb;
     2275                                offTrgObject = *(const KU16 *)pb;
    22762276                                pb += 2;
    22772277                            }
    … …  
    22962296                    case NRRORD:
    22972297                    {
    2298                         uint16_t iModule;
    2299                         uint32_t iSymbol;
     2298                        KU16 iModule;
     2299                        KU32 iSymbol;
    23002300
    23012301                        /* the module ordinal */
    23022302                        if (u.prlc->nr_flags & NR16OBJMOD)
    23032303                        {
    2304                             iModule = *(const uint16_t *)pb;
     2304                            iModule = *(const KU16 *)pb;
    23052305                            pb += 2;
    23062306                        }
    … …  
    23182318                        if (u.prlc->nr_flags & NR32BITOFF)
    23192319                        {
    2320                             iSymbol = *(const uint32_t *)pb;
     2320                            iSymbol = *(const KU32 *)pb;
    23212321                            pb += 4;
    23222322                        }
    23232323                        else if (!(u.prlc->nr_flags & NR8BITORD))
    23242324                        {
    2325                             iSymbol = *(const uint16_t *)pb;
     2325                            iSymbol = *(const KU16 *)pb;
    23262326                            pb += 2;
    23272327                        }
    … …  
    23422342                    case NRRNAM:
    23432343                    {
    2344                         uint32_t iModule;
    2345                         uint16_t offSymbol;
    2346                         const uint8_t *pbSymbol;
     2344                        KU32 iModule;
     2345                        KU16 offSymbol;
     2346                        const KU8 *pbSymbol;
    23472347
    23482348                        /* the module ordinal */
    23492349                        if (u.prlc->nr_flags & NR16OBJMOD)
    23502350                        {
    2351                             iModule = *(const uint16_t *)pb;
     2351                            iModule = *(const KU16 *)pb;
    23522352                            pb += 2;
    23532353                        }
    … …  
    23652365                        if (u.prlc->nr_flags & NR32BITOFF)
    23662366                        {
    2367                             offSymbol = *(const uint32_t *)pb;
     2367                            offSymbol = *(const KU32 *)pb;
    23682368                            pb += 4;
    23692369                        }
    23702370                        else if (!(u.prlc->nr_flags & NR8BITORD))
    23712371                        {
    2372                             offSymbol = *(const uint16_t *)pb;
     2372                            offSymbol = *(const KU16 *)pb;
    23732373                            pb += 2;
    23742374                        }
    … …  
    24002400                    if (u.prlc->nr_flags & NR32BITADD)
    24012401                    {
    2402                         uValue += *(const uint32_t *)pb;
     2402                        uValue += *(const KU32 *)pb;
    24032403                        pb += 4;
    24042404                    }
    24052405                    else
    24062406                    {
    2407                         uValue += *(const uint16_t *)pb;
     2407                        uValue += *(const KU16 *)pb;
    24082408                        pb += 2;
    24092409                    }
    … …  
    24222422                        &&  off >= 0
    24232423                        &&  off <= OBJPAGELEN - 4)
    2424                         *(uint32_t *)&pbPage[off] = uValue;
     2424                        *(KU32 *)&pbPage[off] = uValue;
    24252425                    else if (    (u.prlc->nr_stype & NRSRCMASK) == NRSOFF32
    24262426                            &&  off >= 0
    24272427                            &&  off <= OBJPAGELEN - 4)
    2428                         *(uint32_t *)&pbPage[off] = uValue - (PageAddress + off + 4);
     2428                        *(KU32 *)&pbPage[off] = uValue - (PageAddress + off + 4);
    24292429                    else
    24302430                    {
    … …  
    24372437                else if (!(u.prlc->nr_flags & NRICHAIN))
    24382438                {
    2439                     const int16_t *poffSrc = (const int16_t *)pb;
    2440                     uint8_t c = u.pb[2];
     2439                    const KI16 *poffSrc = (const KI16 *)pb;
     2440                    KU8 c = u.pb[2];
    24412441
    24422442                    /* common / simple */
    … …  
    24472447                            int off = *poffSrc++;
    24482448                            if (off >= 0 && off <= OBJPAGELEN - 4)
    2449                                 *(uint32_t *)&pbPage[off] = uValue;
     2449                                *(KU32 *)&pbPage[off] = uValue;
    24502450                            else
    24512451                            {
    … …  
    24622462                            int off = *poffSrc++;
    24632463                            if (off >= 0 && off <= OBJPAGELEN - 4)
    2464                                 *(uint32_t *)&pbPage[off] = uValue - (PageAddress + off + 4);
     2464                                *(KU32 *)&pbPage[off] = uValue - (PageAddress + off + 4);
    24652465                            else
    24662466                            {
    … …  
    24802480                        }
    24812481                    }
    2482                     pb = (const uint8_t *)poffSrc;
     2482                    pb = (const KU8 *)poffSrc;
    24832483                }
    24842484                else
    … …  
    25082508 * @param   fKind       The target kind.
    25092509 */
    2510 static int kldrModLXDoReloc(uint8_t *pbPage, int off, KLDRADDR PageAddress, const struct r32_rlc *prlc,
    2511                             int iSelector, KLDRADDR uValue, uint32_t fKind)
     2510static int kldrModLXDoReloc(KU8 *pbPage, int off, KLDRADDR PageAddress, const struct r32_rlc *prlc,
     2511                            int iSelector, KLDRADDR uValue, KU32 fKind)
    25122512{
    25132513#pragma pack(1) /* just to be sure */
    25142514    union
    25152515    {
    2516         uint8_t     ab[6];
    2517         uint32_t    off32;
    2518         uint16_t    off16;
    2519         uint8_t     off8;
     2516        KU8         ab[6];
     2517        KU32        off32;
     2518        KU16        off16;
     2519        KU8         off8;
    25202520        struct
    25212521        {
    2522             uint16_t off;
    2523             uint16_t Sel;
     2522            KU16    off;
     2523            KU16    Sel;
    25242524        }           Far16;
    25252525        struct
    25262526        {
    2527             uint32_t off;
    2528             uint16_t Sel;
     2527            KU32    off;
     2528            KU16    Sel;
    25292529        }           Far32;
    25302530    }               uData;
    25312531#pragma pack()
    2532     const uint8_t  *pbSrc;
    2533     uint8_t        *pbDst;
    2534     uint8_t         cb;
     2532    const KU8      *pbSrc;
     2533    KU8            *pbDst;
     2534    KU8             cb;
    25352535
    25362536    /*
    … …  
    25402540    {
    25412541        case NRSBYT:
    2542             uData.off8 = (uint8_t)uValue;
     2542            uData.off8 = (KU8)uValue;
    25432543            cb = 1;
    25442544            break;
    … …  
    25562556                /* fixme */
    25572557            }
    2558             uData.Far16.off = (uint16_t)uValue;
     2558            uData.Far16.off = (KU16)uValue;
    25592559            uData.Far16.Sel = iSelector;
    25602560            cb = 4;
    25612561            break;
    25622562        case NRSOFF:
    2563             uData.off16 = (uint16_t)uValue;
     2563            uData.off16 = (KU16)uValue;
    25642564            cb = 2;
    25652565            break;
    … …  
    25692569                /* fixme */
    25702570            }
    2571             uData.Far32.off = (uint32_t)uValue;
     2571            uData.Far32.off = (KU32)uValue;
    25722572            uData.Far32.Sel = iSelector;
    25732573            cb = 6;
    25742574            break;
    25752575        case NROFF32:
    2576             uData.off32 = (uint32_t)uValue;
     2576            uData.off32 = (KU32)uValue;
    25772577            cb = 4;
    25782578            break;
    25792579        case NRSOFF32:
    2580             uData.off32 = (uint32_t)uValue - (PageAddress + off + 4);
     2580            uData.off32 = (KU32)uValue - (PageAddress + off + 4);
    25812581            cb = 4;
    25822582            break;

  • trunk/kStuff/kLdr/kLdrModLX.h

    r3537 r3567  
    2020struct e32_exe
    2121{
    22     uint8_t             e32_magic[2];
    23     uint8_t             e32_border;
    24     uint8_t             e32_worder;
    25     uint32_t            e32_level;
    26     uint16_t            e32_cpu;
    27     uint16_t            e32_os;
    28     uint32_t            e32_ver;
    29     uint32_t            e32_mflags;
    30     uint32_t            e32_mpages;
    31     uint32_t            e32_startobj;
    32     uint32_t            e32_eip;
    33     uint32_t            e32_stackobj;
    34     uint32_t            e32_esp;
    35     uint32_t            e32_pagesize;
    36     uint32_t            e32_pageshift;
     22    KU8                 e32_magic[2];
     23    KU8                 e32_border;
     24    KU8                 e32_worder;
     25    KU32                e32_level;
     26    KU16                e32_cpu;
     27    KU16                e32_os;
     28    KU32                e32_ver;
     29    KU32                e32_mflags;
     30    KU32                e32_mpages;
     31    KU32                e32_startobj;
     32    KU32                e32_eip;
     33    KU32                e32_stackobj;
     34    KU32                e32_esp;
     35    KU32                e32_pagesize;
     36    KU32                e32_pageshift;
    3737    /** The size of the fixup section.
    3838     * The fixup section consists of the fixup page table, the fixup record table,
    3939     * the import module table, and the import procedure name table.
    4040     */
    41     uint32_t            e32_fixupsize;
    42     uint32_t            e32_fixupsum;
     41    KU32                e32_fixupsize;
     42    KU32                e32_fixupsum;
    4343    /** The size of the resident loader section.
    4444     * This includes the object table, the object page map table, the resource table, the resident name table,
    4545     * the entry table, the module format directives table, and the page checksum table (?). */
    46     uint32_t            e32_ldrsize;
     46    KU32                e32_ldrsize;
    4747    /** The checksum of the loader section. 0 if not calculated. */
    48     uint32_t            e32_ldrsum;
     48    KU32                e32_ldrsum;
    4949    /** The offset of the object table relative to this structure. */
    50     uint32_t            e32_objtab;
     50    KU32                e32_objtab;
    5151    /** Count of objects. */
    52     uint32_t            e32_objcnt;
     52    KU32                e32_objcnt;
    5353    /** The offset of the object page map table relative to this structure. */
    54     uint32_t            e32_objmap;
     54    KU32                e32_objmap;
    5555    /** The offset of the object iterated pages (whatever this is used for) relative to the start of the file. */
    56     uint32_t            e32_itermap;
     56    KU32                e32_itermap;
    5757    /** The offset of the resource table relative to this structure. */
    58     uint32_t            e32_rsrctab;
     58    KU32                e32_rsrctab;
    5959    /** The number of entries in the resource table. */
    60     uint32_t            e32_rsrccnt;
     60    KU32                e32_rsrccnt;
    6161    /** The offset of the resident name table relative to this structure. */
    62     uint32_t            e32_restab;
     62    KU32                e32_restab;
    6363    /** The offset of the entry (export) table relative to this structure. */
    64     uint32_t            e32_enttab;
     64    KU32                e32_enttab;
    6565    /** The offset of the module format directives table relative to this structure. */
    66     uint32_t            e32_dirtab;
     66    KU32                e32_dirtab;
    6767    /** The number of entries in the module format directives table. */
    68     uint32_t            e32_dircnt;
     68    KU32                e32_dircnt;
    6969    /** The offset of the fixup page table relative to this structure. */
    70     uint32_t            e32_fpagetab;
     70    KU32                e32_fpagetab;
    7171    /** The offset of the fixup record table relative to this structure. */
    72     uint32_t            e32_frectab;
     72    KU32                e32_frectab;
    7373    /** The offset of the import module name table relative to this structure. */
    74     uint32_t            e32_impmod;
     74    KU32                e32_impmod;
    7575    /** The number of entries in the import module name table. */
    76     uint32_t            e32_impmodcnt;
     76    KU32                e32_impmodcnt;
    7777    /** The offset of the import procedure name table relative to this structure. */
    78     uint32_t            e32_impproc;
     78    KU32                e32_impproc;
    7979    /** The offset of the page checksum table relative to this structure. */
    80     uint32_t            e32_pagesum;
     80    KU32                e32_pagesum;
    8181    /** The offset of the data pages relative to the start of the file. */
    82     uint32_t            e32_datapage;
     82    KU32                e32_datapage;
    8383    /** The number of preload pages (ignored). */
    84     uint32_t            e32_preload;
     84    KU32                e32_preload;
    8585    /** The offset of the non-resident name table relative to the start of the file. */
    86     uint32_t            e32_nrestab;
     86    KU32                e32_nrestab;
    8787    /** The size of the non-resident name table. */
    88     uint32_t            e32_cbnrestab;
    89     uint32_t            e32_nressum;
    90     uint32_t            e32_autodata;
    91     uint32_t            e32_debuginfo;
    92     uint32_t            e32_debuglen;
    93     uint32_t            e32_instpreload;
    94     uint32_t            e32_instdemand;
    95     uint32_t            e32_heapsize;
    96     uint32_t            e32_stacksize;
    97     uint8_t             e32_res3[20];
     88    KU32                e32_cbnrestab;
     89    KU32                e32_nressum;
     90    KU32                e32_autodata;
     91    KU32                e32_debuginfo;
     92    KU32                e32_debuglen;
     93    KU32                e32_instpreload;
     94    KU32                e32_instdemand;
     95    KU32                e32_heapsize;
     96    KU32                e32_stacksize;
     97    KU8                 e32_res3[20];
    9898};
    9999
    … …  
    113113#define E32BEWO         1
    114114/** e32_level */
    115 #define E32LEVEL        UINT32_C(0)
     115#define E32LEVEL        KU32_C(0)
    116116/** e32_cpu - 80286 */
    117117#define E32CPU286       1
    … …  
    121121#define E32CPU486       3
    122122/** e32_pagesize */
    123 #define OBJPAGELEN      UINT32_C(0x1000)
     123#define OBJPAGELEN      KU32_C(0x1000)
    124124
    125125
    … …  
    127127 * @{ */
    128128/** App Type: Fullscreen only. */
    129 #define E32NOPMW         UINT32_C(0x00000100)
     129#define E32NOPMW         KU32_C(0x00000100)
    130130/** App Type: PM API. */
    131 #define E32PMAPI         UINT32_C(0x00000300)
     131#define E32PMAPI         KU32_C(0x00000300)
    132132/** App Type: PM VIO compatible. */
    133 #define E32PMW           UINT32_C(0x00000200)
     133#define E32PMW           KU32_C(0x00000200)
    134134/** Application type mask. */
    135 #define E32APPMASK       UINT32_C(0x00000300)
     135#define E32APPMASK       KU32_C(0x00000300)
    136136/** Executable module. */
    137 #define E32MODEXE        UINT32_C(0x00000000)
     137#define E32MODEXE        KU32_C(0x00000000)
    138138/** Dynamic link library (DLL / library) module. */
    139 #define E32MODDLL        UINT32_C(0x00008000)
     139#define E32MODDLL        KU32_C(0x00008000)
    140140/** Protected memory DLL. */
    141 #define E32PROTDLL       UINT32_C(0x00010000)
     141#define E32PROTDLL       KU32_C(0x00010000)
    142142/** Physical Device Driver. */
    143 #define E32MODPDEV       UINT32_C(0x00020000)
     143#define E32MODPDEV       KU32_C(0x00020000)
    144144/** Virtual Device Driver. */
    145 #define E32MODVDEV       UINT32_C(0x00028000)
     145#define E32MODVDEV       KU32_C(0x00028000)
    146146/** Device driver */
    147147#define E32DEVICE        E32MODPDEV
    … …  
    151151#define E32MODPROTDLL    (E32MODDLL | E32PROTDLL)
    152152/** Module Type mask. */
    153 #define E32MODMASK       UINT32_C(0x00038000)
     153#define E32MODMASK       KU32_C(0x00038000)
    154154/** Not loadable (linker error). */
    155 #define E32NOLOAD        UINT32_C(0x00002000)
     155#define E32NOLOAD        KU32_C(0x00002000)
    156156/** No internal fixups. */
    157 #define E32NOINTFIX      UINT32_C(0x00000010)
     157#define E32NOINTFIX      KU32_C(0x00000010)
    158158/** No external fixups (i.e. imports). */
    159 #define E32NOEXTFIX      UINT32_C(0x00000020)
     159#define E32NOEXTFIX      KU32_C(0x00000020)
    160160/** System DLL, no internal fixups. */
    161 #define E32SYSDLL        UINT32_C(0x00000008)
     161#define E32SYSDLL        KU32_C(0x00000008)
    162162/** Global (set) or per instance (cleared) library initialization. */
    163 #define E32LIBINIT       UINT32_C(0x00000004)
     163#define E32LIBINIT       KU32_C(0x00000004)
    164164/** Global (set) or per instance (cleared) library termination. */
    165 #define E32LIBTERM       UINT32_C(0x40000000)
     165#define E32LIBTERM       KU32_C(0x40000000)
    166166/** Indicates when set in an executable that the process isn't SMP safe. */
    167 #define E32NOTMPSAFE     UINT32_C(0x00080000)
     167#define E32NOTMPSAFE     KU32_C(0x00080000)
    168168/** @} */
    169169
    … …  
    172172typedef union _offset
    173173{
    174     uint16_t            offset16;
    175     uint32_t            offset32;
     174    KU16                offset16;
     175    KU32                offset32;
    176176} offset;
    177177
    … …  
    181181struct r32_rlc
    182182{
    183     uint8_t             nr_stype;
    184     uint8_t             nr_flags;
    185     int16_t             r32_soff;
    186     uint16_t            r32_objmod;
     183    KU8                 nr_stype;
     184    KU8                 nr_flags;
     185    KI16                r32_soff;
     186    KU16                r32_objmod;
    187187
    188188    union targetid
    … …  
    192192        {
    193193            offset      proc;
    194             uint32_t    ord;
     194            KU32        ord;
    195195        } extref;
    196196        struct addfixup
    197197        {
    198             uint16_t    entry;
     198            KU16        entry;
    199199            offset      addval;
    200200        } addfix;
    201201    } r32_target;
    202     uint16_t            r32_srccount;
    203     uint16_t            r32_chain;
     202    KU16                r32_srccount;
     203    KU16                r32_chain;
    204204};
    205205
    … …  
    256256{
    257257    /** The size of the object. */
    258     uint32_t            o32_size;
     258    KU32                o32_size;
    259259    /** The base address of the object. */
    260     uint32_t            o32_base;
     260    KU32                o32_base;
    261261    /** Object flags. */
    262     uint32_t            o32_flags;
     262    KU32                o32_flags;
    263263    /** Page map index. */
    264     uint32_t            o32_pagemap;
     264    KU32                o32_pagemap;
    265265    /** Page map size. (doesn't need to be o32_size >> page shift). */
    266     uint32_t            o32_mapsize;
     266    KU32                o32_mapsize;
    267267    /** Reserved */
    268     uint32_t            o32_reserved;
     268    KU32                o32_reserved;
    269269};
    270270
    … …  
    272272 * @{ */
    273273/** Read access. */
    274 #define OBJREAD         UINT32_C(0x00000001)
     274#define OBJREAD         KU32_C(0x00000001)
    275275/** Write access. */
    276 #define OBJWRITE        UINT32_C(0x00000002)
     276#define OBJWRITE        KU32_C(0x00000002)
    277277/** Execute access. */
    278 #define OBJEXEC         UINT32_C(0x00000004)
     278#define OBJEXEC         KU32_C(0x00000004)
    279279/** Resource object. */
    280 #define OBJRSRC         UINT32_C(0x00000008)
     280#define OBJRSRC         KU32_C(0x00000008)
    281281/** The object is discarable (i.e. don't swap, just load in pages from the executable).
    282282 * This overlaps a bit with object type. */
    283 #define OBJDISCARD      UINT32_C(0x00000010)
     283#define OBJDISCARD      KU32_C(0x00000010)
    284284/** The object is shared. */
    285 #define OBJSHARED       UINT32_C(0x00000020)
     285#define OBJSHARED       KU32_C(0x00000020)
    286286/** The object has preload pages. */
    287 #define OBJPRELOAD      UINT32_C(0x00000040)
     287#define OBJPRELOAD      KU32_C(0x00000040)
    288288/** The object has invalid pages. */
    289 #define OBJINVALID      UINT32_C(0x00000080)
     289#define OBJINVALID      KU32_C(0x00000080)
    290290/** Non-permanent, link386 bug. */
    291 #define LNKNONPERM      UINT32_C(0x00000600)
     291#define LNKNONPERM      KU32_C(0x00000600)
    292292/** Non-permanent, correct 'value'. */
    293 #define OBJNONPERM      UINT32_C(0x00000000)
     293#define OBJNONPERM      KU32_C(0x00000000)
    294294/** Obj Type: The object is permanent and swappable. */
    295 #define OBJPERM         UINT32_C(0x00000100)
     295#define OBJPERM         KU32_C(0x00000100)
    296296/** Obj Type: The object is permanent and resident (i.e. not swappable). */
    297 #define OBJRESIDENT     UINT32_C(0x00000200)
     297#define OBJRESIDENT     KU32_C(0x00000200)
    298298/** Obj Type: The object is resident and contigious. */
    299 #define OBJCONTIG       UINT32_C(0x00000300)
     299#define OBJCONTIG       KU32_C(0x00000300)
    300300/** Obj Type: The object is permanent and long locable. */
    301 #define OBJDYNAMIC      UINT32_C(0x00000400)
     301#define OBJDYNAMIC      KU32_C(0x00000400)
    302302/** Object type mask. */
    303 #define OBJTYPEMASK     UINT32_C(0x00000700)
     303#define OBJTYPEMASK     KU32_C(0x00000700)
    304304/** x86: The object require an 16:16 alias. */
    305 #define OBJALIAS16      UINT32_C(0x00001000)
     305#define OBJALIAS16      KU32_C(0x00001000)
    306306/** x86: Big/Default selector setting, i.e. toggle 32-bit or 16-bit. */
    307 #define OBJBIGDEF       UINT32_C(0x00002000)
     307#define OBJBIGDEF       KU32_C(0x00002000)
    308308/** x86: conforming selector setting (weird stuff). */
    309 #define OBJCONFORM      UINT32_C(0x00004000)
     309#define OBJCONFORM      KU32_C(0x00004000)
    310310/** x86: IOPL. */
    311 #define OBJIOPL         UINT32_C(0x00008000)
     311#define OBJIOPL         KU32_C(0x00008000)
    312312/** @} */
    313313
    … …  
    316316{
    317317    /** The file offset of the page. */
    318     uint32_t            o32_pagedataoffset;
     318    KU32                o32_pagedataoffset;
    319319    /** The number of bytes of raw page data. */
    320     uint16_t            o32_pagesize;
     320    KU16                o32_pagesize;
    321321    /** Per page flags describing how the page is encoded in the file. */
    322     uint16_t            o32_pageflags;
     322    KU16                o32_pageflags;
    323323};
    324324
    … …  
    327327 */
    328328/** Raw page (uncompressed) in the file. */
    329 #define VALID           UINT16_C(0x0000)
     329#define VALID           KU16_C(0x0000)
    330330/** RLE encoded page in file. */
    331 #define ITERDATA        UINT16_C(0x0001)
     331#define ITERDATA        KU16_C(0x0001)
    332332/** Invalid page, nothing in the file. */
    333 #define INVALID         UINT16_C(0x0002)
     333#define INVALID         KU16_C(0x0002)
    334334/** Zero page, nothing in file. */
    335 #define ZEROED          UINT16_C(0x0003)
     335#define ZEROED          KU16_C(0x0003)
    336336/** range of pages (what is this?) */
    337 #define RANGE           UINT16_C(0x0004)
     337#define RANGE           KU16_C(0x0004)
    338338/** Compressed page in file. */
    339 #define ITERDATA2       UINT16_C(0x0005)
     339#define ITERDATA2       KU16_C(0x0005)
    340340/** @} */
    341341
    … …  
    345345{
    346346    /** Number of iterations. */
    347     uint16_t            LX_nIter;
     347    KU16                LX_nIter;
    348348    /** The number of bytes that's being iterated. */
    349     uint16_t            LX_nBytes;
     349    KU16                LX_nBytes;
    350350    /** The bytes. */
    351     uint8_t             LX_Iterdata;
     351    KU8                 LX_Iterdata;
    352352};
    353353
    … …  
    359359{
    360360    /** Resource Type. */
    361     uint16_t            type;
     361    KU16                type;
    362362    /** Resource ID. */
    363     uint16_t            name;
     363    KU16                name;
    364364    /** Resource size in bytes. */
    365     uint32_t            cb;
     365    KU32                cb;
    366366    /** The index of the object containing the resource. */
    367     uint16_t            obj;
     367    KU16                obj;
    368368    /** Offset of the resource that within the object. */
    369     uint32_t            offset;
     369    KU32                offset;
    370370};
    371371
    … …  
    379379{
    380380    /** The number of entries. */
    381     uint8_t             b32_cnt;
     381    KU8                 b32_cnt;
    382382    /** The type of bundle. */
    383     uint8_t             b32_type;
     383    KU8                 b32_type;
    384384    /** The index of the object containing these entry points. */
    385     uint16_t            b32_obj;
     385    KU16                b32_obj;
    386386};
    387387
    … …  
    407407{
    408408    /** Entry point flags */
    409     uint8_t             e32_flags;      /* Entry point flags */
     409    KU8                 e32_flags;      /* Entry point flags */
    410410    union entrykind
    411411    {
    … …  
    416416        {
    417417            /** Offset into segment. */
    418             uint16_t    offset;
     418            KU16        offset;
    419419            /** The callgate selector */
    420             uint16_t    callgate;
     420            KU16        callgate;
    421421        } e32_callgate;
    422422        /** ENTRYFWD */
    … …  
    424424        {
    425425            /** Module ordinal number (i.e. into the import module table). */
    426             uint16_t    modord;
     426            KU16        modord;
    427427            /** Procedure name or ordinal number. */
    428             uint32_t    value;
     428            KU32        value;
    429429        } e32_fwd;
    430430    } e32_variant;

  • trunk/kStuff/kLdr/kLdrModMZ.h

    r3537 r3567  
    1010typedef struct _IMAGE_DOS_HEADER
    1111{
    12     uint16_t   e_magic;
    13     uint16_t   e_cblp;
    14     uint16_t   e_cp;
    15     uint16_t   e_crlc;
    16     uint16_t   e_cparhdr;
    17     uint16_t   e_minalloc;
    18     uint16_t   e_maxalloc;
    19     uint16_t   e_ss;
    20     uint16_t   e_sp;
    21     uint16_t   e_csum;
    22     uint16_t   e_ip;
    23     uint16_t   e_cs;
    24     uint16_t   e_lfarlc;
    25     uint16_t   e_ovno;
    26     uint16_t   e_res[4];
    27     uint16_t   e_oemid;
    28     uint16_t   e_oeminfo;
    29     uint16_t   e_res2[10];
    30     uint32_t   e_lfanew;
     12    KU16       e_magic;
     13    KU16       e_cblp;
     14    KU16       e_cp;
     15    KU16       e_crlc;
     16    KU16       e_cparhdr;
     17    KU16       e_minalloc;
     18    KU16       e_maxalloc;
     19    KU16       e_ss;
     20    KU16       e_sp;
     21    KU16       e_csum;
     22    KU16       e_ip;
     23    KU16       e_cs;
     24    KU16       e_lfarlc;
     25    KU16       e_ovno;
     26    KU16       e_res[4];
     27    KU16       e_oemid;
     28    KU16       e_oeminfo;
     29    KU16       e_res2[10];
     30    KU32       e_lfanew;
    3131} IMAGE_DOS_HEADER;
    3232typedef IMAGE_DOS_HEADER *PIMAGE_DOS_HEADER;

  • trunk/kStuff/kLdr/kLdrModMachO.c

    r3537 r3567  
    7070    KLDRFOFF                offFile;
    7171    /** The number of fixups. */
    72     uint32_t                cFixups;
     72    KU32                    cFixups;
    7373    /** The array of fixups. (lazy loaded) */
    7474    macho_relocation_info_t *paFixups;
    … …  
    7777    KLDRFOFF                offFixups;
    7878    /** Mach-O section flags. */
    79     uint32_t                fFlags;
     79    KU32                    fFlags;
    8080    /** kLdr segment index. */
    81     uint32_t                iSegment;
     81    KU32                    iSegment;
    8282    /** Pointer to the Mach-O section structure. */
    8383    void                   *pvMachoSection;
    … …  
    9292{
    9393    /** The number of sections in the segment. */
    94     uint32_t                cSections;
     94    KU32                    cSections;
    9595    /** Pointer to the sections belonging to this segment.
    9696     * The array resides in the big memory chunk allocated for
    … …  
    122122
    123123    /** Pointer to the load commands. (endian converted) */
    124     uint8_t                *pbLoadCommands;
     124    KU8                    *pbLoadCommands;
    125125    /** The Mach-O header. (endian converted)
    126126     * @remark The reserved field is only valid for real 64-bit headers. */
    … …  
    130130    KLDRFOFF                offSymbols;
    131131    /** The number of symbols. */
    132     uint32_t                cSymbols;
     132    KU32                    cSymbols;
    133133    /** The pointer to the loaded symbol table. */
    134134    void                   *pvaSymbols;
    … …  
    136136    KLDRFOFF                offStrings;
    137137    /** The size of the of the string table. */
    138     uint32_t                cchStrings;
     138    KU32                    cchStrings;
    139139    /** Pointer to the loaded string table. */
    140140    char                   *pchStrings;
    141141
    142142    /** The number of sections. */
    143     uint32_t                cSections;
     143    KU32                    cSections;
    144144    /** Pointer to the section array running in parallel to the Mach-O one. */
    145145    PKLDRMODMACHOSECT       paSections;
    … …  
    155155*******************************************************************************/
    156156#if 0
    157 static int32_t kldrModMachONumberOfImports(PKLDRMOD pMod, const void *pvBits);
     157static KI32 kldrModMachONumberOfImports(PKLDRMOD pMod, const void *pvBits);
    158158#endif
    159159static int kldrModMachORelocateBits(PKLDRMOD pMod, void *pvBits, KLDRADDR NewBaseAddress, KLDRADDR OldBaseAddress,
    … …  
    161161
    162162static int  kldrModMachODoCreate(PKLDRRDR pRdr, PKLDRMODMACHO *ppMod);
    163 static int  kldrModMachOPreParseLoadCommands(uint8_t *pbLoadCommands, const mach_header_32_t *pHdr, PKLDRRDR pRdr,
    164                                              uint32_t *pcSegments, uint32_t *pcSections, uint32_t *pcbStringPool);
    165 static int  kldrModMachOParseLoadCommands(PKLDRMODMACHO pModMachO, char *pbStringPool, uint32_t cbStringPool);
     163static int  kldrModMachOPreParseLoadCommands(KU8 *pbLoadCommands, const mach_header_32_t *pHdr, PKLDRRDR pRdr,
     164                                             KU32 *pcSegments, KU32 *pcSections, KU32 *pcbStringPool);
     165static int  kldrModMachOParseLoadCommands(PKLDRMODMACHO pModMachO, char *pbStringPool, KU32 cbStringPool);
    166166static int  kldrModMachOAdjustBaseAddress(PKLDRMODMACHO pModMachO, PKLDRADDR pBaseAddress);
    167167
    168168/*static int  kldrModMachOLoadLoadCommands(PKLDRMODMACHO pModMachO);*/
    169169static int  kldrModMachOLoadObjSymTab(PKLDRMODMACHO pModMachO);
    170 static int  kldrModMachOLoadFixups(PKLDRMODMACHO pModMachO, KLDRFOFF offFixups, uint32_t cFixups, macho_relocation_info_t **ppaFixups);
     170static int  kldrModMachOLoadFixups(PKLDRMODMACHO pModMachO, KLDRFOFF offFixups, KU32 cFixups, macho_relocation_info_t **ppaFixups);
    171171static int  kldrModMachOMapVirginBits(PKLDRMODMACHO pModMachO);
    172172
    173 static int  kldrModMachODoQuerySymbol32Bit(PKLDRMODMACHO pModMachO, const macho_nlist_32_t *paSyms, uint32_t cSyms, const char *pchStrings,
    174                                            uint32_t cchStrings, KLDRADDR BaseAddress, uint32_t iSymbol, const char *pchSymbol,
    175                                            size_t cchSymbol, PKLDRADDR puValue, uint32_t *pfKind);
    176 static int  kldrModMachODoEnumSymbols32Bit(PKLDRMODMACHO pModMachO, const macho_nlist_32_t *paSyms, uint32_t cSyms,
    177                                            const char *pchStrings, uint32_t cchStrings, KLDRADDR BaseAddress,
    178                                            uint32_t fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser);
     173static int  kldrModMachODoQuerySymbol32Bit(PKLDRMODMACHO pModMachO, const macho_nlist_32_t *paSyms, KU32 cSyms, const char *pchStrings,
     174                                           KU32 cchStrings, KLDRADDR BaseAddress, KU32 iSymbol, const char *pchSymbol,
     175                                           KSIZE cchSymbol, PKLDRADDR puValue, KU32 *pfKind);
     176static int  kldrModMachODoEnumSymbols32Bit(PKLDRMODMACHO pModMachO, const macho_nlist_32_t *paSyms, KU32 cSyms,
     177                                           const char *pchStrings, KU32 cchStrings, KLDRADDR BaseAddress,
     178                                           KU32 fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser);
    179179static int  kldrModMachOObjDoImports(PKLDRMODMACHO pModMachO, PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
    180180static int  kldrModMachOObjDoFixups(PKLDRMODMACHO pModMachO, void *pvMapping, KLDRADDR NewBaseAddress);
    181 static int  kldrModMachOFixupSectionGeneric32Bit(PKLDRMODMACHO pModMachO, uint8_t *pbSectBits, PKLDRMODMACHOSECT pFixupSect,
    182                                                  macho_nlist_32_t *paSyms, uint32_t cSyms, KLDRADDR NewBaseAddress);
     181static int  kldrModMachOFixupSectionGeneric32Bit(PKLDRMODMACHO pModMachO, KU8 *pbSectBits, PKLDRMODMACHOSECT pFixupSect,
     182                                                 macho_nlist_32_t *paSyms, KU32 cSyms, KLDRADDR NewBaseAddress);
    183183
    184184/*static int  kldrModMachODoFixups(PKLDRMODMACHO pModMachO, void *pvMapping, KLDRADDR NewBaseAddress, KLDRADDR OldBaseAddress);
    … …  
    235235    PKLDRMODMACHO pModMachO;
    236236    PKLDRMOD pMod;
    237     uint8_t *pbLoadCommands;
    238     uint32_t cSegments;
    239     uint32_t cSections;
    240     uint32_t cbStringPool;
    241     size_t cchFilename;
    242     size_t cb;
     237    KU8 *pbLoadCommands;
     238    KU32 cSegments;
     239    KU32 cSections;
     240    KU32 cbStringPool;
     241    KSIZE cchFilename;
     242    KSIZE cb;
    243243    int rc;
    244244    *ppModMachO = NULL;
    … …  
    311311
    312312    /* KLDRMOD */
    313     pMod = (PKLDRMOD)((uint8_t *)pModMachO + KLDR_ALIGN_Z(  KLDR_OFFSETOF(KLDRMODMACHO, aSegments[cSegments])
    314                                                           + sizeof(KLDRMODMACHOSECT) * cSections, 16));
     313    pMod = (PKLDRMOD)((KU8 *)pModMachO + KLDR_ALIGN_Z(  KLDR_OFFSETOF(KLDRMODMACHO, aSegments[cSegments])
     314                                                      + sizeof(KLDRMODMACHOSECT) * cSections, 16));
    315315    pMod->pvData = pModMachO;
    316316    pMod->pRdr = pRdr;
    … …  
    430430 * @param   pcbStringPool   Where to store the string pool size.
    431431 */
    432 static int  kldrModMachOPreParseLoadCommands(uint8_t *pbLoadCommands, const mach_header_32_t *pHdr, PKLDRRDR pRdr,
    433                                              uint32_t *pcSegments, uint32_t *pcSections, uint32_t *pcbStringPool)
     432static int  kldrModMachOPreParseLoadCommands(KU8 *pbLoadCommands, const mach_header_32_t *pHdr, PKLDRRDR pRdr,
     433                                             KU32 *pcSegments, KU32 *pcSections, KU32 *pcbStringPool)
    434434{
    435435    union
    436436    {
    437         uint8_t              *pb;
     437        KU8                  *pb;
    438438        load_command_t       *pLoadCmd;
    439439        segment_command_32_t *pSeg32;
    … …  
    443443        uuid_command_t       *pUuid;
    444444    } u;
    445     const uint64_t cbFile = kLdrRdrSize(pRdr);
    446     uint32_t cSegments = 0;
    447     uint32_t cSections = 0;
    448     uint32_t cbStringPool = 0;
    449     uint32_t cLeft = pHdr->ncmds;
    450     uint32_t cbLeft = pHdr->sizeofcmds;
    451     uint8_t *pb = pbLoadCommands;
     445    const KU64 cbFile = kLdrRdrSize(pRdr);
     446    KU32 cSegments = 0;
     447    KU32 cSections = 0;
     448    KU32 cbStringPool = 0;
     449    KU32 cLeft = pHdr->ncmds;
     450    KU32 cbLeft = pHdr->sizeofcmds;
     451    KU8 *pb = pbLoadCommands;
    452452    int cSegmentCommands = 0;
    453453    int cSymbolTabs = 0;
    … …  
    487487                section_32_t *pSect;
    488488                section_32_t *pFirstSect;
    489                 uint32_t cSectionsLeft;
     489                KU32 cSectionsLeft;
    490490
    491491                /* convert and verify*/
    … …  
    509509                if (    u.pSeg32->filesize
    510510                    &&  (   u.pSeg32->fileoff > cbFile
    511                          || (uint64_t)u.pSeg32->fileoff + u.pSeg32->filesize > cbFile))
     511                         || (KU64)u.pSeg32->fileoff + u.pSeg32->filesize > cbFile))
    512512                    return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
    513513                if (!u.pSeg32->filesize && u.pSeg32->fileoff)
    … …  
    594594                    if (    fFileBits
    595595                        &&  (   pSect->offset > cbFile
    596                              || (uint64_t)pSect->offset + pSect->size > cbFile))
     596                             || (KU64)pSect->offset + pSect->size > cbFile))
    597597                        return KLDR_ERR_MACHO_BAD_SECTION;
    598598                    if (!fFileBits && pSect->offset)
    … …  
    602602                    if (    pSect->nreloc
    603603                        &&  (   pSect->reloff > cbFile
    604                              || (uint64_t)pSect->reloff + (KLDRFOFF)pSect->nreloc * sizeof(macho_relocation_info_t)) > cbFile)
     604                             || (KU64)pSect->reloff + (KLDRFOFF)pSect->nreloc * sizeof(macho_relocation_info_t)) > cbFile)
    605605                        return KLDR_ERR_MACHO_BAD_SECTION;
    606606
    … …  
    624624                                /* verify that the linker/assembler has ordered sections correctly. */
    625625                                section_32_t *pCur = (pSect - 2);
    626                                 while ((uintptr_t)pCur >= (uintptr_t)pFirstSect)
     626                                while ((KUPTR)pCur >= (KUPTR)pFirstSect)
    627627                                {
    628628                                    if (!kLdrHlpStrNComp(pCur->segname, pSect->segname, sizeof(pSect->segname)))
    … …  
    656656            case LC_SYMTAB:
    657657            {
    658                 size_t cbSym;
     658                KSIZE cbSym;
    659659                if (fConvertEndian)
    660660                {
    … …  
    671671                      : sizeof(macho_nlist_64_t);
    672672                if (    u.pSymTab->symoff >= cbFile
    673                     ||  (uint64_t)u.pSymTab->symoff + u.pSymTab->nsyms * cbSym > kLdrRdrSize(pRdr))
     673                    ||  (KU64)u.pSymTab->symoff + u.pSymTab->nsyms * cbSym > kLdrRdrSize(pRdr))
    674674                    return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
    675675                if (    u.pSymTab->stroff >= cbFile
    676                     ||  (uint64_t)u.pSymTab->stroff + u.pSymTab->strsize > cbFile)
     676                    ||  (KU64)u.pSymTab->stroff + u.pSymTab->strsize > cbFile)
    677677                    return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
    678678
    … …  
    692692            case LC_UNIXTHREAD:
    693693            {
    694                 uint32_t *pu32 = (uint32_t *)(u.pb + sizeof(load_command_t));
    695                 uint32_t cItemsLeft = (u.pThread->cmdsize - sizeof(load_command_t)) / sizeof(uint32_t);
     694                KU32 *pu32 = (KU32 *)(u.pb + sizeof(load_command_t));
     695                KU32 cItemsLeft = (u.pThread->cmdsize - sizeof(load_command_t)) / sizeof(KU32);
    696696                while (cItemsLeft)
    697697                {
    698                     /* convert & verify header items ([0] == flavor, [1] == uint32_t count). */
     698                    /* convert & verify header items ([0] == flavor, [1] == KU32 count). */
    699699                    if (cItemsLeft < 2)
    700700                        return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
    … …  
    787787 * @param   cbStringPool    The size of the string pool.
    788788 */
    789 static int  kldrModMachOParseLoadCommands(PKLDRMODMACHO pModMachO, char *pbStringPool, uint32_t cbStringPool)
     789static int  kldrModMachOParseLoadCommands(PKLDRMODMACHO pModMachO, char *pbStringPool, KU32 cbStringPool)
    790790{
    791791    union
    792792    {
    793         const uint8_t              *pb;
     793        const KU8                  *pb;
    794794        const load_command_t       *pLoadCmd;
    795795        const segment_command_32_t *pSeg32;
    … …  
    797797        const symtab_command_t     *pSymTab;
    798798    } u;
    799     uint32_t cLeft = pModMachO->Hdr.ncmds;
    800     uint32_t cbLeft = pModMachO->Hdr.sizeofcmds;
    801     const uint8_t *pb = pModMachO->pbLoadCommands;
     799    KU32 cLeft = pModMachO->Hdr.ncmds;
     800    KU32 cbLeft = pModMachO->Hdr.sizeofcmds;
     801    const KU8 *pb = pModMachO->pbLoadCommands;
    802802    int fFirstSegment = 1;
    803803    PKLDRSEG pSeg = &pModMachO->pMod->aSegments[0];
    804804    PKLDRMODMACHOSEG pSegExtra = &pModMachO->aSegments[0];
    805805    PKLDRMODMACHOSECT pSectExtra = pModMachO->paSections;
    806     const uint32_t cSegments = pModMachO->pMod->cSegments;
    807     uint32_t i;
     806    const KU32 cSegments = pModMachO->pMod->cSegments;
     807    KU32 i;
    808808
    809809    while (cLeft-- > 0)
    … …  
    822822                section_32_t *pSect;
    823823                section_32_t *pFirstSect;
    824                 uint32_t cSectionsLeft;
     824                KU32 cSectionsLeft;
    825825
    826826                pModMachO->LinkAddress = u.pSeg32->vmaddr;
    … …  
    867867                                pSeg->pvUser = NULL;
    868868                                pSeg->pchName = pbStringPool;
    869                                 pSeg->cchName = (uint32_t)kLdrHlpStrNLen(&pSect->segname[0], sizeof(pSect->sectname));
     869                                pSeg->cchName = (KU32)kLdrHlpStrNLen(&pSect->segname[0], sizeof(pSect->sectname));
    870870                                kLdrHlpMemCopy(pbStringPool, &pSect->segname[0], pSeg->cchName);
    871871                                pbStringPool += pSeg->cchName;
    … …  
    967967        {
    968968            KLDRADDR cb1;
    969             size_t cb2;
     969            KSIZE cb2;
    970970
    971971            for (i = 0; i < cSegments - 1; i++)
    972972            {
    973973                cb1 = pSeg[i + 1].LinkAddress - pSeg[i].LinkAddress;
    974                 cb2 = (size_t)cb1;
    975                 pSeg[i].cbMapped = cb2 == cb1 ? cb2 : ~(size_t)0;
     974                cb2 = (KSIZE)cb1;
     975                pSeg[i].cbMapped = cb2 == cb1 ? cb2 : ~(KSIZE)0;
    976976            }
    977977            cb1 = KLDR_ALIGN_ADDR(pSeg[i].cb, pSeg[i].Alignment);
    978             cb2 = (size_t)cb1;
    979             pSeg[i].cbMapped = cb2 == cb1 ? cb2 : ~(size_t)0;
     978            cb2 = (KSIZE)cb1;
     979            pSeg[i].cbMapped = cb2 == cb1 ? cb2 : ~(KSIZE)0;
    980980
    981981            pModMachO->cbImage = pSeg[i].RVA + cb1;
    … …  
    993993    PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
    994994    int rc = 0;
    995     uint32_t i, j;
     995    KU32 i, j;
    996996    KLDRMODMACHO_ASSERT(!pModMachO->pvMapping);
    997997
    … …  
    10491049
    10501050/** @copydoc kLdrModQuerySymbol */
    1051 static int kldrModMachOQuerySymbol(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, uint32_t iSymbol,
    1052                                    const char *pchSymbol, size_t cchSymbol, const char *pszVersion,
    1053                                    PFNKLDRMODGETIMPORT pfnGetForwarder, void *pvUser, PKLDRADDR puValue, uint32_t *pfKind)
     1051static int kldrModMachOQuerySymbol(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, KU32 iSymbol,
     1052                                   const char *pchSymbol, KSIZE cchSymbol, const char *pszVersion,
     1053                                   PFNKLDRMODGETIMPORT pfnGetForwarder, void *pvUser, PKLDRADDR puValue, KU32 *pfKind)
    10541054{
    10551055    PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
    … …  
    11151115 * @param   pfKind      See kLdrModQuerySymbol.
    11161116 */
    1117 static int kldrModMachODoQuerySymbol32Bit(PKLDRMODMACHO pModMachO, const macho_nlist_32_t *paSyms, uint32_t cSyms, const char *pchStrings,
    1118                                           uint32_t cchStrings, KLDRADDR BaseAddress, uint32_t iSymbol, const char *pchSymbol, size_t cchSymbol,
    1119                                           PKLDRADDR puValue, uint32_t *pfKind)
     1117static int kldrModMachODoQuerySymbol32Bit(PKLDRMODMACHO pModMachO, const macho_nlist_32_t *paSyms, KU32 cSyms, const char *pchStrings,
     1118                                          KU32 cchStrings, KLDRADDR BaseAddress, KU32 iSymbol, const char *pchSymbol, KSIZE cchSymbol,
     1119                                          PKLDRADDR puValue, KU32 *pfKind)
    11201120{
    11211121    /*
    … …  
    11301130
    11311131        /* external symbols are usually at the end, so search the other way. */
    1132         for (iSymbol = cSyms - 1; iSymbol != UINT32_MAX; iSymbol--)
     1132        for (iSymbol = cSyms - 1; iSymbol != KU32_MAX; iSymbol--)
    11331133        {
    11341134            const char *psz;
    … …  
    11471147            if (!paSyms[iSymbol].n_un.n_strx)
    11481148                continue;
    1149             if ((uint32_t)paSyms[iSymbol].n_un.n_strx >= cchStrings)
     1149            if ((KU32)paSyms[iSymbol].n_un.n_strx >= cchStrings)
    11501150                continue;
    11511151            psz = &pchStrings[paSyms[iSymbol].n_un.n_strx];
    … …  
    11581158            break;
    11591159        }
    1160         if (iSymbol == UINT32_MAX)
     1160        if (iSymbol == KU32_MAX)
    11611161            return KLDR_ERR_SYMBOL_NOT_FOUND;
    11621162    }
    … …  
    11911191            PKLDRMODMACHOSECT pSect;
    11921192            KLDRADDR RVA;
    1193             if ((uint32_t)(paSyms[iSymbol].n_sect - 1) >= pModMachO->cSections)
     1193            if ((KU32)(paSyms[iSymbol].n_sect - 1) >= pModMachO->cSections)
    11941194                return KLDR_ERR_MACHO_BAD_SYMBOL;
    11951195            pSect = &pModMachO->paSections[paSyms[iSymbol].n_sect - 1];
    … …  
    12281228/** @copydoc kLdrModEnumSymbols */
    12291229static int kldrModMachOEnumSymbols(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress,
    1230                                    uint32_t fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser)
     1230                                   KU32 fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser)
    12311231{
    12321232    PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
    … …  
    12801280 * @param   pvUser      See kLdrModEnumSymbols.
    12811281 */
    1282 static int kldrModMachODoEnumSymbols32Bit(PKLDRMODMACHO pModMachO, const macho_nlist_32_t *paSyms, uint32_t cSyms,
    1283                                           const char *pchStrings, uint32_t cchStrings, KLDRADDR BaseAddress,
    1284                                           uint32_t fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser)
    1285 {
    1286     const uint32_t fKindBase = pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE
     1282static int kldrModMachODoEnumSymbols32Bit(PKLDRMODMACHO pModMachO, const macho_nlist_32_t *paSyms, KU32 cSyms,
     1283                                          const char *pchStrings, KU32 cchStrings, KLDRADDR BaseAddress,
     1284                                          KU32 fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser)
     1285{
     1286    const KU32 fKindBase = pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE
    12871287                            || pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE_OE
    12881288                             ? KLDRSYMKIND_32BIT : KLDRSYMKIND_64BIT;
    1289     uint32_t iSym;
     1289    KU32 iSym;
    12901290    int rc;
    12911291
    … …  
    12951295    for (iSym = 0; iSym < cSyms; iSym++)
    12961296    {
    1297         uint32_t fKind;
     1297        KU32 fKind;
    12981298        KLDRADDR uValue;
    12991299        const char *psz;
    1300         size_t cch;
     1300        KSIZE cch;
    13011301
    13021302        /* Skip debug symbols and undefined symbols. */
    … …  
    13221322
    13231323        /* name */
    1324         if ((uint32_t)paSyms[iSym].n_un.n_strx >= cchStrings)
     1324        if ((KU32)paSyms[iSym].n_un.n_strx >= cchStrings)
    13251325            return KLDR_ERR_MACHO_BAD_SYMBOL;
    13261326        psz = &pchStrings[paSyms[iSym].n_un.n_strx];
    … …  
    13381338            {
    13391339                PKLDRMODMACHOSECT pSect;
    1340                 if ((uint32_t)(paSyms[iSym].n_sect - 1) >= pModMachO->cSections)
     1340                if ((KU32)(paSyms[iSym].n_sect - 1) >= pModMachO->cSections)
    13411341                    return KLDR_ERR_MACHO_BAD_SYMBOL;
    13421342                pSect = &pModMachO->paSections[paSyms[iSym].n_sect - 1];
    … …  
    13791379
    13801380/** @copydoc kLdrModGetImport */
    1381 static int kldrModMachOGetImport(PKLDRMOD pMod, const void *pvBits, uint32_t iImport, char *pszName, size_t cchName)
     1381static int kldrModMachOGetImport(PKLDRMOD pMod, const void *pvBits, KU32 iImport, char *pszName, KSIZE cchName)
    13821382{
    13831383    PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
    … …  
    13911391
    13921392/** @copydoc kLdrModNumberOfImports */
    1393 static int32_t kldrModMachONumberOfImports(PKLDRMOD pMod, const void *pvBits)
     1393static KI32 kldrModMachONumberOfImports(PKLDRMOD pMod, const void *pvBits)
    13941394{
    13951395    PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
    … …  
    14491449    PKLDRMODMACHO                      pModMachO = (PKLDRMODMACHO)pMod->pvData;
    14501450    const IMAGE_DEBUG_DIRECTORY    *pDbgDir;
    1451     uint32_t                        iDbgInfo;
    1452     uint32_t                        cb;
     1451    KU32                            iDbgInfo;
     1452    KU32                            cb;
    14531453    int                             rc;
    14541454
    … …  
    15431543    PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
    15441544    unsigned fFixed;
    1545     uint32_t i;
     1545    KU32 i;
    15461546    void *pvBase;
    15471547    int rc;
    … …  
    15631563    else
    15641564    {
    1565         pvBase = (void *)(uintptr_t)pMod->aSegments[0].LinkAddress;
    1566         if ((uintptr_t)pvBase != pMod->aSegments[0].LinkAddress)
     1565        pvBase = (void *)(KUPTR)pMod->aSegments[0].LinkAddress;
     1566        if ((KUPTR)pvBase != pMod->aSegments[0].LinkAddress)
    15671567            return KLDR_ERR_ADDRESS_OVERFLOW;
    15681568    }
    … …  
    15841584    {
    15851585        if (pMod->aSegments[i].RVA != NIL_KLDRADDR)
    1586             pMod->aSegments[i].MapAddress = (uintptr_t)pvBase + (uintptr_t)pMod->aSegments[i].RVA;
     1586            pMod->aSegments[i].MapAddress = (KUPTR)pvBase + (KUPTR)pMod->aSegments[i].RVA;
    15871587    }
    15881588    pModMachO->pvMapping = pvBase;
    … …  
    15961596{
    15971597    PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
    1598     uint32_t i;
     1598    KU32 i;
    15991599    int rc;
    16001600
    … …  
    16911691     * Resolve imports and apply base relocations.
    16921692     */
    1693     rc = kldrModMachORelocateBits(pMod, pModMachO->pvMapping, (uintptr_t)pModMachO->pvMapping, pModMachO->LinkAddress,
     1693    rc = kldrModMachORelocateBits(pMod, pModMachO->pvMapping, (KUPTR)pModMachO->pvMapping, pModMachO->LinkAddress,
    16941694                                  pfnGetImport, pvUser);
    16951695
    … …  
    17171717static int  kldrModMachOObjDoImports(PKLDRMODMACHO pModMachO, PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser)
    17181718{
    1719     const uint32_t cSyms = pModMachO->cSymbols;
    1720     uint32_t iSym;
     1719    const KU32 cSyms = pModMachO->cSymbols;
     1720    KU32 iSym;
    17211721    int rc;
    17221722
    … …  
    17451745            {
    17461746                const char *pszSymbol;
    1747                 size_t cchSymbol;
    1748                 uint32_t fKind = KLDRSYMKIND_REQ_FLAT;
     1747                KSIZE cchSymbol;
     1748                KU32 fKind = KLDRSYMKIND_REQ_FLAT;
    17491749                KLDRADDR Value;
    17501750
    … …  
    17541754
    17551755                /* Get the symbol name and try resolve it. */
    1756                 if ((uint32_t)paSyms[iSym].n_un.n_strx >= pModMachO->cchStrings)
     1756                if ((KU32)paSyms[iSym].n_un.n_strx >= pModMachO->cchStrings)
    17571757                    return KLDR_ERR_MACHO_BAD_SYMBOL;
    17581758                pszSymbol = &pModMachO->pchStrings[paSyms[iSym].n_un.n_strx];
    … …  
    17691769
    17701770                /* Update the symbol. */
    1771                 paSyms[iSym].n_value = (uint32_t)Value;
     1771                paSyms[iSym].n_value = (KU32)Value;
    17721772                if (paSyms[iSym].n_value != Value)
    17731773                {
    … …  
    17961796            {
    17971797                const char *pszSymbol;
    1798                 size_t cchSymbol;
    1799                 uint32_t fKind = KLDRSYMKIND_REQ_FLAT;
     1798                KSIZE cchSymbol;
     1799                KU32 fKind = KLDRSYMKIND_REQ_FLAT;
    18001800                KLDRADDR Value;
    18011801
    … …  
    18501850static int  kldrModMachOObjDoFixups(PKLDRMODMACHO pModMachO, void *pvMapping, KLDRADDR NewBaseAddress)
    18511851{
    1852     uint32_t iSeg;
     1852    KU32 iSeg;
    18531853    int rc;
    18541854
    … …  
    18671867    {
    18681868        PKLDRMODMACHOSEG pSeg = &pModMachO->aSegments[iSeg];
    1869         uint32_t iSect;
     1869        KU32 iSect;
    18701870
    18711871        for (iSect = 0; iSect < pSeg->cSections; iSect++)
    18721872        {
    18731873            PKLDRMODMACHOSECT pSect = &pSeg->paSections[iSect];
    1874             uint8_t *pbSectBits;
     1874            KU8 *pbSectBits;
    18751875
    18761876            /* skip sections without fixups. */
    … …  
    18891889             * Apply the fixups.
    18901890             */
    1891             pbSectBits = (uint8_t *)pvMapping + (uintptr_t)pSect->RVA;
     1891            pbSectBits = (KU8 *)pvMapping + (KUPTR)pSect->RVA;
    18921892            if (pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE) /** @todo this aint right. */
    18931893                rc = kldrModMachOFixupSectionGeneric32Bit(pModMachO, pbSectBits, pSect,
    … …  
    19151915 * @param   NewBaseAddress  The new base image address.
    19161916 */
    1917 static int  kldrModMachOFixupSectionGeneric32Bit(PKLDRMODMACHO pModMachO, uint8_t *pbSectBits, PKLDRMODMACHOSECT pFixupSect,
    1918                                                  macho_nlist_32_t *paSyms, uint32_t cSyms, KLDRADDR NewBaseAddress)
     1917static int  kldrModMachOFixupSectionGeneric32Bit(PKLDRMODMACHO pModMachO, KU8 *pbSectBits, PKLDRMODMACHOSECT pFixupSect,
     1918                                                 macho_nlist_32_t *paSyms, KU32 cSyms, KLDRADDR NewBaseAddress)
    19191919{
    19201920    const macho_relocation_info_t *paFixups = pFixupSect->paFixups;
    1921     const uint32_t cFixups = pFixupSect->cFixups;
    1922     size_t cbSectBits = (size_t)pFixupSect->cb;
    1923     const uint8_t *pbSectVirginBits;
    1924     uint32_t iFixup;
     1921    const KU32 cFixups = pFixupSect->cFixups;
     1922    KSIZE cbSectBits = (KSIZE)pFixupSect->cb;
     1923    const KU8 *pbSectVirginBits;
     1924    KU32 iFixup;
    19251925    KLDRPU uFixVirgin;
    19261926    KLDRPU uFix;
    … …  
    19361936        if (rc)
    19371937            return rc;
    1938         pbSectVirginBits = (const uint8_t *)pModMachO->pvBits + pFixupSect->offFile;
     1938        pbSectVirginBits = (const KU8 *)pModMachO->pvBits + pFixupSect->offFile;
    19391939    }
    19401940    else
    … …  
    19561956        {
    19571957            /* sanity */
    1958             if ((uint32_t)Fixup.r.r_address >= cbSectBits)
     1958            if ((KU32)Fixup.r.r_address >= cbSectBits)
    19591959                return KLDR_ERR_BAD_FIXUP;
    19601960
    19611961            /* calc fixup addresses. */
    19621962            uFix.pv = pbSectBits + Fixup.r.r_address;
    1963             uFixVirgin.pv = pbSectVirginBits ? (uint8_t *)pbSectVirginBits + Fixup.r.r_address : 0;
     1963            uFixVirgin.pv = pbSectVirginBits ? (KU8 *)pbSectVirginBits + Fixup.r.r_address : 0;
    19641964
    19651965            /*
    … …  
    19941994                    {
    19951995                        PKLDRMODMACHOSECT pSymSect;
    1996                         if ((uint32_t)pSym->n_sect - 1 > pModMachO->cSections)
     1996                        if ((KU32)pSym->n_sect - 1 > pModMachO->cSections)
    19971997                            return KLDR_ERR_MACHO_BAD_SYMBOL;
    19981998                        pSymSect = &pModMachO->paSections[pSym->n_sect - 1];
    … …  
    20322032        {
    20332033            PKLDRMODMACHOSECT pSymSect;
    2034             uint32_t iSymSect;
     2034            KU32 iSymSect;
    20352035            KLDRADDR Value;
    20362036
    20372037            /* sanity */
    20382038            KLDRMODMACHO_ASSERT(Fixup.s.r_scattered);
    2039             if ((uint32_t)Fixup.s.r_address >= cbSectBits)
     2039            if ((KU32)Fixup.s.r_address >= cbSectBits)
    20402040                return KLDR_ERR_BAD_FIXUP;
    20412041
    20422042            /* calc fixup addresses. */
    20432043            uFix.pv = pbSectBits + Fixup.s.r_address;
    2044             uFixVirgin.pv = pbSectVirginBits ? (uint8_t *)pbSectVirginBits + Fixup.s.r_address : 0;
     2044            uFixVirgin.pv = pbSectVirginBits ? (KU8 *)pbSectVirginBits + Fixup.s.r_address : 0;
    20452045
    20462046            /*
    … …  
    20922092            switch (Fixup.r.r_length)
    20932093            {
    2094                 case 0: *uFix.pu8  = (uint8_t)SymAddr; break;
    2095                 case 1: *uFix.pu16 = (uint16_t)SymAddr; break;
    2096                 case 2: *uFix.pu32 = (uint32_t)SymAddr; break;
    2097                 case 3: *uFix.pu64 = (uint64_t)SymAddr; break;
     2094                case 0: *uFix.pu8  = (KU8)SymAddr; break;
     2095                case 1: *uFix.pu16 = (KU16)SymAddr; break;
     2096                case 2: *uFix.pu32 = (KU32)SymAddr; break;
     2097                case 3: *uFix.pu64 = (KU64)SymAddr; break;
    20982098            }
    20992099        }
    … …  
    21232123        &&  pModMachO->cSymbols)
    21242124    {
    2125         size_t cbSyms;
    2126         size_t cbSym;
     2125        KSIZE cbSyms;
     2126        KSIZE cbSym;
    21272127        void *pvSyms;
    21282128        void *pvStrings;
    … …  
    21632163                    if (pModMachO->Hdr.magic == IMAGE_MACHO32_SIGNATURE_OE)
    21642164                    {
    2165                         uint32_t cLeft = pModMachO->cSymbols;
     2165                        KU32 cLeft = pModMachO->cSymbols;
    21662166                        macho_nlist_32_t *pSym = (macho_nlist_32_t *)pvSyms;
    21672167                        while (cLeft-- > 0)
    21682168                        {
    21692169                            pSym->n_un.n_strx = KLDR_E2E_U32(pSym->n_un.n_strx);
    2170                             pSym->n_desc = (int16_t)KLDR_E2E_U16(pSym->n_desc);
     2170                            pSym->n_desc = (KI16)KLDR_E2E_U16(pSym->n_desc);
    21712171                            pSym->n_value = KLDR_E2E_U32(pSym->n_value);
    21722172                            pSym++;
    … …  
    21752175                    else if (pModMachO->Hdr.magic == IMAGE_MACHO64_SIGNATURE_OE)
    21762176                    {
    2177                         uint32_t cLeft = pModMachO->cSymbols;
     2177                        KU32 cLeft = pModMachO->cSymbols;
    21782178                        macho_nlist_64_t *pSym = (macho_nlist_64_t *)pvSyms;
    21792179                        while (cLeft-- > 0)
    21802180                        {
    21812181                            pSym->n_un.n_strx = KLDR_E2E_U32(pSym->n_un.n_strx);
    2182                             pSym->n_desc = (int16_t)KLDR_E2E_U16(pSym->n_desc);
     2182                            pSym->n_desc = (KI16)KLDR_E2E_U16(pSym->n_desc);
    21832183                            pSym->n_value = KLDR_E2E_U64(pSym->n_value);
    21842184                            pSym++;
    … …  
    22102210 * @param   ppaFixups       Where to put the pointer to the allocated fixup array.
    22112211 */
    2212 static int  kldrModMachOLoadFixups(PKLDRMODMACHO pModMachO, KLDRFOFF offFixups, uint32_t cFixups, macho_relocation_info_t **ppaFixups)
     2212static int  kldrModMachOLoadFixups(PKLDRMODMACHO pModMachO, KLDRFOFF offFixups, KU32 cFixups, macho_relocation_info_t **ppaFixups)
    22132213{
    22142214    macho_relocation_info_t *paFixups;
    2215     size_t cbFixups;
     2215    KSIZE cbFixups;
    22162216    int rc;
    22172217
    … …  
    22342234            ||  pModMachO->Hdr.magic == IMAGE_MACHO64_SIGNATURE_OE)
    22352235        {
    2236             uint32_t iFixup;
     2236            KU32 iFixup;
    22372237            for (iFixup = 0; iFixup < cFixups; iFixup++)
    22382238            {
    2239                 uint32_t *pu32 = (uint32_t *)&paFixups[iFixup];
     2239                KU32 *pu32 = (KU32 *)&paFixups[iFixup];
    22402240                pu32[0] = KLDR_E2E_U32(pu32[0]);
    22412241                pu32[1] = KLDR_E2E_U32(pu32[1]);
    … …  
    22652265
    22662266/** @copydoc kLdrModCallInit */
    2267 static int kldrModMachOCallInit(PKLDRMOD pMod, uintptr_t uHandle)
     2267static int kldrModMachOCallInit(PKLDRMOD pMod, KUPTR uHandle)
    22682268{
    22692269    /* later */
    … …  
    22732273
    22742274/** @copydoc kLdrModCallTerm */
    2275 static int kldrModMachOCallTerm(PKLDRMOD pMod, uintptr_t uHandle)
     2275static int kldrModMachOCallTerm(PKLDRMOD pMod, KUPTR uHandle)
    22762276{
    22772277    /* later */
    … …  
    22812281
    22822282/** @copydoc kLdrModCallThread */
    2283 static int kldrModMachOCallThread(PKLDRMOD pMod, uintptr_t uHandle, unsigned fAttachingOrDetaching)
     2283static int kldrModMachOCallThread(PKLDRMOD pMod, KUPTR uHandle, unsigned fAttachingOrDetaching)
    22842284{
    22852285    /* Relevant for Mach-O? */
    … …  
    23002300{
    23012301    PKLDRMODMACHO  pModMachO = (PKLDRMODMACHO)pMod->pvData;
    2302     uint32_t    i;
     2302    KU32        i;
    23032303    int         rc;
    23042304
    … …  
    23062306     * Zero the entire buffer first to simplify things.
    23072307     */
    2308     kLdrHlpMemSet(pvBits, 0, (size_t)pModMachO->cbImage);
     2308    kLdrHlpMemSet(pvBits, 0, (KSIZE)pModMachO->cbImage);
    23092309
    23102310    /*
    … …  
    23252325                continue;
    23262326            rc = kLdrRdrRead(pMod->pRdr,
    2327                              (uint8_t *)pvBits + (pMod->aSegments[i].LinkAddress - pModMachO->LinkAddress),
     2327                             (KU8 *)pvBits + (pMod->aSegments[i].LinkAddress - pModMachO->LinkAddress),
    23282328                             pMod->aSegments[i].cbFile,
    23292329                             pMod->aSegments[i].offFile);

  • trunk/kStuff/kLdr/kLdrModMachO.h

    r3537 r3567  
    1616#ifndef IMAGE_FAT_SIGNATURE
    1717/** The FAT signature (universal binaries). */
    18 # define IMAGE_FAT_SIGNATURE            UINT32_C(0xcafebabe)
     18# define IMAGE_FAT_SIGNATURE            KU32_C(0xcafebabe)
    1919#endif
    2020#ifndef IMAGE_FAT_SIGNATURE_OE
    2121/** The FAT signature (universal binaries), other endian. */
    22 # define IMAGE_FAT_SIGNATURE_OE         UINT32_C(0xbebafeca)
     22# define IMAGE_FAT_SIGNATURE_OE         KU32_C(0xbebafeca)
    2323#endif
    2424
    … …  
    2929typedef struct fat_header
    3030{
    31     uint32_t        magic;
    32     uint32_t        nfat_arch;
     31    KU32            magic;
     32    KU32            nfat_arch;
    3333} fat_header_t;
    3434
    … …  
    3838typedef struct fat_arch
    3939{
    40     int32_t         cputype;
    41     int32_t         cpusubtype;
    42     uint32_t        offset;
    43     uint32_t        size;
    44     uint32_t        align;          /**< Power of 2. */
     40    KI32            cputype;
     41    KI32            cpusubtype;
     42    KU32            offset;
     43    KU32            size;
     44    KU32            align;          /**< Power of 2. */
    4545} fat_arch_t;
    4646
    … …  
    4949#ifndef IMAGE_MACHO32_SIGNATURE
    5050/** The 32-bit Mach-O signature. */
    51 # define IMAGE_MACHO32_SIGNATURE        UINT32_C(0xfeedface)
     51# define IMAGE_MACHO32_SIGNATURE        KU32_C(0xfeedface)
    5252#endif
    5353#ifndef IMAGE_MACHO32_SIGNATURE_OE
    5454/** The 32-bit Mach-O signature, other endian. */
    55 # define IMAGE_MACHO32_SIGNATURE_OE     UINT32_C(0xcefaedfe)
     55# define IMAGE_MACHO32_SIGNATURE_OE     KU32_C(0xcefaedfe)
    5656#endif
    5757#define MH_MAGIC    IMAGE_MACHO32_SIGNATURE
    … …  
    6565typedef struct mach_header_32
    6666{
    67     uint32_t        magic;
    68     int32_t         cputype;
    69     int32_t         cpusubtype;
    70     uint32_t        filetype;
    71     uint32_t        ncmds;
    72     uint32_t        sizeofcmds;
    73     uint32_t        flags;
     67    KU32            magic;
     68    KI32            cputype;
     69    KI32            cpusubtype;
     70    KU32            filetype;
     71    KU32            ncmds;
     72    KU32            sizeofcmds;
     73    KU32            flags;
    7474} mach_header_32_t;
    7575
    … …  
    7878#ifndef IMAGE_MACHO64_SIGNATURE
    7979/** The 64-bit Mach-O signature. */
    80 # define IMAGE_MACHO64_SIGNATURE        UINT32_C(0xfeedfacf)
     80# define IMAGE_MACHO64_SIGNATURE        KU32_C(0xfeedfacf)
    8181#endif
    8282#ifndef IMAGE_MACHO64_SIGNATURE_OE
    8383/** The 64-bit Mach-O signature, other endian. */
    84 # define IMAGE_MACHO64_SIGNATURE_OE     UINT32_C(0xfefaedfe)
     84# define IMAGE_MACHO64_SIGNATURE_OE     KU32_C(0xfefaedfe)
    8585#endif
    8686#define MH_MAGIC_64 IMAGE_MACHO64_SIGNATURE
    … …  
    9494typedef struct mach_header_64
    9595{
    96     uint32_t        magic;
    97     int32_t         cputype;
    98     int32_t         cpusubtype;
    99     uint32_t        filetype;
    100     uint32_t        ncmds;
    101     uint32_t        sizeofcmds;
    102     uint32_t        flags;
    103     uint32_t        reserved;       /**< (for proper struct and command alignment I guess) */
     96    KU32            magic;
     97    KI32            cputype;
     98    KI32            cpusubtype;
     99    KU32            filetype;
     100    KU32            ncmds;
     101    KU32            sizeofcmds;
     102    KU32            flags;
     103    KU32            reserved;       /**< (for proper struct and command alignment I guess) */
    104104} mach_header_64_t;
    105105
    … …  
    108108 * @{
    109109 */
    110 #define MH_OBJECT           UINT32_C(1) /**< Object (relocatable). */
    111 #define MH_EXECUTE          UINT32_C(2) /**< Executable (demand paged). */
    112 #define MH_FVMLIB           UINT32_C(3) /**< Fixed VM shared library. */
    113 #define MH_CORE             UINT32_C(4) /**< Core file. */
    114 #define MH_PRELOAD          UINT32_C(5) /**< Preloaded executable. */
    115 #define MH_DYLIB            UINT32_C(6) /**< Dynamically bound shared library. */
    116 #define MH_DYLINKER         UINT32_C(7) /**< Dynamic linker. */
    117 #define MH_BUNDLE           UINT32_C(8) /**< Dymamically bound bundle. */
    118 #define MH_DYLIB_STUB       UINT32_C(9) /**< Shared library stub for static linking. */
    119 #define MH_DSYM             UINT32_C(10)/**< Debug symbols. */
     110#define MH_OBJECT           KU32_C(1) /**< Object (relocatable). */
     111#define MH_EXECUTE          KU32_C(2) /**< Executable (demand paged). */
     112#define MH_FVMLIB           KU32_C(3) /**< Fixed VM shared library. */
     113#define MH_CORE             KU32_C(4) /**< Core file. */
     114#define MH_PRELOAD          KU32_C(5) /**< Preloaded executable. */
     115#define MH_DYLIB            KU32_C(6) /**< Dynamically bound shared library. */
     116#define MH_DYLINKER         KU32_C(7) /**< Dynamic linker. */
     117#define MH_BUNDLE           KU32_C(8) /**< Dymamically bound bundle. */
     118#define MH_DYLIB_STUB       KU32_C(9) /**< Shared library stub for static linking. */
     119#define MH_DSYM             KU32_C(10)/**< Debug symbols. */
    120120
    121121/** @} */
    … …  
    125125 * @{
    126126 */
    127 #define MH_NOUNDEFS                 UINT32_C(0x00000001) /**< No undefined symbols. */
    128 #define MH_INCRLINK                 UINT32_C(0x00000002) /**< Partial increment link output. */
    129 #define MH_DYLDLINK                 UINT32_C(0x00000004) /**< Food for the dynamic linker, not for ld. */
    130 #define MH_BINDATLOAD               UINT32_C(0x00000008) /**< Bind all undefined symbols at load time. */
    131 #define MH_PREBOUND                 UINT32_C(0x00000010) /**< Contains prebound undefined symbols. */
    132 #define MH_SPLIT_SEGS               UINT32_C(0x00000020) /**< Read-only and read-write segments are split. */
    133 #define MH_LAZY_INIT                UINT32_C(0x00000040) /**< Obsolete flag for doing lazy init when data is written. */
    134 #define MH_TWOLEVEL                 UINT32_C(0x00000080) /**< Uses two-level name space bindings. */
    135 #define MH_FORCE_FLAT               UINT32_C(0x00000100) /**< Task: The executable forces all images to use flat name space bindings. */
    136 #define MH_NOMULTIDEFS              UINT32_C(0x00000200) /**< No multiple symbol definitions, safe to use two-level namespace hints. */
    137 #define MH_NOFIXPREBINDING          UINT32_C(0x00000400) /**< The dynamic linker should not notify the prebinding agent about this executable. */
    138 #define MH_PREBINDABLE              UINT32_C(0x00000800) /**< Not prebound, but it can be. Invalid if MH_PREBOUND is set. */
    139 #define MH_ALLMODSBOUND             UINT32_C(0x00001000) /**< Binds to all two-level namespace modules of preqs. Requires MH_PREBINDABLE and MH_TWOLEVEL to be set. */
    140 #define MH_SUBSECTIONS_VIA_SYMBOLS  UINT32_C(0x00002000) /**< Safe to divide sections into sub-sections via symbols for dead code stripping. */
    141 #define MH_CANONICAL                UINT32_C(0x00004000) /**< Canonicalized via unprebind. */
    142 #define MH_WEAK_DEFINES             UINT32_C(0x00008000) /**< The (finally) linked image has weak symbols. */
    143 #define MH_BINDS_TO_WEAK            UINT32_C(0x00010000) /**< The (finally) linked image uses weak symbols. */
    144 #define MH_ALLOW_STACK_EXECUTION    UINT32_C(0x00020000) /**< Task: allow stack execution. (MH_EXECUTE only) */
    145 #define MH_VALID_FLAGS              UINT32_C(0x0003ffff) /**< Mask containing the defined flags. */
     127#define MH_NOUNDEFS                 KU32_C(0x00000001) /**< No undefined symbols. */
     128#define MH_INCRLINK                 KU32_C(0x00000002) /**< Partial increment link output. */
     129#define MH_DYLDLINK                 KU32_C(0x00000004) /**< Food for the dynamic linker, not for ld. */
     130#define MH_BINDATLOAD               KU32_C(0x00000008) /**< Bind all undefined symbols at load time. */
     131#define MH_PREBOUND                 KU32_C(0x00000010) /**< Contains prebound undefined symbols. */
     132#define MH_SPLIT_SEGS               KU32_C(0x00000020) /**< Read-only and read-write segments are split. */
     133#define MH_LAZY_INIT                KU32_C(0x00000040) /**< Obsolete flag for doing lazy init when data is written. */
     134#define MH_TWOLEVEL                 KU32_C(0x00000080) /**< Uses two-level name space bindings. */
     135#define MH_FORCE_FLAT               KU32_C(0x00000100) /**< Task: The executable forces all images to use flat name space bindings. */
     136#define MH_NOMULTIDEFS              KU32_C(0x00000200) /**< No multiple symbol definitions, safe to use two-level namespace hints. */
     137#define MH_NOFIXPREBINDING          KU32_C(0x00000400) /**< The dynamic linker should not notify the prebinding agent about this executable. */
     138#define MH_PREBINDABLE              KU32_C(0x00000800) /**< Not prebound, but it can be. Invalid if MH_PREBOUND is set. */
     139#define MH_ALLMODSBOUND             KU32_C(0x00001000) /**< Binds to all two-level namespace modules of preqs. Requires MH_PREBINDABLE and MH_TWOLEVEL to be set. */
     140#define MH_SUBSECTIONS_VIA_SYMBOLS  KU32_C(0x00002000) /**< Safe to divide sections into sub-sections via symbols for dead code stripping. */
     141#define MH_CANONICAL                KU32_C(0x00004000) /**< Canonicalized via unprebind. */
     142#define MH_WEAK_DEFINES             KU32_C(0x00008000) /**< The (finally) linked image has weak symbols. */
     143#define MH_BINDS_TO_WEAK            KU32_C(0x00010000) /**< The (finally) linked image uses weak symbols. */
     144#define MH_ALLOW_STACK_EXECUTION    KU32_C(0x00020000) /**< Task: allow stack execution. (MH_EXECUTE only) */
     145#define MH_VALID_FLAGS              KU32_C(0x0003ffff) /**< Mask containing the defined flags. */
    146146/** @} */
    147147
    … …  
    150150 * @{
    151151 */
    152 #define CPU_ARCH_MASK               INT32_C(0xff000000)
    153 #define CPU_ARCH_ABI64              INT32_C(0x01000000)
    154 #define CPU_TYPE_ANY                INT32_C(-1)
    155 #define CPU_TYPE_VAX                INT32_C(1)
    156 #define CPU_TYPE_MC680x0            INT32_C(6)
    157 #define CPU_TYPE_X86                INT32_C(7)
     152#define CPU_ARCH_MASK               KI32_C(0xff000000)
     153#define CPU_ARCH_ABI64              KI32_C(0x01000000)
     154#define CPU_TYPE_ANY                KI32_C(-1)
     155#define CPU_TYPE_VAX                KI32_C(1)
     156#define CPU_TYPE_MC680x0            KI32_C(6)
     157#define CPU_TYPE_X86                KI32_C(7)
    158158#define CPU_TYPE_I386               CPU_TYPE_X86
    159159#define CPU_TYPE_X86_64             (CPU_TYPE_X86 | CPU_ARCH_ABI64)
    160 #define CPU_TYPE_MC98000            INT32_C(10)
    161 #define CPU_TYPE_HPPA               INT32_C(11)
    162 #define CPU_TYPE_MC88000            INT32_C(13)
    163 #define CPU_TYPE_SPARC              INT32_C(14)
    164 #define CPU_TYPE_I860               INT32_C(15)
    165 #define CPU_TYPE_POWERPC            INT32_C(18)
     160#define CPU_TYPE_MC98000            KI32_C(10)
     161#define CPU_TYPE_HPPA               KI32_C(11)
     162#define CPU_TYPE_MC88000            KI32_C(13)
     163#define CPU_TYPE_SPARC              KI32_C(14)
     164#define CPU_TYPE_I860               KI32_C(15)
     165#define CPU_TYPE_POWERPC            KI32_C(18)
    166166#define CPU_TYPE_POWERPC64          (CPU_TYPE_POWERPC | CPU_ARCH_ABI64)
    167167/** @} */
    … …  
    170170/** @name CPU subtypes (mach_header_64::cpusubtype, mach_header_32::cpusubtype, fat_arch::cpusubtype)
    171171 * @{ */
    172 #define CPU_SUBTYPE_MULTIPLE        INT32_C(-1)
    173 #define CPU_SUBTYPE_LITTLE_ENDIAN   INT32_C(0)  /**< figure this one out. */
    174 #define CPU_SUBTYPE_BIG_ENDIAN      INT32_C(1)  /**< ditto */
     172#define CPU_SUBTYPE_MULTIPLE        KI32_C(-1)
     173#define CPU_SUBTYPE_LITTLE_ENDIAN   KI32_C(0)  /**< figure this one out. */
     174#define CPU_SUBTYPE_BIG_ENDIAN      KI32_C(1)  /**< ditto */
    175175
    176176/* VAX */
    177 #define CPU_SUBTYPE_VAX_ALL         INT32_C(0)
    178 #define CPU_SUBTYPE_VAX780          INT32_C(1)
    179 #define CPU_SUBTYPE_VAX785          INT32_C(2)
    180 #define CPU_SUBTYPE_VAX750          INT32_C(3)
    181 #define CPU_SUBTYPE_VAX730          INT32_C(4)
    182 #define CPU_SUBTYPE_UVAXI           INT32_C(5)
    183 #define CPU_SUBTYPE_UVAXII          INT32_C(6)
    184 #define CPU_SUBTYPE_VAX8200         INT32_C(7)
    185 #define CPU_SUBTYPE_VAX8500         INT32_C(8)
    186 #define CPU_SUBTYPE_VAX8600         INT32_C(9)
    187 #define CPU_SUBTYPE_VAX8650         INT32_C(10)
    188 #define CPU_SUBTYPE_VAX8800         INT32_C(11)
    189 #define CPU_SUBTYPE_UVAXIII         INT32_C(12)
     177#define CPU_SUBTYPE_VAX_ALL         KI32_C(0)
     178#define CPU_SUBTYPE_VAX780          KI32_C(1)
     179#define CPU_SUBTYPE_VAX785          KI32_C(2)
     180#define CPU_SUBTYPE_VAX750          KI32_C(3)
     181#define CPU_SUBTYPE_VAX730          KI32_C(4)
     182#define CPU_SUBTYPE_UVAXI           KI32_C(5)
     183#define CPU_SUBTYPE_UVAXII          KI32_C(6)
     184#define CPU_SUBTYPE_VAX8200         KI32_C(7)
     185#define CPU_SUBTYPE_VAX8500         KI32_C(8)
     186#define CPU_SUBTYPE_VAX8600         KI32_C(9)
     187#define CPU_SUBTYPE_VAX8650         KI32_C(10)
     188#define CPU_SUBTYPE_VAX8800         KI32_C(11)
     189#define CPU_SUBTYPE_UVAXIII         KI32_C(12)
    190190
    191191/* MC680xx */
    192 #define CPU_SUBTYPE_MC680x0_ALL     INT32_C(1)
    193 #define CPU_SUBTYPE_MC68030         INT32_C(1)
    194 #define CPU_SUBTYPE_MC68040         INT32_C(2)
    195 #define CPU_SUBTYPE_MC68030_ONLY    INT32_C(3)
     192#define CPU_SUBTYPE_MC680x0_ALL     KI32_C(1)
     193#define CPU_SUBTYPE_MC68030         KI32_C(1)
     194#define CPU_SUBTYPE_MC68040         KI32_C(2)
     195#define CPU_SUBTYPE_MC68030_ONLY    KI32_C(3)
    196196
    197197/* I386 */
    198 #define CPU_SUBTYPE_INTEL(fam, model)       ( (int32_t)(((model) << 4) | (fam)) )
     198#define CPU_SUBTYPE_INTEL(fam, model)       ( (KI32)(((model) << 4) | (fam)) )
    199199#define CPU_SUBTYPE_INTEL_FAMILY(subtype)   ( (subtype) & 0xf )
    200200#define CPU_SUBTYPE_INTEL_MODEL(subtype)    ( (subtype) >> 4 )
    … …  
    225225
    226226/* X86 */
    227 #define CPU_SUBTYPE_X86_ALL         INT32_C(3) /* CPU_SUBTYPE_I386_ALL */
    228 #define CPU_SUBTYPE_X86_64_ALL      INT32_C(3) /* CPU_SUBTYPE_I386_ALL */
    229 #define CPU_SUBTYPE_X86_ARCH1       INT32_C(4) /* CPU_SUBTYPE_I486_ALL */
     227#define CPU_SUBTYPE_X86_ALL         KI32_C(3) /* CPU_SUBTYPE_I386_ALL */
     228#define CPU_SUBTYPE_X86_64_ALL      KI32_C(3) /* CPU_SUBTYPE_I386_ALL */
     229#define CPU_SUBTYPE_X86_ARCH1       KI32_C(4) /* CPU_SUBTYPE_I486_ALL */
    230230
    231231/* MIPS */
    232 #define CPU_SUBTYPE_MIPS_ALL        INT32_C(0)
    233 #define CPU_SUBTYPE_MIPS_R2300      INT32_C(1)
    234 #define CPU_SUBTYPE_MIPS_R2600      INT32_C(2)
    235 #define CPU_SUBTYPE_MIPS_R2800      INT32_C(3)
    236 #define CPU_SUBTYPE_MIPS_R2000a     INT32_C(4)
    237 #define CPU_SUBTYPE_MIPS_R2000      INT32_C(5)
    238 #define CPU_SUBTYPE_MIPS_R3000a     INT32_C(6)
    239 #define CPU_SUBTYPE_MIPS_R3000      INT32_C(7)
     232#define CPU_SUBTYPE_MIPS_ALL        KI32_C(0)
     233#define CPU_SUBTYPE_MIPS_R2300      KI32_C(1)
     234#define CPU_SUBTYPE_MIPS_R2600      KI32_C(2)
     235#define CPU_SUBTYPE_MIPS_R2800      KI32_C(3)
     236#define CPU_SUBTYPE_MIPS_R2000a     KI32_C(4)
     237#define CPU_SUBTYPE_MIPS_R2000      KI32_C(5)
     238#define CPU_SUBTYPE_MIPS_R3000a     KI32_C(6)
     239#define CPU_SUBTYPE_MIPS_R3000      KI32_C(7)
    240240
    241241/* MC98000 (PowerPC) */
    242 #define CPU_SUBTYPE_MC98000_ALL     INT32_C(0)
    243 #define CPU_SUBTYPE_MC98601         INT32_C(1)
     242#define CPU_SUBTYPE_MC98000_ALL     KI32_C(0)
     243#define CPU_SUBTYPE_MC98601         KI32_C(1)
    244244
    245245/* HP-PA */
    246 #define CPU_SUBTYPE_HPPA_ALL        INT32_C(0)
    247 #define CPU_SUBTYPE_HPPA_7100       INT32_C(0)
    248 #define CPU_SUBTYPE_HPPA_7100LC     INT32_C(1)
     246#define CPU_SUBTYPE_HPPA_ALL        KI32_C(0)
     247#define CPU_SUBTYPE_HPPA_7100       KI32_C(0)
     248#define CPU_SUBTYPE_HPPA_7100LC     KI32_C(1)
    249249
    250250/* MC88000 */
    251 #define CPU_SUBTYPE_MC88000_ALL     INT32_C(0)
    252 #define CPU_SUBTYPE_MC88100         INT32_C(1)
    253 #define CPU_SUBTYPE_MC88110         INT32_C(2)
     251#define CPU_SUBTYPE_MC88000_ALL     KI32_C(0)
     252#define CPU_SUBTYPE_MC88100         KI32_C(1)
     253#define CPU_SUBTYPE_MC88110         KI32_C(2)
    254254
    255255/* SPARC */
    256 #define CPU_SUBTYPE_SPARC_ALL       INT32_C(0)
     256#define CPU_SUBTYPE_SPARC_ALL       KI32_C(0)
    257257
    258258/* I860 */
    259 #define CPU_SUBTYPE_I860_ALL        INT32_C(0)
    260 #define CPU_SUBTYPE_I860_860        INT32_C(1)
     259#define CPU_SUBTYPE_I860_ALL        KI32_C(0)
     260#define CPU_SUBTYPE_I860_860        KI32_C(1)
    261261
    262262/* PowerPC */
    263 #define CPU_SUBTYPE_POWERPC_ALL     INT32_C(0)
    264 #define CPU_SUBTYPE_POWERPC_601     INT32_C(1)
    265 #define CPU_SUBTYPE_POWERPC_602     INT32_C(2)
    266 #define CPU_SUBTYPE_POWERPC_603     INT32_C(3)
    267 #define CPU_SUBTYPE_POWERPC_603e    INT32_C(4)
    268 #define CPU_SUBTYPE_POWERPC_603ev   INT32_C(5)
    269 #define CPU_SUBTYPE_POWERPC_604     INT32_C(6)
    270 #define CPU_SUBTYPE_POWERPC_604e    INT32_C(7)
    271 #define CPU_SUBTYPE_POWERPC_620     INT32_C(8)
    272 #define CPU_SUBTYPE_POWERPC_750     INT32_C(9)
    273 #define CPU_SUBTYPE_POWERPC_7400    INT32_C(10)
    274 #define CPU_SUBTYPE_POWERPC_7450    INT32_C(11)
    275 #define CPU_SUBTYPE_POWERPC_Max     INT32_C(10)
    276 #define CPU_SUBTYPE_POWERPC_SCVger  INT32_C(11)
    277 #define CPU_SUBTYPE_POWERPC_970     INT32_C(100)
     263#define CPU_SUBTYPE_POWERPC_ALL     KI32_C(0)
     264#define CPU_SUBTYPE_POWERPC_601     KI32_C(1)
     265#define CPU_SUBTYPE_POWERPC_602     KI32_C(2)
     266#define CPU_SUBTYPE_POWERPC_603     KI32_C(3)
     267#define CPU_SUBTYPE_POWERPC_603e    KI32_C(4)
     268#define CPU_SUBTYPE_POWERPC_603ev   KI32_C(5)
     269#define CPU_SUBTYPE_POWERPC_604     KI32_C(6)
     270#define CPU_SUBTYPE_POWERPC_604e    KI32_C(7)
     271#define CPU_SUBTYPE_POWERPC_620     KI32_C(8)
     272#define CPU_SUBTYPE_POWERPC_750     KI32_C(9)
     273#define CPU_SUBTYPE_POWERPC_7400    KI32_C(10)
     274#define CPU_SUBTYPE_POWERPC_7450    KI32_C(11)
     275#define CPU_SUBTYPE_POWERPC_Max     KI32_C(10)
     276#define CPU_SUBTYPE_POWERPC_SCVger  KI32_C(11)
     277#define CPU_SUBTYPE_POWERPC_970     KI32_C(100)
    278278
    279279/** @} */
    … …  
    292292typedef struct load_command
    293293{
    294     uint32_t        cmd;            /**< The load command id. */
    295     uint32_t        cmdsize;        /**< The size of the command (including this header). */
     294    KU32            cmd;            /**< The load command id. */
     295    KU32            cmdsize;        /**< The size of the command (including this header). */
    296296} load_command_t;
    297297
    … …  
    302302 * grok the command. The dynamic linker will otherwise ignore commands it
    303303 * doesn't understand. Introduced with Mac OS X 10.1. */
    304 #define LC_REQ_DYLD         UINT32_C(0x80000000)
    305 
    306 #define LC_SEGMENT_32       UINT32_C(0x01)  /**< Segment to be mapped (32-bit). See segment_command_32. */
    307 #define LC_SYMTAB           UINT32_C(0x02)  /**< 'stab' symbol table. See symtab_command. */
    308 #define LC_SYMSEG           UINT32_C(0x03)  /**< Obsoleted gdb symbol table. */
    309 #define LC_THREAD           UINT32_C(0x04)  /**< Thread. See thread_command. */
    310 #define LC_UNIXTHREAD       UINT32_C(0x05)  /**< Unix thread (includes stack and stuff). See thread_command. */
    311 #define LC_LOADFVMLIB       UINT32_C(0x06)  /**< Load a specified fixed VM shared library  (obsolete?). See fvmlib_command. */
    312 #define LC_IDFVMLIB         UINT32_C(0x07)  /**< Fixed VM shared library id (obsolete?). See fvmlib_command. */
    313 #define LC_IDENT            UINT32_C(0x08)  /**< Identification info (obsolete). See ident_command. */
    314 #define LC_FVMFILE          UINT32_C(0x09)  /**< Fixed VM file inclusion (internal). See fvmfile_command. */
    315 #define LC_PREPAGE          UINT32_C(0x0a)  /**< Prepage command (internal). See ?? */
    316 #define LC_DYSYMTAB         UINT32_C(0x0b)  /**< Symbol table for dynamic linking. See dysymtab_command. */
    317 #define LC_LOAD_DYLIB       UINT32_C(0x0c)  /**< Load a dynamically linked shared library. See dylib_command. */
    318 #define LC_ID_DYLIB         UINT32_C(0x0d)  /**< Dynamically linked share library ident. See dylib_command. */
    319 #define LC_LOAD_DYLINKER    UINT32_C(0x0e)  /**< Load a dynamical link editor. See dylinker_command. */
    320 #define LC_ID_DYLINKER      UINT32_C(0x0f)  /**< Dynamic link editor ident. See dylinker_command. */
    321 #define LC_PREBOUND_DYLIB   UINT32_C(0x10)  /**< Prebound modules for dynamically linking of a shared lib. See prebound_dylib_command. */
    322 #define LC_ROUTINES         UINT32_C(0x11)  /**< Image routines. See routines_command_32. */
    323 #define LC_SUB_FRAMEWORK    UINT32_C(0x12)  /**< Sub framework. See sub_framework_command. */
    324 #define LC_SUB_UMBRELLA     UINT32_C(0x13)  /**< Sub umbrella. See sub_umbrella_command. */
    325 #define LC_SUB_CLIENT       UINT32_C(0x14)  /**< Sub client. See sub_client_command. */
    326 #define LC_SUB_LIBRARY      UINT32_C(0x15)  /**< Sub library. See sub_library_command. */
    327 #define LC_TWOLEVEL_HINTS   UINT32_C(0x16)  /**< Two-level namespace lookup hints. See twolevel_hints_command. */
    328 #define LC_PREBIND_CKSUM    UINT32_C(0x17)  /**< Prebind checksum. See prebind_cksum_command. */
    329 #define LC_LOAD_WEAK_DYLIB (UINT32_C(0x18) | LC_REQ_DYLD) /**< Dylib that can be missing, all symbols weak. See dylib_command. */
    330 #define LC_SEGMENT_64       UINT32_C(0x19)  /**< segment to be mapped (64-bit). See segment_command_32. */
    331 #define LC_ROUTINES_64      UINT32_C(0x1a)  /**< Image routines (64-bit). See routines_command_32. */
    332 #define LC_UUID             UINT32_C(0x1b)  /**< The UUID of the object module. See uuid_command.  */
     304#define LC_REQ_DYLD         KU32_C(0x80000000)
     305
     306#define LC_SEGMENT_32       KU32_C(0x01)  /**< Segment to be mapped (32-bit). See segment_command_32. */
     307#define LC_SYMTAB           KU32_C(0x02)  /**< 'stab' symbol table. See symtab_command. */
     308#define LC_SYMSEG           KU32_C(0x03)  /**< Obsoleted gdb symbol table. */
     309#define LC_THREAD           KU32_C(0x04)  /**< Thread. See thread_command. */
     310#define LC_UNIXTHREAD       KU32_C(0x05)  /**< Unix thread (includes stack and stuff). See thread_command. */
     311#define LC_LOADFVMLIB       KU32_C(0x06)  /**< Load a specified fixed VM shared library  (obsolete?). See fvmlib_command. */
     312#define LC_IDFVMLIB         KU32_C(0x07)  /**< Fixed VM shared library id (obsolete?). See fvmlib_command. */
     313#define LC_IDENT            KU32_C(0x08)  /**< Identification info (obsolete). See ident_command. */
     314#define LC_FVMFILE          KU32_C(0x09)  /**< Fixed VM file inclusion (internal). See fvmfile_command. */
     315#define LC_PREPAGE          KU32_C(0x0a)  /**< Prepage command (internal). See ?? */
     316#define LC_DYSYMTAB         KU32_C(0x0b)  /**< Symbol table for dynamic linking. See dysymtab_command. */
     317#define LC_LOAD_DYLIB       KU32_C(0x0c)  /**< Load a dynamically linked shared library. See dylib_command. */
     318#define LC_ID_DYLIB         KU32_C(0x0d)  /**< Dynamically linked share library ident. See dylib_command. */
     319#define LC_LOAD_DYLINKER    KU32_C(0x0e)  /**< Load a dynamical link editor. See dylinker_command. */
     320#define LC_ID_DYLINKER      KU32_C(0x0f)  /**< Dynamic link editor ident. See dylinker_command. */
     321#define LC_PREBOUND_DYLIB   KU32_C(0x10)  /**< Prebound modules for dynamically linking of a shared lib. See prebound_dylib_command. */
     322#define LC_ROUTINES         KU32_C(0x11)  /**< Image routines. See routines_command_32. */
     323#define LC_SUB_FRAMEWORK    KU32_C(0x12)  /**< Sub framework. See sub_framework_command. */
     324#define LC_SUB_UMBRELLA     KU32_C(0x13)  /**< Sub umbrella. See sub_umbrella_command. */
     325#define LC_SUB_CLIENT       KU32_C(0x14)  /**< Sub client. See sub_client_command. */
     326#define LC_SUB_LIBRARY      KU32_C(0x15)  /**< Sub library. See sub_library_command. */
     327#define LC_TWOLEVEL_HINTS   KU32_C(0x16)  /**< Two-level namespace lookup hints. See twolevel_hints_command. */
     328#define LC_PREBIND_CKSUM    KU32_C(0x17)  /**< Prebind checksum. See prebind_cksum_command. */
     329#define LC_LOAD_WEAK_DYLIB (KU32_C(0x18) | LC_REQ_DYLD) /**< Dylib that can be missing, all symbols weak. See dylib_command. */
     330#define LC_SEGMENT_64       KU32_C(0x19)  /**< segment to be mapped (64-bit). See segment_command_32. */
     331#define LC_ROUTINES_64      KU32_C(0x1a)  /**< Image routines (64-bit). See routines_command_32. */
     332#define LC_UUID             KU32_C(0x1b)  /**< The UUID of the object module. See uuid_command.  */
    333333/** @} */
    334334
    … …  
    342342     * The string is zero-terminated. the size of the load command
    343343     * is zero padded up to a multiple of 4 bytes. */
    344     uint32_t        offset;
     344    KU32            offset;
    345345} lc_str_t;
    346346
    … …  
    351351typedef struct segment_command_32
    352352{
    353     uint32_t        cmd;            /**< LC_SEGMENT */
    354     uint32_t        cmdsize;        /**< sizeof(self) + sections. */
     353    KU32            cmd;            /**< LC_SEGMENT */
     354    KU32            cmdsize;        /**< sizeof(self) + sections. */
    355355    char            segname[16];    /**< The segment name. */
    356     uint32_t        vmaddr;         /**< Memory address of this segment. */
    357     uint32_t        vmsize;         /**< Size of this segment. */
    358     uint32_t        fileoff;        /**< The file location of the segment. */
    359     uint32_t        filesize;       /**< The file size of the segment. */
    360     uint32_t        maxprot;        /**< Maximum VM protection. */
    361     uint32_t        initprot;       /**< Initial VM protection. */
    362     uint32_t        nsects;         /**< Number of section desciptors following this structure. */
    363     uint32_t        flags;          /**< Flags (SG_*). */
     356    KU32            vmaddr;         /**< Memory address of this segment. */
     357    KU32            vmsize;         /**< Size of this segment. */
     358    KU32            fileoff;        /**< The file location of the segment. */
     359    KU32            filesize;       /**< The file size of the segment. */
     360    KU32            maxprot;        /**< Maximum VM protection. */
     361    KU32            initprot;       /**< Initial VM protection. */
     362    KU32            nsects;         /**< Number of section desciptors following this structure. */
     363    KU32            flags;          /**< Flags (SG_*). */
    364364} segment_command_32_t;
    365365
    … …  
    371371typedef struct segment_command_64
    372372{
    373     uint32_t        cmd;            /**< LC_SEGMENT */
    374     uint32_t        cmdsize;        /**< sizeof(self) + sections. */
     373    KU32            cmd;            /**< LC_SEGMENT */
     374    KU32            cmdsize;        /**< sizeof(self) + sections. */
    375375    char            segname[16];    /**< The segment name. */
    376     uint64_t        vmaddr;         /**< Memory address of this segment. */
    377     uint64_t        vmsize;         /**< Size of this segment. */
    378     uint64_t        fileoff;        /**< The file location of the segment. */
    379     uint64_t        filesize;       /**< The file size of the segment. */
    380     uint32_t        maxprot;        /**< Maximum VM protection. */
    381     uint32_t        initprot;       /**< Initial VM protection. */
    382     uint32_t        nsects;         /**< Number of section desciptors following this structure. */
    383     uint32_t        flags;          /**< Flags (SG_*). */
     376    KU64            vmaddr;         /**< Memory address of this segment. */
     377    KU64            vmsize;         /**< Size of this segment. */
     378    KU64            fileoff;        /**< The file location of the segment. */
     379    KU64            filesize;       /**< The file size of the segment. */
     380    KU32            maxprot;        /**< Maximum VM protection. */
     381    KU32            initprot;       /**< Initial VM protection. */
     382    KU32            nsects;         /**< Number of section desciptors following this structure. */
     383    KU32            flags;          /**< Flags (SG_*). */
    384384} segment_command_64_t;
    385385
    … …  
    389389 * instead of the low end. Intended for stacks in core dumps.
    390390 * The part of the segment memory not covered by file bits will be zeroed. */
    391 #define SG_HIGHVM           UINT32_C(0x00000001)
     391#define SG_HIGHVM           KU32_C(0x00000001)
    392392/** This segment is the virtual memory allocated by a fixed VM library.
    393393 * (Used for overlap checking in the linker.) */
    394 #define SG_FVMLIB           UINT32_C(0x00000002)
     394#define SG_FVMLIB           KU32_C(0x00000002)
    395395/** No relocations for or symbols that's relocated to in this segment.
    396396 * The segment can therefore safely be replaced. */
    397 #define SG_NORELOC          UINT32_C(0x00000004)
     397#define SG_NORELOC          KU32_C(0x00000004)
    398398/** The segment is protected.
    399399 * The first page isn't protected if it starts at file offset 0
    400400 * (so that the mach header and this load command can be easily mapped). */
    401 #define SG_PROTECTED_VERSION_1 UINT32_C(0x00000008)
     401#define SG_PROTECTED_VERSION_1 KU32_C(0x00000008)
    402402/** @} */
    403403
    … …  
    410410    char            sectname[16];   /**< The section name. */
    411411    char            segname[16];    /**< The name of the segment this section goes into. */
    412     uint32_t        addr;           /**< The memory address of this section. */
    413     uint32_t        size;           /**< The size of this section. */
    414     uint32_t        offset;         /**< The file offset of this section. */
    415     uint32_t        align;          /**< The section alignment (**2). */
    416     uint32_t        reloff;         /**< The file offset of the relocations. */
    417     uint32_t        nreloc;         /**< The number of relocations. */
    418     uint32_t        flags;          /**< The section flags; section type and attribs */
    419     uint32_t        reserved1;      /**< Reserved / offset / index. */
    420     uint32_t        reserved2;      /**< Reserved / count / sizeof. */
     412    KU32            addr;           /**< The memory address of this section. */
     413    KU32            size;           /**< The size of this section. */
     414    KU32            offset;         /**< The file offset of this section. */
     415    KU32            align;          /**< The section alignment (**2). */
     416    KU32            reloff;         /**< The file offset of the relocations. */
     417    KU32            nreloc;         /**< The number of relocations. */
     418    KU32            flags;          /**< The section flags; section type and attribs */
     419    KU32            reserved1;      /**< Reserved / offset / index. */
     420    KU32            reserved2;      /**< Reserved / count / sizeof. */
    421421} section_32_t;
    422422
    … …  
    428428    char            sectname[16];   /**< The section name. */
    429429    char            segname[16];    /**< The name of the segment this section goes into. */
    430     uint64_t        addr;           /**< The memory address of this section. */
    431     uint64_t        size;           /**< The size of this section. */
    432     uint32_t        offset;         /**< The file offset of this section. */
    433     uint32_t        align;          /**< The section alignment (**2). */
    434     uint32_t        reloff;         /**< The file offset of the relocations. */
    435     uint32_t        nreloc;         /**< The number of relocations. */
    436     uint32_t        flags;          /**< The section flags; section type and attribs */
    437     uint32_t        reserved1;      /**< Reserved / offset / index. */
    438     uint32_t        reserved2;      /**< Reserved / count / sizeof. */
    439     uint32_t        reserved3;      /**< (Just) Reserved. */
     430    KU64            addr;           /**< The memory address of this section. */
     431    KU64            size;           /**< The size of this section. */
     432    KU32            offset;         /**< The file offset of this section. */
     433    KU32            align;          /**< The section alignment (**2). */
     434    KU32            reloff;         /**< The file offset of the relocations. */
     435    KU32            nreloc;         /**< The number of relocations. */
     436    KU32            flags;          /**< The section flags; section type and attribs */
     437    KU32            reserved1;      /**< Reserved / offset / index. */
     438    KU32            reserved2;      /**< Reserved / count / sizeof. */
     439    KU32            reserved3;      /**< (Just) Reserved. */
    440440} section_64_t;
    441441
    … …  
    444444 */
    445445/** Section type mask. */
    446 #define SECTION_TYPE                UINT32_C(0x000000ff)
     446#define SECTION_TYPE                KU32_C(0x000000ff)
    447447/** Regular section. */
    448448#define S_REGULAR                   0x0
    … …  
    480480
    481481/** Section attribute mask. */
    482 #define SECTION_ATTRIBUTES          UINT32_C(0xffffff00)
     482#define SECTION_ATTRIBUTES          KU32_C(0xffffff00)
    483483
    484484/** User settable attribute mask. */
    485 #define SECTION_ATTRIBUTES_USR      UINT32_C(0xff000000)
     485#define SECTION_ATTRIBUTES_USR      KU32_C(0xff000000)
    486486/** Pure instruction (code). */
    487 #define S_ATTR_PURE_INSTRUCTIONS    UINT32_C(0x80000000)
     487#define S_ATTR_PURE_INSTRUCTIONS    KU32_C(0x80000000)
    488488/** ranlib, ignore my symbols... */
    489 #define S_ATTR_NO_TOC               UINT32_C(0x40000000)
     489#define S_ATTR_NO_TOC               KU32_C(0x40000000)
    490490/** May strip static symbols when linking int a MH_DYLDLINK file. */
    491 #define S_ATTR_STRIP_STATIC_SYMS    UINT32_C(0x20000000)
     491#define S_ATTR_STRIP_STATIC_SYMS    KU32_C(0x20000000)
    492492/** No dead stripping. */
    493 #define S_ATTR_NO_DEAD_STRIP        UINT32_C(0x10000000)
     493#define S_ATTR_NO_DEAD_STRIP        KU32_C(0x10000000)
    494494/** Live support. */
    495 #define S_ATTR_LIVE_SUPPORT         UINT32_C(0x08000000)
     495#define S_ATTR_LIVE_SUPPORT         KU32_C(0x08000000)
    496496/** Contains self modifying code (generally i386 code stub for dyld). */
    497 #define S_ATTR_SELF_MODIFYING_CODE  UINT32_C(0x04000000)
     497#define S_ATTR_SELF_MODIFYING_CODE  KU32_C(0x04000000)
    498498/** Debug info (DWARF usually). */
    499 #define S_ATTR_DEBUG                UINT32_C(0x02000000)
     499#define S_ATTR_DEBUG                KU32_C(0x02000000)
    500500
    501501/** System settable attribute mask. */
    502 #define SECTION_ATTRIBUTES_SYS      UINT32_C(0x00ffff00)
     502#define SECTION_ATTRIBUTES_SYS      KU32_C(0x00ffff00)
    503503/** Contains some instructions (code). */
    504 #define S_ATTR_SOME_INSTRUCTIONS    UINT32_C(0x00000400)
     504#define S_ATTR_SOME_INSTRUCTIONS    KU32_C(0x00000400)
    505505/** Has external relocations. */
    506 #define S_ATTR_EXT_RELOC            UINT32_C(0x00000200)
     506#define S_ATTR_EXT_RELOC            KU32_C(0x00000200)
    507507/** Has internal (local) relocations. */
    508 #define S_ATTR_LOC_RELOC            UINT32_C(0x00000100)
     508#define S_ATTR_LOC_RELOC            KU32_C(0x00000100)
    509509/** @} */
    510510
    … …  
    577577 * is made up of a number of state structures preceded by a 32-bit flavor
    578578 * and 32-bit count field stating the kind of stat structure and it's size
    579  * in uint32_t items respecitvly.
     579 * in KU32 items respecitvly.
    580580 *
    581581 * LC_UNIXTHREAD differs from LC_THREAD in that it implies stack creation
    … …  
    585585typedef struct thread_command
    586586{
    587     uint32_t        cmd;        /**< LC_UNIXTHREAD or LC_THREAD. */
    588     uint32_t        cmdsize;    /**< The size of the command (including this header). */
     587    KU32            cmd;        /**< LC_UNIXTHREAD or LC_THREAD. */
     588    KU32            cmdsize;    /**< The size of the command (including this header). */
    589589} thread_command_t;
    590590
    … …  
    600600typedef struct symtab_command
    601601{
    602     uint32_t        cmd;        /**< LC_SYMTAB */
    603     uint32_t        cmdsize;    /** sizeof(symtab_command_t) */
    604     uint32_t        symoff;     /** The file offset of the symbol table. */
    605     uint32_t        nsyms;      /** The number of symbols in the symbol table. */
    606     uint32_t        stroff;     /** The file offset of the string table. */
    607     uint32_t        strsize;    /** The size of the string table. */
     602    KU32            cmd;        /**< LC_SYMTAB */
     603    KU32            cmdsize;    /** sizeof(symtab_command_t) */
     604    KU32            symoff;     /** The file offset of the symbol table. */
     605    KU32            nsyms;      /** The number of symbols in the symbol table. */
     606    KU32            stroff;     /** The file offset of the string table. */
     607    KU32            strsize;    /** The size of the string table. */
    608608} symtab_command_t;
    609609
    … …  
    624624typedef struct uuid_command
    625625{
    626     uint32_t        cmd;        /**< LC_UUID */
    627     uint32_t        cmdsize;    /**< sizeof(uuid_command_t) */
    628     uint8_t         uuid[16];   /** The UUID bytes. */
     626    KU32            cmd;        /**< LC_UUID */
     627    KU32            cmdsize;    /**< sizeof(uuid_command_t) */
     628    KU8             uuid[16];   /** The UUID bytes. */
    629629} uuid_command_t;
    630630
    … …  
    652652    union
    653653    {
    654         int32_t n_strx;         /**< Offset (index) into the string table. 0 means "". */
     654        KI32    n_strx;         /**< Offset (index) into the string table. 0 means "". */
    655655    }           n_un;
    656     uint8_t     n_type;         /**< Symbol type. */
    657     uint8_t     n_sect;         /**< Section number of NO_SECT. */
    658     int16_t     n_desc;         /**< Type specific, debug info details mostly.*/
    659     uint32_t    n_value;        /**< The symbol value or stab offset. */
     656    KU8         n_type;         /**< Symbol type. */
     657    KU8         n_sect;         /**< Section number of NO_SECT. */
     658    KI16        n_desc;         /**< Type specific, debug info details mostly.*/
     659    KU32        n_value;        /**< The symbol value or stab offset. */
    660660} macho_nlist_32_t;
    661661
    … …  
    669669    union
    670670    {
    671         uint32_t n_strx;        /**< Offset (index) into the string table. 0 means "". */
     671        KU32    n_strx;         /**< Offset (index) into the string table. 0 means "". */
    672672    }           n_un;
    673     uint8_t     n_type;         /**< Symbol type. */
    674     uint8_t     n_sect;         /**< Section number of NO_SECT. */
    675     int16_t     n_desc;         /**< Type specific, debug info details mostly.*/
    676     uint64_t    n_value;        /**< The symbol value or stab offset. */
     673    KU8         n_type;         /**< Symbol type. */
     674    KU8         n_sect;         /**< Section number of NO_SECT. */
     675    KI16        n_desc;         /**< Type specific, debug info details mostly.*/
     676    KU64        n_value;        /**< The symbol value or stab offset. */
    677677} macho_nlist_64_t;
    678678
    … …  
    709709
    710710/* Base masks. */
    711 #define MACHO_N_EXT     UINT8_C(0x01)   /**< External symbol (when set) (N_EXT). */
    712 #define MACHO_N_TYPE    UINT8_C(0x0e)   /**< Symbol type (N_TYPE without the 8th bit). */
    713 #define MACHO_N_PEXT    UINT8_C(0x10)   /**< Private extern symbol (when set). (M) */
    714 #define MACHO_N_STAB    UINT8_C(0xe0)   /**< Debug symbol mask (N_STAB). */
     711#define MACHO_N_EXT     KU8_C(0x01)   /**< External symbol (when set) (N_EXT). */
     712#define MACHO_N_TYPE    KU8_C(0x0e)   /**< Symbol type (N_TYPE without the 8th bit). */
     713#define MACHO_N_PEXT    KU8_C(0x10)   /**< Private extern symbol (when set). (M) */
     714#define MACHO_N_STAB    KU8_C(0xe0)   /**< Debug symbol mask (N_STAB). */
    715715
    716716/* MACHO_N_TYPE values. */
    717 #define MACHO_N_UNDF    UINT8_C(0x00)   /**< MACHO_N_TYPE: Undefined symbol (N_UNDF). n_sect = NO_SECT. */
    718 #define MACHO_N_ABS     UINT8_C(0x02)   /**< MACHO_N_TYPE: Absolute symbol (N_UNDF). n_sect = NO_SECT. */
    719 #define MACHO_N_INDR    UINT8_C(0x0a)   /**< MACHO_N_TYPE: Indirect symbol, n_value is the index of the symbol. (M) */
    720 #define MACHO_N_PBUD    UINT8_C(0x0c)   /**< MACHO_N_TYPE: Prebound undefined symbo (defined in a dylib). (M) */
    721 #define MACHO_N_SECT    UINT8_C(0x0e)   /**< MACHO_N_TYPE: Defined in the section given by n_sects. (M) */
     717#define MACHO_N_UNDF    KU8_C(0x00)   /**< MACHO_N_TYPE: Undefined symbol (N_UNDF). n_sect = NO_SECT. */
     718#define MACHO_N_ABS     KU8_C(0x02)   /**< MACHO_N_TYPE: Absolute symbol (N_UNDF). n_sect = NO_SECT. */
     719#define MACHO_N_INDR    KU8_C(0x0a)   /**< MACHO_N_TYPE: Indirect symbol, n_value is the index of the symbol. (M) */
     720#define MACHO_N_PBUD    KU8_C(0x0c)   /**< MACHO_N_TYPE: Prebound undefined symbo (defined in a dylib). (M) */
     721#define MACHO_N_SECT    KU8_C(0x0e)   /**< MACHO_N_TYPE: Defined in the section given by n_sects. (M) */
    722722
    723723/* Debug symbols. */
    724 #define MACHO_N_GSYM    UINT8_C(0x20)   /**< Global variable.       "name",, NO_SECT, type, 0       (2) */
    725 #define MACHO_N_FNAME   UINT8_C(0x22)   /**< Function name (F77).   "name",, NO_SECT, 0, 0 */
    726 #define MACHO_N_FUN     UINT8_C(0x24)   /**< Function / text var.   "name",, section, line, address (1) */
    727 #define MACHO_N_STSYM   UINT8_C(0x26)   /**< Static data symbol.    "name",, section, type, address (2) */
    728 #define MACHO_N_LCSYM   UINT8_C(0x28)   /**< static bss symbol.     "name",, section, type, address (2) */
     724#define MACHO_N_GSYM    KU8_C(0x20)   /**< Global variable.       "name",, NO_SECT, type, 0       (2) */
     725#define MACHO_N_FNAME   KU8_C(0x22)   /**< Function name (F77).   "name",, NO_SECT, 0, 0 */
     726#define MACHO_N_FUN     KU8_C(0x24)   /**< Function / text var.   "name",, section, line, address (1) */
     727#define MACHO_N_STSYM   KU8_C(0x26)   /**< Static data symbol.    "name",, section, type, address (2) */
     728#define MACHO_N_LCSYM   KU8_C(0x28)   /**< static bss symbol.     "name",, section, type, address (2) */
    729729    /* omits N_MAIN and N_ROSYM. */
    730 #define MACHO_N_BNSYM   UINT8_C(0x2e)   /**< Begin nsect symbol.         0,, section, 0, address (M) */
    731 #define MACHO_N_PC      UINT8_C(0x30)   /**< Global pascal symbol.  "name",, NO_SECT, subtype?, line (3) */
     730#define MACHO_N_BNSYM   KU8_C(0x2e)   /**< Begin nsect symbol.         0,, section, 0, address (M) */
     731#define MACHO_N_PC      KU8_C(0x30)   /**< Global pascal symbol.  "name",, NO_SECT, subtype?, line (3) */
    732732    /* omits N_NSYMS, N_NOMAP and N_OBJ. */
    733 #define MACHO_N_OPT     UINT8_C(0x3c)   /**< Options for the debugger related to the language of the
     733#define MACHO_N_OPT     KU8_C(0x3c)   /**< Options for the debugger related to the language of the
    734734                                             source file.           "options?",,,, */
    735 #define MACHO_N_RSYM    UINT8_C(0x40)   /**< Register variable.     "name",, NO_SECT, type, register */
     735#define MACHO_N_RSYM    KU8_C(0x40)   /**< Register variable.     "name",, NO_SECT, type, register */
    736736    /* omits N_M2C */
    737 #define MACHO_N_SLINE   UINT8_C(0x44)   /**< Source line.                0,, section, line, address */
     737#define MACHO_N_SLINE   KU8_C(0x44)   /**< Source line.                0,, section, line, address */
    738738    /* omits N_DSLINE, N_BSLINE / N_BROWS, N_DEFD and N_FLINE. */
    739 #define MACHO_N_ENSYM   UINT8_C(0x4e)   /**< End nsect symbol.           0,, section, 0, address (M) */
     739#define MACHO_N_ENSYM   KU8_C(0x4e)   /**< End nsect symbol.           0,, section, 0, address (M) */
    740740    /* omits N_EHDECL / N_MOD2 and N_CATCH. */
    741 #define MACHO_N_SSYM    UINT8_C(0x60)   /**< Struct/union element.  "name",, NO_SECT, type, offset */
     741#define MACHO_N_SSYM    KU8_C(0x60)   /**< Struct/union element.  "name",, NO_SECT, type, offset */
    742742    /* omits N_ENDM */
    743 #define MACHO_N_SO      UINT8_C(0x64)   /**< Source file name.      "fname",, section, 0, address */
    744 #define MACHO_N_OSO     UINT8_C(0x66)   /**< Object file name.      "fname",, 0, 0, st_mtime (M?) */
     743#define MACHO_N_SO      KU8_C(0x64)   /**< Source file name.      "fname",, section, 0, address */
     744#define MACHO_N_OSO     KU8_C(0x66)   /**< Object file name.      "fname",, 0, 0, st_mtime (M?) */
    745745    /* omits N_ALIAS */
    746 #define MACHO_N_LSYM    UINT8_C(0x80)   /**< Stack variable.        "name",, NO_SECT, type, frame_offset */
    747 #define MACHO_N_BINCL   UINT8_C(0x82)   /**< Begin #include.        "fname",, NO_SECT, 0, sum? */
    748 #define MACHO_N_SOL     UINT8_C(0x84)   /**< #included file.        "fname",, section, 0, start_address (S) */
    749 #define MACHO_N_PARAMS  UINT8_C(0x86)   /**< Compiler params.       "params",, NO_SECT, 0, 0 */
    750 #define MACHO_N_VERSION UINT8_C(0x88)   /**< Compiler version.      "version",, NO_SECT, 0, 0 */
    751 #define MACHO_N_OLEVEL  UINT8_C(0x8A)   /**< Compiler -O level.     "level",, NO_SECT, 0, 0 */
    752 #define MACHO_N_PSYM    UINT8_C(0xa0)   /**< Parameter variable.    "name",, NO_SECT, type, frame_offset */
    753 #define MACHO_N_EINCL   UINT8_C(0xa2)   /**< End #include.          "fname",, NO_SECT, 0, 0 (S) */
    754 #define MACHO_N_ENTRY   UINT8_C(0xa4)   /**< Alternate entry point. "name",, section, line, address */
    755 #define MACHO_N_LBRAC   UINT8_C(0xc0)   /**< Left bracket.               0,, NO_SECT, nesting_level, address */
    756 #define MACHO_N_EXCL    UINT8_C(0xc2)   /**< Deleted include file.  "fname",, NO_SECT, 0, sum?  (S) */
     746#define MACHO_N_LSYM    KU8_C(0x80)   /**< Stack variable.        "name",, NO_SECT, type, frame_offset */
     747#define MACHO_N_BINCL   KU8_C(0x82)   /**< Begin #include.        "fname",, NO_SECT, 0, sum? */
     748#define MACHO_N_SOL     KU8_C(0x84)   /**< #included file.        "fname",, section, 0, start_address (S) */
     749#define MACHO_N_PARAMS  KU8_C(0x86)   /**< Compiler params.       "params",, NO_SECT, 0, 0 */
     750#define MACHO_N_VERSION KU8_C(0x88)   /**< Compiler version.      "version",, NO_SECT, 0, 0 */
     751#define MACHO_N_OLEVEL  KU8_C(0x8A)   /**< Compiler -O level.     "level",, NO_SECT, 0, 0 */
     752#define MACHO_N_PSYM    KU8_C(0xa0)   /**< Parameter variable.    "name",, NO_SECT, type, frame_offset */
     753#define MACHO_N_EINCL   KU8_C(0xa2)   /**< End #include.          "fname",, NO_SECT, 0, 0 (S) */
     754#define MACHO_N_ENTRY   KU8_C(0xa4)   /**< Alternate entry point. "name",, section, line, address */
     755#define MACHO_N_LBRAC   KU8_C(0xc0)   /**< Left bracket.               0,, NO_SECT, nesting_level, address */
     756#define MACHO_N_EXCL    KU8_C(0xc2)   /**< Deleted include file.  "fname",, NO_SECT, 0, sum?  (S) */
    757757    /* omits N_SCOPE */
    758 #define MACHO_N_RBRAC   UINT8_C(0xe0)   /**< Right bracket.              0,, NO_SECT, nesting_level, address */
    759 #define MACHO_N_BCOMM   UINT8_C(0xe2)   /**< Begin common.          "name",, NO_SECT?, 0, 0 */
    760 #define MACHO_N_ECOMM   UINT8_C(0xe4)   /**< End common.            "name",, section, 0, 0 */
    761 #define MACHO_N_ECOML   UINT8_C(0xe8)   /**< End local common.           0,, section, 0, address */
    762 #define MACHO_N_LENG    UINT8_C(0xfe)   /**< Length-value of the preceding entry.
     758#define MACHO_N_RBRAC   KU8_C(0xe0)   /**< Right bracket.              0,, NO_SECT, nesting_level, address */
     759#define MACHO_N_BCOMM   KU8_C(0xe2)   /**< Begin common.          "name",, NO_SECT?, 0, 0 */
     760#define MACHO_N_ECOMM   KU8_C(0xe4)   /**< End common.            "name",, section, 0, 0 */
     761#define MACHO_N_ECOML   KU8_C(0xe8)   /**< End local common.           0,, section, 0, address */
     762#define MACHO_N_LENG    KU8_C(0xfe)   /**< Length-value of the preceding entry.
    763763                                                                    "name",, NO_SECT, 0, length */
    764764
    … …  
    775775 */
    776776
    777 #define REFERENCE_TYPE                  UINT16_C(0x000f)    /**< The reference type mask. */
     777#define REFERENCE_TYPE                  KU16_C(0x000f)    /**< The reference type mask. */
    778778#define REFERENCE_FLAG_UNDEFINED_NON_LAZY             0     /**< Normal undefined symbol. */
    779779#define REFERENCE_FLAG_UNDEFINED_LAZY                 1     /**< Lazy undefined symbol. */
    … …  
    783783#define REFERENCE_FLAG_PRIVATE_UNDEFINED_LAZY         5     /**< Lazy undefined private symbol. */
    784784
    785 #define REFERENCED_DYNAMICALLY          UINT16_C(0x0010)    /**< Don't strip. */
     785#define REFERENCED_DYNAMICALLY          KU16_C(0x0010)    /**< Don't strip. */
    786786
    787787
    … …  
    799799
    800800/** Only MH_OBJECT: Never dead strip me! */
    801 #define N_NO_DEAD_STRIP                 UINT16_C(0x0020)
     801#define N_NO_DEAD_STRIP                 KU16_C(0x0020)
    802802/** Not MH_OBJECT: Discarded symbol. */
    803 #define N_DESC_DISCARDED                UINT16_C(0x0020)
     803#define N_DESC_DISCARDED                KU16_C(0x0020)
    804804/** Weak external symbol. Symbol can be missing, in which case it's will have the value 0. */
    805 #define N_WEAK_REF                      UINT16_C(0x0040)
     805#define N_WEAK_REF                      KU16_C(0x0040)
    806806/** Weak symbol definition. The symbol can be overridden by another weak
    807807 * symbol already present or by a non-weak (strong) symbol definition.
    … …  
    809809 * @remark This bit means something differently for undefined symbols, see N_REF_TO_WEAK.
    810810 */
    811 #define N_WEAK_DEF                      UINT16_C(0x0080)
     811#define N_WEAK_DEF                      KU16_C(0x0080)
    812812/** Reference to a weak symbol, resolve using flat namespace searching.
    813813 * @remark This bit means something differently for defined symbols, see N_WEAK_DEF. */
    814 #define N_REF_TO_WEAK                   UINT16_C(0x0080)
     814#define N_REF_TO_WEAK                   KU16_C(0x0080)
    815815
    816816/** @} */
    … …  
    833833typedef struct macho_relocation_info
    834834{
    835     int32_t     r_address;          /**< Section relative address of the fixup.
     835    KI32        r_address;          /**< Section relative address of the fixup.
    836836                                         The top bit (signed) indicates that this is a scattered
    837837                                         relocation if set, see scattered_relocation_info_t. */
    838     uint32_t    r_symbolnum : 24,   /**< r_extern=1: Symbol table index, relocate with the address of this symbol.
     838    KU32        r_symbolnum : 24,   /**< r_extern=1: Symbol table index, relocate with the address of this symbol.
    839839                                         r_extern=0: Section ordinal, relocate with the address of this section. */
    840840                r_pcrel : 1,        /**< PC (program counter) relative fixup; subtract the fixup address. */
    841                 r_length : 2,       /**< Fixup length: 0=uint8_t, 1=uint16_t, 2=uint32_t, 3=uint64_t. */
     841                r_length : 2,       /**< Fixup length: 0=KU8, 1=KU16, 2=KU32, 3=KU64. */
    842842                r_extern : 1,       /**< External or internal fixup, decides the r_symbolnum interpretation.. */
    843843                r_type : 4;         /**< Relocation type; 0 is standard, non-zero are machine specific. */
    … …  
    849849/** Flag in r_address indicating that the relocation is of the
    850850 * scattered_relocation_info_t kind and not macho_relocation_info_t. */
    851 #define R_SCATTERED     UINT32_C(0x80000000)
     851#define R_SCATTERED     KU32_C(0x80000000)
    852852
    853853/**
    … …  
    864864{
    865865#ifdef KLDR_LITTLE_ENDIAN
    866     uint32_t    r_address : 24,     /**< Section relative address of the fixup. (macho_relocation_info_t::r_address) */
     866    KU32        r_address : 24,     /**< Section relative address of the fixup. (macho_relocation_info_t::r_address) */
    867867                r_type : 4,         /**< Relocation type; 0 is standard, non-zero are machine specific. (macho_relocation_info_t::r_type) */
    868                 r_length : 2,       /**< Fixup length: 0=uint8_t, 1=uint16_t, 2=uint32_t, 3=uint64_t. (macho_relocation_info_t::r_length) */
     868                r_length : 2,       /**< Fixup length: 0=KU8, 1=KU16, 2=KU32, 3=KU64. (macho_relocation_info_t::r_length) */
    869869                r_pcrel : 1,        /**< PC (program counter) relative fixup; subtract the fixup address. (macho_relocation_info_t::r_pcrel) */
    870870                r_scattered : 1;    /**< Set if scattered relocation, clear if normal relocation. */
    871871#elif defined(KLDR_BIG_ENDIAN)
    872     uint32_t    r_scattered : 1,    /**< Set if scattered relocation, clear if normal relocation. */
     872    KU32        r_scattered : 1,    /**< Set if scattered relocation, clear if normal relocation. */
    873873                r_pcrel : 1,        /**< PC (program counter) relative fixup; subtract the fixup address. (macho_relocation_info_t::r_pcrel) */
    874                 r_length : 2,       /**< Fixup length: 0=uint8_t, 1=uint16_t, 2=uint32_t, 3=uint64_t. (macho_relocation_info_t::r_length) */
     874                r_length : 2,       /**< Fixup length: 0=KU8, 1=KU16, 2=KU32, 3=KU64. (macho_relocation_info_t::r_length) */
    875875                r_type : 4,         /**< Relocation type; 0 is standard, non-zero are machine specific. (macho_relocation_info_t::r_type) */
    876876                r_address : 24;     /**< Section relative address of the fixup. (macho_relocation_info_t::r_address) */
    … …  
    878878# error "Neither KLDR_LITTLE_ENDIAN nor KLDR_BIG_ENDIAN is defined!"
    879879#endif
    880     int32_t     r_value;            /**< The value the fixup is refering to (without offset added). */
     880    KI32        r_value;            /**< The value the fixup is refering to (without offset added). */
    881881} scattered_relocation_info_t;
    882882

  • trunk/kStuff/kLdr/kLdrModNative.c

    r3537 r3567  
    9494 */
    9595# define KLDRMODNATIVE_RVA2TYPE(pvBits, uRVA, type) \
    96         ( (type) ((uintptr_t)(pvBits) + (uRVA)) )
     96        ( (type) ((KUPTR)(pvBits) + (uRVA)) )
    9797
    9898#endif /* PE OSes */
    … …  
    111111    PKLDRMOD                    pMod;
    112112    /** Reserved flags. */
    113     uint32_t                    f32Reserved;
     113    KU32                        f32Reserved;
    114114    /** The number of imported modules.
    115      * If ~(uint32_t)0 this hasn't been determined yet. */
    116     uint32_t                    cImportModules;
     115     * If ~(KU32)0 this hasn't been determined yet. */
     116    KU32                        cImportModules;
    117117#ifdef __OS2__
    118118    /** The module handle. */
    … …  
    140140*   Internal Functions                                                         *
    141141*******************************************************************************/
    142 static int32_t kldrModNativeNumberOfImports(PKLDRMOD pMod, const void *pvBits);
     142static KI32 kldrModNativeNumberOfImports(PKLDRMOD pMod, const void *pvBits);
    143143
    144144
    … …  
    186186    if (rc)
    187187        return rc;
    188     rc = kLdrModOpenNativeByHandle((uintptr_t)hmod, ppMod);
     188    rc = kLdrModOpenNativeByHandle((KUPTR)hmod, ppMod);
    189189    if (rc)
    190190        DosFreeModule(hmod);
    … …  
    196196    if (!hmod)
    197197        return GetLastError();
    198     rc = kLdrModOpenNativeByHandle((uintptr_t)hmod, ppMod);
     198    rc = kLdrModOpenNativeByHandle((KUPTR)hmod, ppMod);
    199199    if (rc)
    200200        FreeLibrary(hmod);
    … …  
    206206    if (!pvMod)
    207207        return ENOENT;
    208     rc = kLdrModOpenNativeByHandle((uintptr_t)pvMod, ppMod);
     208    rc = kLdrModOpenNativeByHandle((KUPTR)pvMod, ppMod);
    209209    if (rc)
    210210        dlclose(pvMod);
    … …  
    227227 * @remark  This will not make the native loader increment the load count.
    228228 */
    229 int kLdrModOpenNativeByHandle(uintptr_t uHandle, PPKLDRMOD ppMod)
    230 {
    231     size_t cb;
    232     size_t cchFilename;
    233     uint32_t cSegments;
     229int kLdrModOpenNativeByHandle(KUPTR uHandle, PPKLDRMOD ppMod)
     230{
     231    KSIZE cb;
     232    KSIZE cchFilename;
     233    KU32 cSegments;
    234234    PKLDRMOD pMod;
    235235    PKLDRMODNATIVE pModNative;
    … …  
    273273    /* get the segment count. */
    274274    if (pDosHdr->e_magic == IMAGE_DOS_SIGNATURE)
    275         pNtHdrs = (const IMAGE_NT_HEADERS *)((uintptr_t)pDosHdr + pDosHdr->e_lfanew);
     275        pNtHdrs = (const IMAGE_NT_HEADERS *)((KUPTR)pDosHdr + pDosHdr->e_lfanew);
    276276    else
    277277        pNtHdrs = (const IMAGE_NT_HEADERS *)pDosHdr;
    … …  
    309309
    310310    /* KLDRMOD */
    311     pMod = (PKLDRMOD)((uint8_t *)pModNative + KLDR_ALIGN_Z(sizeof(KLDRMODNATIVE), 16));
     311    pMod = (PKLDRMOD)((KU8 *)pModNative + KLDR_ALIGN_Z(sizeof(KLDRMODNATIVE), 16));
    312312    pMod->pvData = pModNative;
    313313    pMod->pRdr = NULL;
    … …  
    337337    pModNative->pMod = pMod;
    338338    pModNative->f32Reserved = 0;
    339     pModNative->cImportModules = ~(uint32_t)0;
     339    pModNative->cImportModules = ~(KU32)0;
    340340
    341341    /*
    … …  
    541541
    542542/** @copydoc kLdrModQuerySymbol */
    543 static int kldrModNativeQuerySymbol(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, uint32_t iSymbol,
    544                                     const char *pchSymbol, size_t cchSymbol, const char *pszVersion,
    545                                     PFNKLDRMODGETIMPORT pfnGetForwarder, void *pvUser, PKLDRADDR puValue, uint32_t *pfKind)
     543static int kldrModNativeQuerySymbol(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, KU32 iSymbol,
     544                                    const char *pchSymbol, KSIZE cchSymbol, const char *pszVersion,
     545                                    PFNKLDRMODGETIMPORT pfnGetForwarder, void *pvUser, PKLDRADDR puValue, KU32 *pfKind)
    546546{
    547547    PKLDRMODNATIVE pModNative = (PKLDRMODNATIVE)pMod->pvData;
    … …  
    579579        if (rc)
    580580            return rc == ERROR_PROC_NOT_FOUND ? KLDR_ERR_SYMBOL_NOT_FOUND : rc;
    581         *puValue = (uintptr_t)pfn;
     581        *puValue = (KUPTR)pfn;
    582582    }
    583583    if (pfKind)
    … …  
    602602        return KLDR_ERR_SYMBOL_NOT_FOUND;
    603603
    604     pfn = GetProcAddress(pModNative->hmod, pszSymbol ? pszSymbol : (const char *)(uintptr_t)iSymbol);
     604    pfn = GetProcAddress(pModNative->hmod, pszSymbol ? pszSymbol : (const char *)(KUPTR)iSymbol);
    605605    if (puValue)
    606         *puValue = (uintptr_t)pfn;
     606        *puValue = (KUPTR)pfn;
    607607    if (pfKind)
    608608        *pfKind = (pModNative->pNtHdrs->FileHeader.SizeOfOptionalHeader == sizeof(IMAGE_OPTIONAL_HEADER32)
    … …  
    618618        return KLDR_ERR_SYMBOL_NOT_FOUND;
    619619    if (puValue)
    620         *puValue = (uintptr_t)pfn;
     620        *puValue = (KUPTR)pfn;
    621621    if (pfKind)
    622         *pfKind = (sizeof(uintptr_t) == 4 ? KLDRSYMKIND_32BIT : KLDRSYMKIND_64BIT)
     622        *pfKind = (sizeof(KUPTR) == 4 ? KLDRSYMKIND_32BIT : KLDRSYMKIND_64BIT)
    623623                | KLDRSYMKIND_NO_TYPE;
    624624
    … …  
    633633/** @copydoc kLdrModEnumSymbols */
    634634static int kldrModNativeEnumSymbols(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress,
    635                                     uint32_t fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser)
     635                                    KU32 fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser)
    636636{
    637637    PKLDRMODNATIVE                  pModNative = (PKLDRMODNATIVE)pMod->pvData;
    … …  
    643643
    644644#elif defined(__WIN__) || defined(__NT__)
    645     const uint32_t                 *paFunctions;
     645    const KU32                     *paFunctions;
    646646    const IMAGE_EXPORT_DIRECTORY   *pExpDir;
    647     const uint32_t                 *paRVANames;
    648     const uint16_t                 *paOrdinals;
    649     uint32_t                        iFunction;
    650     uint32_t                        cFunctions;
    651     uint32_t                        cNames;
     647    const KU32                     *paRVANames;
     648    const KU16                     *paOrdinals;
     649    KU32                            iFunction;
     650    KU32                            cFunctions;
     651    KU32                            cNames;
    652652    int                             rc;
    653653
    … …  
    666666     * Enumerate the ordinal exports.
    667667     */
    668     paRVANames = KLDRMODNATIVE_RVA2TYPE(pModNative->hmod, pExpDir->AddressOfNames, const uint32_t *);
    669     paOrdinals = KLDRMODNATIVE_RVA2TYPE(pModNative->hmod, pExpDir->AddressOfNameOrdinals, const uint16_t *);
    670     paFunctions = KLDRMODNATIVE_RVA2TYPE(pModNative->hmod, pExpDir->AddressOfFunctions, const uint32_t *);
     668    paRVANames = KLDRMODNATIVE_RVA2TYPE(pModNative->hmod, pExpDir->AddressOfNames, const KU32 *);
     669    paOrdinals = KLDRMODNATIVE_RVA2TYPE(pModNative->hmod, pExpDir->AddressOfNameOrdinals, const KU16 *);
     670    paFunctions = KLDRMODNATIVE_RVA2TYPE(pModNative->hmod, pExpDir->AddressOfFunctions, const KU32 *);
    671671    cFunctions = pExpDir->NumberOfFunctions;
    672672    cNames = pExpDir->NumberOfNames;
    … …  
    674674    {
    675675        unsigned        fFoundName;
    676         uint32_t        iName;
    677         const uint32_t  uRVA = paFunctions[iFunction];
     676        KU32            iName;
     677        const KU32      uRVA = paFunctions[iFunction];
    678678        const KLDRADDR  uValue = BaseAddress + uRVA;
    679         uint32_t        fKind = (pModNative->pNtHdrs->FileHeader.SizeOfOptionalHeader == sizeof(IMAGE_OPTIONAL_HEADER32)
     679        KU32            fKind = (pModNative->pNtHdrs->FileHeader.SizeOfOptionalHeader == sizeof(IMAGE_OPTIONAL_HEADER32)
    680680                              ? KLDRSYMKIND_32BIT : KLDRSYMKIND_64BIT)
    681681                              | KLDRSYMKIND_NO_TYPE;
    … …  
    727727
    728728/** @copydoc kLdrModGetImport */
    729 static int kldrModNativeGetImport(PKLDRMOD pMod, const void *pvBits, uint32_t iImport, char *pszName, size_t cchName)
     729static int kldrModNativeGetImport(PKLDRMOD pMod, const void *pvBits, KU32 iImport, char *pszName, KSIZE cchName)
    730730{
    731731    PKLDRMODNATIVE                  pModNative = (PKLDRMODNATIVE)pMod->pvData;
    … …  
    739739    const IMAGE_IMPORT_DESCRIPTOR  *pImpDesc;
    740740    const char                     *pszImportName;
    741     size_t                          cchImportName;
     741    KSIZE                           cchImportName;
    742742    int                             rc;
    743743
    … …  
    745745     * Simple bounds check.
    746746     */
    747     if (iImport >= (uint32_t)kldrModNativeNumberOfImports(pMod, pvBits))
     747    if (iImport >= (KU32)kldrModNativeNumberOfImports(pMod, pvBits))
    748748        return KLDR_ERR_IMPORT_ORDINAL_OUT_OF_BOUNDS;
    749749
    … …  
    784784
    785785/** @copydoc kLdrModNumberOfImports */
    786 static int32_t kldrModNativeNumberOfImports(PKLDRMOD pMod, const void *pvBits)
     786static KI32 kldrModNativeNumberOfImports(PKLDRMOD pMod, const void *pvBits)
    787787{
    788788    PKLDRMODNATIVE pModNative = (PKLDRMODNATIVE)pMod->pvData;
    … …  
    794794
    795795#elif defined(__WIN__) || defined(__NT__)
    796     if (pModNative->cImportModules == ~(uint32_t)0)
     796    if (pModNative->cImportModules == ~(KU32)0)
    797797    {
    798798        /*
    … …  
    898898#elif defined(__WIN__) || defined(__NT__)
    899899    const IMAGE_DEBUG_DIRECTORY    *pDbgDir;
    900     uint32_t                        iDbgInfo;
    901     uint32_t                        cb;
     900    KU32                            iDbgInfo;
     901    KU32                            cb;
    902902    int                             rc;
    903903
    … …  
    10391039
    10401040/** @copydoc kLdrModCallInit */
    1041 static int kldrModNativeCallInit(PKLDRMOD pMod, uintptr_t uHandle)
     1041static int kldrModNativeCallInit(PKLDRMOD pMod, KUPTR uHandle)
    10421042{
    10431043    return 0;
    … …  
    10461046
    10471047/** @copydoc kLdrModCallTerm */
    1048 static int kldrModNativeCallTerm(PKLDRMOD pMod, uintptr_t uHandle)
     1048static int kldrModNativeCallTerm(PKLDRMOD pMod, KUPTR uHandle)
    10491049{
    10501050    return 0;
    … …  
    10531053
    10541054/** @copydoc kLdrModCallThread */
    1055 static int kldrModNativeCallThread(PKLDRMOD pMod, uintptr_t uHandle, unsigned fAttachingOrDetaching)
     1055static int kldrModNativeCallThread(PKLDRMOD pMod, KUPTR uHandle, unsigned fAttachingOrDetaching)
    10561056{
    10571057    return 0;

  • 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);

  • trunk/kStuff/kLdr/kLdrModPE.h

    r3537 r3567  
    176176typedef struct _IMAGE_FILE_HEADER
    177177{
    178     uint16_t  Machine;
    179     uint16_t  NumberOfSections;
    180     uint32_t  TimeDateStamp;
    181     uint32_t  PointerToSymbolTable;
    182     uint32_t  NumberOfSymbols;
    183     uint16_t  SizeOfOptionalHeader;
    184     uint16_t  Characteristics;
     178    KU16      Machine;
     179    KU16      NumberOfSections;
     180    KU32      TimeDateStamp;
     181    KU32      PointerToSymbolTable;
     182    KU32      NumberOfSymbols;
     183    KU16      SizeOfOptionalHeader;
     184    KU16      Characteristics;
    185185} IMAGE_FILE_HEADER;
    186186typedef IMAGE_FILE_HEADER *PIMAGE_FILE_HEADER;
    … …  
    189189typedef struct _IMAGE_DATA_DIRECTORY
    190190{
    191     uint32_t  VirtualAddress;
    192     uint32_t  Size;
     191    KU32      VirtualAddress;
     192    KU32      Size;
    193193} IMAGE_DATA_DIRECTORY;
    194194typedef IMAGE_DATA_DIRECTORY *PIMAGE_DATA_DIRECTORY;
    … …  
    197197typedef struct _IMAGE_OPTIONAL_HEADER32
    198198{
    199     uint16_t  Magic;
    200     uint8_t  MajorLinkerVersion;
    201     uint8_t  MinorLinkerVersion;
    202     uint32_t  SizeOfCode;
    203     uint32_t  SizeOfInitializedData;
    204     uint32_t  SizeOfUninitializedData;
    205     uint32_t  AddressOfEntryPoint;
    206     uint32_t  BaseOfCode;
    207     uint32_t  BaseOfData;
    208     uint32_t  ImageBase;
    209     uint32_t  SectionAlignment;
    210     uint32_t  FileAlignment;
    211     uint16_t  MajorOperatingSystemVersion;
    212     uint16_t  MinorOperatingSystemVersion;
    213     uint16_t  MajorImageVersion;
    214     uint16_t  MinorImageVersion;
    215     uint16_t  MajorSubsystemVersion;
    216     uint16_t  MinorSubsystemVersion;
    217     uint32_t  Win32VersionValue;
    218     uint32_t  SizeOfImage;
    219     uint32_t  SizeOfHeaders;
    220     uint32_t  CheckSum;
    221     uint16_t  Subsystem;
    222     uint16_t  DllCharacteristics;
    223     uint32_t  SizeOfStackReserve;
    224     uint32_t  SizeOfStackCommit;
    225     uint32_t  SizeOfHeapReserve;
    226     uint32_t  SizeOfHeapCommit;
    227     uint32_t  LoaderFlags;
    228     uint32_t  NumberOfRvaAndSizes;
     199    KU16    Magic;
     200    KU8     MajorLinkerVersion;
     201    KU8     MinorLinkerVersion;
     202    KU32    SizeOfCode;
     203    KU32    SizeOfInitializedData;
     204    KU32    SizeOfUninitializedData;
     205    KU32    AddressOfEntryPoint;
     206    KU32    BaseOfCode;
     207    KU32    BaseOfData;
     208    KU32    ImageBase;
     209    KU32    SectionAlignment;
     210    KU32    FileAlignment;
     211    KU16    MajorOperatingSystemVersion;
     212    KU16    MinorOperatingSystemVersion;
     213    KU16    MajorImageVersion;
     214    KU16    MinorImageVersion;
     215    KU16    MajorSubsystemVersion;
     216    KU16    MinorSubsystemVersion;
     217    KU32    Win32VersionValue;
     218    KU32    SizeOfImage;
     219    KU32    SizeOfHeaders;
     220    KU32    CheckSum;
     221    KU16    Subsystem;
     222    KU16    DllCharacteristics;
     223    KU32    SizeOfStackReserve;
     224    KU32    SizeOfStackCommit;
     225    KU32    SizeOfHeapReserve;
     226    KU32    SizeOfHeapCommit;
     227    KU32    LoaderFlags;
     228    KU32    NumberOfRvaAndSizes;
    229229    IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES];
    230230} IMAGE_OPTIONAL_HEADER32;
    … …  
    233233typedef struct _IMAGE_OPTIONAL_HEADER64
    234234{
    235     uint16_t  Magic;
    236     uint8_t  MajorLinkerVersion;
    237     uint8_t  MinorLinkerVersion;
    238     uint32_t  SizeOfCode;
    239     uint32_t  SizeOfInitializedData;
    240     uint32_t  SizeOfUninitializedData;
    241     uint32_t  AddressOfEntryPoint;
    242     uint32_t  BaseOfCode;
    243     uint64_t  ImageBase;
    244     uint32_t  SectionAlignment;
    245     uint32_t  FileAlignment;
    246     uint16_t  MajorOperatingSystemVersion;
    247     uint16_t  MinorOperatingSystemVersion;
    248     uint16_t  MajorImageVersion;
    249     uint16_t  MinorImageVersion;
    250     uint16_t  MajorSubsystemVersion;
    251     uint16_t  MinorSubsystemVersion;
    252     uint32_t  Win32VersionValue;
    253     uint32_t  SizeOfImage;
    254     uint32_t  SizeOfHeaders;
    255     uint32_t  CheckSum;
    256     uint16_t  Subsystem;
    257     uint16_t  DllCharacteristics;
    258     uint64_t  SizeOfStackReserve;
    259     uint64_t  SizeOfStackCommit;
    260     uint64_t  SizeOfHeapReserve;
    261     uint64_t  SizeOfHeapCommit;
    262     uint32_t  LoaderFlags;
    263     uint32_t  NumberOfRvaAndSizes;
     235    KU16    Magic;
     236    KU8     MajorLinkerVersion;
     237    KU8     MinorLinkerVersion;
     238    KU32    SizeOfCode;
     239    KU32    SizeOfInitializedData;
     240    KU32    SizeOfUninitializedData;
     241    KU32    AddressOfEntryPoint;
     242    KU32    BaseOfCode;
     243    KU64    ImageBase;
     244    KU32    SectionAlignment;
     245    KU32    FileAlignment;
     246    KU16    MajorOperatingSystemVersion;
     247    KU16    MinorOperatingSystemVersion;
     248    KU16    MajorImageVersion;
     249    KU16    MinorImageVersion;
     250    KU16    MajorSubsystemVersion;
     251    KU16    MinorSubsystemVersion;
     252    KU32    Win32VersionValue;
     253    KU32    SizeOfImage;
     254    KU32    SizeOfHeaders;
     255    KU32    CheckSum;
     256    KU16    Subsystem;
     257    KU16    DllCharacteristics;
     258    KU64    SizeOfStackReserve;
     259    KU64    SizeOfStackCommit;
     260    KU64    SizeOfHeapReserve;
     261    KU64    SizeOfHeapCommit;
     262    KU32    LoaderFlags;
     263    KU32    NumberOfRvaAndSizes;
    264264    IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES];
    265265} IMAGE_OPTIONAL_HEADER64;
    … …  
    269269typedef struct _IMAGE_NT_HEADERS
    270270{
    271     uint32_t Signature;
     271    KU32 Signature;
    272272    IMAGE_FILE_HEADER FileHeader;
    273273    IMAGE_OPTIONAL_HEADER32 OptionalHeader;
    … …  
    277277typedef struct _IMAGE_NT_HEADERS64
    278278{
    279     uint32_t Signature;
     279    KU32 Signature;
    280280    IMAGE_FILE_HEADER FileHeader;
    281281    IMAGE_OPTIONAL_HEADER64 OptionalHeader;
    … …  
    286286typedef struct _IMAGE_SECTION_HEADER
    287287{
    288     uint8_t  Name[IMAGE_SIZEOF_SHORT_NAME];
     288    KU8      Name[IMAGE_SIZEOF_SHORT_NAME];
    289289    union
    290290    {
    291         uint32_t  PhysicalAddress;
    292         uint32_t  VirtualSize;
     291        KU32      PhysicalAddress;
     292        KU32      VirtualSize;
    293293    } Misc;
    294     uint32_t  VirtualAddress;
    295     uint32_t  SizeOfRawData;
    296     uint32_t  PointerToRawData;
    297     uint32_t  PointerToRelocations;
    298     uint32_t  PointerToLinenumbers;
    299     uint16_t  NumberOfRelocations;
    300     uint16_t  NumberOfLinenumbers;
    301     uint32_t  Characteristics;
     294    KU32      VirtualAddress;
     295    KU32      SizeOfRawData;
     296    KU32      PointerToRawData;
     297    KU32      PointerToRelocations;
     298    KU32      PointerToLinenumbers;
     299    KU16      NumberOfRelocations;
     300    KU16      NumberOfLinenumbers;
     301    KU32      Characteristics;
    302302} IMAGE_SECTION_HEADER;
    303303typedef IMAGE_SECTION_HEADER *PIMAGE_SECTION_HEADER;
    … …  
    306306typedef struct _IMAGE_BASE_RELOCATION
    307307{
    308     uint32_t  VirtualAddress;
    309     uint32_t  SizeOfBlock;
     308    KU32      VirtualAddress;
     309    KU32      SizeOfBlock;
    310310} IMAGE_BASE_RELOCATION;
    311311typedef IMAGE_BASE_RELOCATION *PIMAGE_BASE_RELOCATION;
    … …  
    314314typedef struct _IMAGE_EXPORT_DIRECTORY
    315315{
    316     uint32_t  Characteristics;
    317     uint32_t  TimeDateStamp;
    318     uint16_t  MajorVersion;
    319     uint16_t  MinorVersion;
    320     uint32_t  Name;
    321     uint32_t  Base;
    322     uint32_t  NumberOfFunctions;
    323     uint32_t  NumberOfNames;
    324     uint32_t  AddressOfFunctions;
    325     uint32_t  AddressOfNames;
    326     uint32_t  AddressOfNameOrdinals;
     316    KU32      Characteristics;
     317    KU32      TimeDateStamp;
     318    KU16      MajorVersion;
     319    KU16      MinorVersion;
     320    KU32      Name;
     321    KU32      Base;
     322    KU32      NumberOfFunctions;
     323    KU32      NumberOfNames;
     324    KU32      AddressOfFunctions;
     325    KU32      AddressOfNames;
     326    KU32      AddressOfNameOrdinals;
    327327} IMAGE_EXPORT_DIRECTORY, *PIMAGE_EXPORT_DIRECTORY;
    328328
    … …  
    332332    union
    333333    {
    334         uint32_t  Characteristics;
    335         uint32_t  OriginalFirstThunk;
     334        KU32      Characteristics;
     335        KU32      OriginalFirstThunk;
    336336    } u;
    337     uint32_t  TimeDateStamp;
    338     uint32_t  ForwarderChain;
    339     uint32_t  Name;
    340     uint32_t  FirstThunk;
     337    KU32      TimeDateStamp;
     338    KU32      ForwarderChain;
     339    KU32      Name;
     340    KU32      FirstThunk;
    341341} IMAGE_IMPORT_DESCRIPTOR;
    342342typedef IMAGE_IMPORT_DESCRIPTOR *PIMAGE_IMPORT_DESCRIPTOR;
    … …  
    345345typedef struct _IMAGE_IMPORT_BY_NAME
    346346{
    347     uint16_t  Hint;
    348     uint8_t  Name[1];
     347    KU16      Hint;
     348    KU8      Name[1];
    349349} IMAGE_IMPORT_BY_NAME;
    350350typedef IMAGE_IMPORT_BY_NAME *PIMAGE_IMPORT_BY_NAME;
    … …  
    356356    union
    357357    {
    358         uint64_t  ForwarderString;
    359         uint64_t  Function;
    360         uint64_t  Ordinal;
    361         uint64_t  AddressOfData;
     358        KU64      ForwarderString;
     359        KU64      Function;
     360        KU64      Ordinal;
     361        KU64      AddressOfData;
    362362    } u1;
    363363} IMAGE_THUNK_DATA64;
    … …  
    368368    union
    369369    {
    370         uint32_t  ForwarderString;
    371         uint32_t  Function;
    372         uint32_t  Ordinal;
    373         uint32_t  AddressOfData;
     370        KU32      ForwarderString;
     371        KU32      Function;
     372        KU32      Ordinal;
     373        KU32      AddressOfData;
    374374    } u1;
    375375} IMAGE_THUNK_DATA32;
    … …  
    379379typedef struct _IMAGE_LOAD_CONFIG_DIRECTORY32
    380380{
    381     uint32_t  Size;
    382     uint32_t  TimeDateStamp;
    383     uint16_t  MajorVersion;
    384     uint16_t  MinorVersion;
    385     uint32_t  GlobalFlagsClear;
    386     uint32_t  GlobalFlagsSet;
    387     uint32_t  CriticalSectionDefaultTimeout;
    388     uint32_t  DeCommitFreeBlockThreshold;
    389     uint32_t  DeCommitTotalFreeThreshold;
    390     uint32_t  LockPrefixTable;
    391     uint32_t  MaximumAllocationSize;
    392     uint32_t  VirtualMemoryThreshold;
    393     uint32_t  ProcessHeapFlags;
    394     uint32_t  ProcessAffinityMask;
    395     uint16_t  CSDVersion;
    396     uint16_t  Reserved1;
    397     uint32_t  EditList;
    398     uint32_t  SecurityCookie;
    399     uint32_t  SEHandlerTable;
    400     uint32_t  SEHandlerCount;
     381    KU32      Size;
     382    KU32      TimeDateStamp;
     383    KU16      MajorVersion;
     384    KU16      MinorVersion;
     385    KU32      GlobalFlagsClear;
     386    KU32      GlobalFlagsSet;
     387    KU32      CriticalSectionDefaultTimeout;
     388    KU32      DeCommitFreeBlockThreshold;
     389    KU32      DeCommitTotalFreeThreshold;
     390    KU32      LockPrefixTable;
     391    KU32      MaximumAllocationSize;
     392    KU32      VirtualMemoryThreshold;
     393    KU32      ProcessHeapFlags;
     394    KU32      ProcessAffinityMask;
     395    KU16      CSDVersion;
     396    KU16      Reserved1;
     397    KU32      EditList;
     398    KU32      SecurityCookie;
     399    KU32      SEHandlerTable;
     400    KU32      SEHandlerCount;
    401401} IMAGE_LOAD_CONFIG_DIRECTORY32;
    402402typedef IMAGE_LOAD_CONFIG_DIRECTORY32 PIMAGE_LOAD_CONFIG_DIRECTORY32;
    … …  
    404404typedef struct _IMAGE_LOAD_CONFIG_DIRECTORY64
    405405{
    406     uint32_t  Size;
    407     uint32_t  TimeDateStamp;
    408     uint16_t  MajorVersion;
    409     uint16_t  MinorVersion;
    410     uint32_t  GlobalFlagsClear;
    411     uint32_t  GlobalFlagsSet;
    412     uint32_t  CriticalSectionDefaultTimeout;
    413     uint64_t  DeCommitFreeBlockThreshold;
    414     uint64_t  DeCommitTotalFreeThreshold;
    415     uint64_t  LockPrefixTable;
    416     uint64_t  MaximumAllocationSize;
    417     uint64_t  VirtualMemoryThreshold;
    418     uint64_t  ProcessAffinityMask;
    419     uint32_t  ProcessHeapFlags;
    420     uint16_t  CSDVersion;
    421     uint16_t  Reserved1;
    422     uint64_t  EditList;
    423     uint64_t  SecurityCookie;
    424     uint64_t  SEHandlerTable;
    425     uint64_t  SEHandlerCount;
     406    KU32      Size;
     407    KU32      TimeDateStamp;
     408    KU16      MajorVersion;
     409    KU16      MinorVersion;
     410    KU32      GlobalFlagsClear;
     411    KU32      GlobalFlagsSet;
     412    KU32      CriticalSectionDefaultTimeout;
     413    KU64      DeCommitFreeBlockThreshold;
     414    KU64      DeCommitTotalFreeThreshold;
     415    KU64      LockPrefixTable;
     416    KU64      MaximumAllocationSize;
     417    KU64      VirtualMemoryThreshold;
     418    KU64      ProcessAffinityMask;
     419    KU32      ProcessHeapFlags;
     420    KU16      CSDVersion;
     421    KU16      Reserved1;
     422    KU64      EditList;
     423    KU64      SecurityCookie;
     424    KU64      SEHandlerTable;
     425    KU64      SEHandlerCount;
    426426} IMAGE_LOAD_CONFIG_DIRECTORY64;
    427427typedef IMAGE_LOAD_CONFIG_DIRECTORY64 *PIMAGE_LOAD_CONFIG_DIRECTORY64;
    … …  
    429429typedef struct _IMAGE_DEBUG_DIRECTORY
    430430{
    431     uint32_t  Characteristics;
    432         uint32_t  TimeDateStamp;
    433     uint16_t  MajorVersion;
    434     uint16_t  MinorVersion;
    435     uint32_t  Type;
    436     uint32_t  SizeOfData;
    437     uint32_t  AddressOfRawData;
    438     uint32_t  PointerToRawData;
     431    KU32      Characteristics;
     432        KU32  TimeDateStamp;
     433    KU16      MajorVersion;
     434    KU16      MinorVersion;
     435    KU32      Type;
     436    KU32      SizeOfData;
     437    KU32      AddressOfRawData;
     438    KU32      PointerToRawData;
    439439} IMAGE_DEBUG_DIRECTORY;
    440440typedef IMAGE_DEBUG_DIRECTORY *PIMAGE_DEBUG_DIRECTORY;
    … …  
    451451typedef struct _IMAGE_TLS_DIRECTORY32
    452452{
    453     uint32_t  StartAddressOfRawData;
    454     uint32_t  EndAddressOfRawData;
    455     uint32_t  AddressOfIndex;
    456     uint32_t  AddressOfCallBacks;
    457     uint32_t  SizeOfZeroFill;
    458     uint32_t  Characteristics;
     453    KU32      StartAddressOfRawData;
     454    KU32      EndAddressOfRawData;
     455    KU32      AddressOfIndex;
     456    KU32      AddressOfCallBacks;
     457    KU32      SizeOfZeroFill;
     458    KU32      Characteristics;
    459459} IMAGE_TLS_DIRECTORY32;
    460460typedef IMAGE_TLS_DIRECTORY32 *PIMAGE_TLS_DIRECTORY32;
    … …  
    462462typedef struct _IMAGE_TLS_DIRECTORY64
    463463{
    464     uint64_t  StartAddressOfRawData;
    465     uint64_t  EndAddressOfRawData;
    466     uint64_t  AddressOfIndex;
    467     uint64_t  AddressOfCallBacks;
    468     uint32_t  SizeOfZeroFill;
    469     uint32_t  Characteristics;
     464    KU64      StartAddressOfRawData;
     465    KU64      EndAddressOfRawData;
     466    KU64      AddressOfIndex;
     467    KU64      AddressOfCallBacks;
     468    KU32      SizeOfZeroFill;
     469    KU32      Characteristics;
    470470} IMAGE_TLS_DIRECTORY64;
    471471typedef IMAGE_TLS_DIRECTORY64 *PIMAGE_TLS_DIRECTORY64;

  • trunk/kStuff/kLdr/kLdrRdr.c

    r3549 r3567  
    139139 * @param   off         Where to start reading.
    140140 */
    141 int kLdrRdrRead(PKLDRRDR pRdr, void *pvBuf, size_t cb, KLDRFOFF off)
     141int kLdrRdrRead(PKLDRRDR pRdr, void *pvBuf, KSIZE cb, KLDRFOFF off)
    142142{
    143143    KLDRRDR_VALIDATE(pRdr);
    … …  
    215215 * @param   pRdr        The file provider instance.
    216216 */
    217 size_t  kLdrRdrPageSize(PKLDRRDR pRdr)
     217KSIZE  kLdrRdrPageSize(PKLDRRDR pRdr)
    218218{
    219219    KLDRRDR_VALIDATE_EX(pRdr, 0x10000);
    … …  
    236236 * @param   fFixed      If set, the address at *ppvBase should be the base address of the mapping.
    237237 */
    238 int kLdrRdrMap(PKLDRRDR pRdr, void **ppvBase, uint32_t cSegments, PCKLDRSEG paSegments, unsigned fFixed)
     238int kLdrRdrMap(PKLDRRDR pRdr, void **ppvBase, KU32 cSegments, PCKLDRSEG paSegments, unsigned fFixed)
    239239{
    240240    KLDRRDR_VALIDATE(pRdr);
    … …  
    252252 * @param   paSegments  The segments thats going to be mapped.
    253253 */
    254 int kLdrRdrRefresh(PKLDRRDR pRdr, void *pvBase, uint32_t cSegments, PCKLDRSEG paSegments)
     254int kLdrRdrRefresh(PKLDRRDR pRdr, void *pvBase, KU32 cSegments, PCKLDRSEG paSegments)
    255255{
    256256    KLDRRDR_VALIDATE(pRdr);
    … …  
    273273 *                                  When clean the segment protection is restored.
    274274 */
    275 int kLdrRdrProtect(PKLDRRDR pRdr, void *pvBase, uint32_t cSegments, PCKLDRSEG paSegments, unsigned fUnprotectOrProtect)
     275int kLdrRdrProtect(PKLDRRDR pRdr, void *pvBase, KU32 cSegments, PCKLDRSEG paSegments, unsigned fUnprotectOrProtect)
    276276{
    277277    KLDRRDR_VALIDATE(pRdr);
    … …  
    289289 * @param   paSegments  The segments thats going to be mapped.
    290290 */
    291 int kLdrRdrUnmap(PKLDRRDR pRdr, void *pvBase, uint32_t cSegments, PCKLDRSEG paSegments)
     291int kLdrRdrUnmap(PKLDRRDR pRdr, void *pvBase, KU32 cSegments, PCKLDRSEG paSegments)
    292292{
    293293    KLDRRDR_VALIDATE(pRdr);

  • trunk/kStuff/kLdr/kLdrRdrFile.c

    r3537 r3567  
    184184    void           *pv;
    185185    /** The size of the prepared region. */
    186     size_t          cb;
     186    KSIZE           cb;
    187187#if defined(__WIN__) || defined(__NT__)
    188188    /** Handle to the section created to map the file. */
    … …  
    213213    KLDRRDRFILEPREP     aPreps[4];
    214214    /** The number of current preps. */
    215     uint32_t            cPreps;
     215    KU32                cPreps;
    216216    /** Number of mapping references. */
    217     int32_t             cMappings;
     217    KI32                cMappings;
    218218    /** The memory mapping. */
    219219    void               *pvMapping;
    … …  
    227227*******************************************************************************/
    228228static void     kldrRdrFileDone(PKLDRRDR pRdr);
    229 static int      kldrRdrFileUnmap(PKLDRRDR pRdr, void *pvBase, uint32_t cSegments, PCKLDRSEG paSegments);
    230 static int      kldrRdrFileGenericUnmap(PKLDRRDR pRdr, PKLDRRDRFILEPREP pPrep, uint32_t cSegments, PCKLDRSEG paSegments);
    231 static int      kldrRdrFileProtect(PKLDRRDR pRdr, void *pvBase, uint32_t cSegments, PCKLDRSEG paSegments, unsigned fUnprotectOrProtect);
    232 static int      kldrRdrFileGenericProtect(PKLDRRDR pRdr, PKLDRRDRFILEPREP pPrep, uint32_t cSegments, PCKLDRSEG paSegments, unsigned fUnprotectOrProtect);
    233 static int      kldrRdrFileRefresh(PKLDRRDR pRdr, void *pvBase, uint32_t cSegments, PCKLDRSEG paSegments);
    234 static int      kldrRdrFileGenericRefresh(PKLDRRDR pRdr, PKLDRRDRFILEPREP pPrep, uint32_t cSegments, PCKLDRSEG paSegments);
    235 static int      kldrRdrFileMap(PKLDRRDR pRdr, void **ppvBase, uint32_t cSegments, PCKLDRSEG paSegments, unsigned fFixed);
    236 static int      kldrRdrFileGenericMap(PKLDRRDR pRdr, PKLDRRDRFILEPREP pPrep, uint32_t cSegments, PCKLDRSEG paSegments, unsigned fFixed);
    237 static size_t   kldrRdrFilePageSize(PKLDRRDR pRdr);
     229static int      kldrRdrFileUnmap(PKLDRRDR pRdr, void *pvBase, KU32 cSegments, PCKLDRSEG paSegments);
     230static int      kldrRdrFileGenericUnmap(PKLDRRDR pRdr, PKLDRRDRFILEPREP pPrep, KU32 cSegments, PCKLDRSEG paSegments);
     231static int      kldrRdrFileProtect(PKLDRRDR pRdr, void *pvBase, KU32 cSegments, PCKLDRSEG paSegments, unsigned fUnprotectOrProtect);
     232static int      kldrRdrFileGenericProtect(PKLDRRDR pRdr, PKLDRRDRFILEPREP pPrep, KU32 cSegments, PCKLDRSEG paSegments, unsigned fUnprotectOrProtect);
     233static int      kldrRdrFileRefresh(PKLDRRDR pRdr, void *pvBase, KU32 cSegments, PCKLDRSEG paSegments);
     234static int      kldrRdrFileGenericRefresh(PKLDRRDR pRdr, PKLDRRDRFILEPREP pPrep, KU32 cSegments, PCKLDRSEG paSegments);
     235static int      kldrRdrFileMap(PKLDRRDR pRdr, void **ppvBase, KU32 cSegments, PCKLDRSEG paSegments, unsigned fFixed);
     236static int      kldrRdrFileGenericMap(PKLDRRDR pRdr, PKLDRRDRFILEPREP pPrep, KU32 cSegments, PCKLDRSEG paSegments, unsigned fFixed);
     237static KSIZE    kldrRdrFilePageSize(PKLDRRDR pRdr);
    238238static const char *kldrRdrFileName(PKLDRRDR pRdr);
    239239static KLDRFOFF kldrRdrFileTell(PKLDRRDR pRdr);
    … …  
    241241static int      kldrRdrFileAllUnmap(PKLDRRDR pRdr, const void *pvBits);
    242242static int      kldrRdrFileAllMap(PKLDRRDR pRdr, const void **ppvBits);
    243 static int      kldrRdrFileRead(PKLDRRDR pRdr, void *pvBuf, size_t cb, KLDRFOFF off);
     243static int      kldrRdrFileRead(PKLDRRDR pRdr, void *pvBuf, KSIZE cb, KLDRFOFF off);
    244244static int      kldrRdrFileDestroy(PKLDRRDR pRdr);
    245245static int      kldrRdrFileCreate(PPKLDRRDR ppRdr, const char *pszFilename);
    … …  
    335335static PKLDRRDRFILEPREP kldrRdrFileFindPrepExact(PKLDRRDRFILE pFile, void *pv)
    336336{
    337     int32_t i = pFile->cPreps;
     337    KI32 i = pFile->cPreps;
    338338    while (i-- > 0)
    339339        if (pFile->aPreps[i].pv == pv)
    … …  
    344344
    345345/** @copydoc KLDRRDR::pfnUnmap */
    346 static int      kldrRdrFileUnmap(PKLDRRDR pRdr, void *pvBase, uint32_t cSegments, PCKLDRSEG paSegments)
     346static int      kldrRdrFileUnmap(PKLDRRDR pRdr, void *pvBase, KU32 cSegments, PCKLDRSEG paSegments)
    347347{
    348348    PKLDRRDRFILE        pRdrFile = (PKLDRRDRFILE)pRdr;
    … …  
    374374
    375375/** Generic implementation of kldrRdrFileUnmap. */
    376 static int kldrRdrFileGenericUnmap(PKLDRRDR pRdr, PKLDRRDRFILEPREP pPrep, uint32_t cSegments, PCKLDRSEG paSegments)
     376static int kldrRdrFileGenericUnmap(PKLDRRDR pRdr, PKLDRRDRFILEPREP pPrep, KU32 cSegments, PCKLDRSEG paSegments)
    377377{
    378378    kldrRdrFileGenericProtect(pRdr, pPrep, cSegments, paSegments, 1 /* unprotect */);
    … …  
    382382
    383383/** @copydoc KLDRRDR::pfnProtect */
    384 static int      kldrRdrFileProtect(PKLDRRDR pRdr, void *pvBase, uint32_t cSegments, PCKLDRSEG paSegments, unsigned fUnprotectOrProtect)
     384static int      kldrRdrFileProtect(PKLDRRDR pRdr, void *pvBase, KU32 cSegments, PCKLDRSEG paSegments, unsigned fUnprotectOrProtect)
    385385{
    386386    PKLDRRDRFILE        pRdrFile = (PKLDRRDRFILE)pRdr;
    … …  
    402402
    403403/** Generic implementation of kldrRdrFileProtect. */
    404 static int kldrRdrFileGenericProtect(PKLDRRDR pRdr, PKLDRRDRFILEPREP pPrep, uint32_t cSegments, PCKLDRSEG paSegments, unsigned fUnprotectOrProtect)
    405 {
    406     uint32_t i;
     404static int kldrRdrFileGenericProtect(PKLDRRDR pRdr, PKLDRRDRFILEPREP pPrep, KU32 cSegments, PCKLDRSEG paSegments, unsigned fUnprotectOrProtect)
     405{
     406    KU32 i;
    407407
    408408    /*
    … …  
    450450        }
    451451
    452         pv = (uint8_t *)pPrep->pv + paSegments[i].RVA;
     452        pv = (KU8 *)pPrep->pv + paSegments[i].RVA;
    453453
    454454        rc = kldrHlpPageProtect(pv, paSegments[i].cbMapped, enmProt);
    … …  
    462462
    463463/** @copydoc KLDRRDR::pfnRefresh */
    464 static int      kldrRdrFileRefresh(PKLDRRDR pRdr, void *pvBase, uint32_t cSegments, PCKLDRSEG paSegments)
     464static int      kldrRdrFileRefresh(PKLDRRDR pRdr, void *pvBase, KU32 cSegments, PCKLDRSEG paSegments)
    465465{
    466466    PKLDRRDRFILE        pRdrFile = (PKLDRRDRFILE)pRdr;
    … …  
    482482
    483483/** Generic implementation of kldrRdrFileRefresh. */
    484 static int      kldrRdrFileGenericRefresh(PKLDRRDR pRdr, PKLDRRDRFILEPREP pPrep, uint32_t cSegments, PCKLDRSEG paSegments)
     484static int      kldrRdrFileGenericRefresh(PKLDRRDR pRdr, PKLDRRDRFILEPREP pPrep, KU32 cSegments, PCKLDRSEG paSegments)
    485485{
    486486    int rc;
    487487    int rc2;
    488     uint32_t i;
     488    KU32 i;
    489489
    490490    /*
    … …  
    517517            continue;
    518518
    519         pv = (uint8_t *)pPrep->pv + paSegments[i].RVA;
     519        pv = (KU8 *)pPrep->pv + paSegments[i].RVA;
    520520        rc = pRdr->pOps->pfnRead(pRdr, pv, paSegments[i].cbFile, paSegments[i].offFile);
    521521        if (rc)
    … …  
    535535
    536536/** @copydoc KLDRRDR::pfnMap */
    537 static int      kldrRdrFileMap(PKLDRRDR pRdr, void **ppvBase, uint32_t cSegments, PCKLDRSEG paSegments, unsigned fFixed)
     537static int      kldrRdrFileMap(PKLDRRDR pRdr, void **ppvBase, KU32 cSegments, PCKLDRSEG paSegments, unsigned fFixed)
    538538{
    539539    PKLDRRDRFILE        pRdrFile = (PKLDRRDRFILE)pRdr;
    540540    PKLDRRDRFILEPREP    pPrep = &pRdrFile->aPreps[pRdrFile->cPreps];
    541541    KLDRSIZE            cbTotal;
    542     const size_t        cbPage = pRdr->pOps->pfnPageSize(pRdr);
     542    const KSIZE         cbPage = pRdr->pOps->pfnPageSize(pRdr);
    543543    int                 rc;
    544     uint32_t            i;
     544    KU32                i;
    545545
    546546    if (pRdrFile->cPreps >= KLDR_ELEMENTS(pRdrFile->aPreps))
    … …  
    560560            cbTotal = uRVASegmentEnd;
    561561    }
    562     pPrep->cb = (size_t)cbTotal;
     562    pPrep->cb = (KSIZE)cbTotal;
    563563    if (pPrep->cb != cbTotal)
    564564        return KLDR_ERR_ADDRESS_OVERFLOW;
    … …  
    646646        {
    647647            pv = NULL;
    648             ViewSize = (size_t)cbTotal;
     648            ViewSize = (KSIZE)cbTotal;
    649649
    650650            Status = NtAllocateVirtualMemory(NtCurrentProcess(),
    … …  
    677677                continue;
    678678
    679             pv = (uint8_t *)pPrep->pv + paSegments[i].RVA;
     679            pv = (KU8 *)pPrep->pv + paSegments[i].RVA;
    680680            if (paSegments[i].cbFile > 0)
    681681            {
    … …  
    735735                continue;
    736736
    737             pv = (uint8_t *)pPrep->pv + paSegments[i].RVA;
     737            pv = (KU8 *)pPrep->pv + paSegments[i].RVA;
    738738            if (paSegments[i].cbFile > 0)
    739739                NtUnmapViewOfSection(NtCurrentProcess(), pv);
    … …  
    763763
    764764/** Generic implementation of kldrRdrFileMap. */
    765 static int  kldrRdrFileGenericMap(PKLDRRDR pRdr, PKLDRRDRFILEPREP pPrep, uint32_t cSegments, PCKLDRSEG paSegments, unsigned fFixed)
     765static int  kldrRdrFileGenericMap(PKLDRRDR pRdr, PKLDRRDRFILEPREP pPrep, KU32 cSegments, PCKLDRSEG paSegments, unsigned fFixed)
    766766{
    767767    int rc;
    768     uint32_t i;
     768    KU32 i;
    769769
    770770    /*
    … …  
    786786            continue;
    787787
    788         pv = (uint8_t *)pPrep->pv + paSegments[i].RVA;
     788        pv = (KU8 *)pPrep->pv + paSegments[i].RVA;
    789789        rc = pRdr->pOps->pfnRead(pRdr, pv, paSegments[i].cbFile, paSegments[i].offFile);
    790790        if (rc)
    … …  
    810810
    811811/** @copydoc KLDRRDR::pfnPageSize */
    812 static size_t   kldrRdrFilePageSize(PKLDRRDR pRdr)
     812static KSIZE   kldrRdrFilePageSize(PKLDRRDR pRdr)
    813813{
    814814#ifdef __OS2__
    … …  
    941941
    942942/** @copydoc KLDRRDR::pfnRead */
    943 static int kldrRdrFileRead(PKLDRRDR pRdr, void *pvBuf, size_t cb, KLDRFOFF off)
     943static int kldrRdrFileRead(PKLDRRDR pRdr, void *pvBuf, KSIZE cb, KLDRFOFF off)
    944944{
    945945    PKLDRRDRFILE pRdrFile = (PKLDRRDRFILE)pRdr;
    … …  
    10591059static int kldrRdrFileCreate(PPKLDRRDR ppRdr, const char *pszFilename)
    10601060{
    1061     size_t          cchFilename;
     1061    KSIZE           cchFilename;
    10621062    PKLDRRDRFILE    pRdrFile;
    10631063
    … …  
    10731073    char            szFilename[CCHMAXPATH];
    10741074
    1075     if ((uintptr_t)pszFilename >= 0x20000000)
     1075    if ((KUPTR)pszFilename >= 0x20000000)
    10761076    {
    10771077        char *psz;

  • trunk/kStuff/kLdr/tstkLdrMod.c

    r3537 r3567  
    7070
    7171/** Dummy import resolver callback. */
    72 static int BasicTestsGetImport(PKLDRMOD pMod, uint32_t iImport, uint32_t iSymbol, const char *pchSymbol, size_t cchSymbol,
    73                                const char *pszVersion, PKLDRADDR puValue, uint32_t *pfKind, void *pvUser)
     72static int BasicTestsGetImport(PKLDRMOD pMod, KU32 iImport, KU32 iSymbol, const char *pchSymbol, KSIZE cchSymbol,
     73                               const char *pszVersion, PKLDRADDR puValue, KU32 *pfKind, void *pvUser)
    7474{
    7575    *puValue = 0xdeadface;
    … …  
    8282 * Verbose memcmp().
    8383 */
    84 static int TestMemComp(const void *pv1, const void *pv2, size_t cb)
    85 {
    86     size_t          off;
    87     const uint8_t  *pb1 = (const uint8_t *)pv1;
    88     const uint8_t  *pb2 = (const uint8_t *)pv2;
     84static int TestMemComp(const void *pv1, const void *pv2, KSIZE cb)
     85{
     86    KSIZE           off;
     87    const KU8      *pb1 = (const KU8 *)pv1;
     88    const KU8      *pb2 = (const KU8 *)pv2;
    8989    if (!memcmp(pb1, pb2, cb))
    9090        return 0;
    … …  
    105105static int BasicTestsRelocate(PKLDRMOD pMod, void *pvBits, void *pvBits2)
    106106{
    107     const size_t cbImage = (size_t)kLdrModSize(pMod);
     107    const KSIZE cbImage = (KSIZE)kLdrModSize(pMod);
    108108    int rc;
    109109
    … …  
    114114     */
    115115    memset(pvBits2, 0xfe, cbImage);
    116     rc = kLdrModGetBits(pMod, pvBits2, (uintptr_t)pvBits, BasicTestsGetImport, NULL);
     116    rc = kLdrModGetBits(pMod, pvBits2, (KUPTR)pvBits, BasicTestsGetImport, NULL);
    117117    if (rc)
    118118        return Failure("failed to get image bits, rc=%d (%s) (a)", rc, kLdrErrStr(rc));
    … …  
    123123     * Short relocation round trip.
    124124     */
    125     rc = kLdrModRelocateBits(pMod, pvBits2, 0x1000, (uintptr_t)pvBits, BasicTestsGetImport, NULL);
     125    rc = kLdrModRelocateBits(pMod, pvBits2, 0x1000, (KUPTR)pvBits, BasicTestsGetImport, NULL);
    126126    if (rc)
    127127        return Failure("failed to relocate, rc=%d (%s) (b1)", rc, kLdrErrStr(rc));
    128     rc = kLdrModRelocateBits(pMod, pvBits2, (uintptr_t)pvBits, 0x1000, BasicTestsGetImport, NULL);
     128    rc = kLdrModRelocateBits(pMod, pvBits2, (KUPTR)pvBits, 0x1000, BasicTestsGetImport, NULL);
    129129    if (rc)
    130130        return Failure("failed to relocate, rc=%d (%s) (b2)", rc, kLdrErrStr(rc));
    … …  
    136136     */
    137137    /* stage one */
    138     rc = kLdrModRelocateBits(pMod, pvBits, 0x1000000, (uintptr_t)pvBits, BasicTestsGetImport, NULL);
     138    rc = kLdrModRelocateBits(pMod, pvBits, 0x1000000, (KUPTR)pvBits, BasicTestsGetImport, NULL);
    139139    if (rc)
    140140        return Failure("failed to relocate, rc=%d (%s) (c1)", rc, kLdrErrStr(rc));
    … …  
    147147
    148148    /* stage two */
    149     rc = kLdrModRelocateBits(pMod, pvBits, ~(uintptr_t)0x1010000, 0x1000000, BasicTestsGetImport, NULL);
     149    rc = kLdrModRelocateBits(pMod, pvBits, ~(KUPTR)0x1010000, 0x1000000, BasicTestsGetImport, NULL);
    150150    if (rc)
    151151        return Failure("failed to relocate, rc=%d (%s) (c2)", rc, kLdrErrStr(rc));
    152152    memset(pvBits2, 0xef, cbImage);
    153     rc = kLdrModGetBits(pMod, pvBits2, ~(uintptr_t)0x1010000, BasicTestsGetImport, NULL);
     153    rc = kLdrModGetBits(pMod, pvBits2, ~(KUPTR)0x1010000, BasicTestsGetImport, NULL);
    154154    if (rc)
    155155        return Failure("failed to get image bits, rc=%d (%s) (c2)", rc, kLdrErrStr(rc));
    … …  
    158158
    159159    /* stage three */
    160     rc = kLdrModRelocateBits(pMod, pvBits, MY_BASEADDRESS, ~(uintptr_t)0x1010000, BasicTestsGetImport, NULL);
     160    rc = kLdrModRelocateBits(pMod, pvBits, MY_BASEADDRESS, ~(KUPTR)0x1010000, BasicTestsGetImport, NULL);
    161161    if (rc)
    162162        return Failure("failed to relocate, rc=%d (%s) (c3)", rc, kLdrErrStr(rc));
    … …  
    169169
    170170    /* stage four */
    171     rc = kLdrModRelocateBits(pMod, pvBits, ~(uintptr_t)0 / 2 - 0x10000, MY_BASEADDRESS, BasicTestsGetImport, NULL);
     171    rc = kLdrModRelocateBits(pMod, pvBits, ~(KUPTR)0 / 2 - 0x10000, MY_BASEADDRESS, BasicTestsGetImport, NULL);
    172172    if (rc)
    173173        return Failure("failed to relocate, rc=%d %(s) (c4)", rc, kLdrErrStr(rc));
    174174    memset(pvBits2, 0xdc, cbImage);
    175     rc = kLdrModGetBits(pMod, pvBits2, ~(uintptr_t)0 / 2 - 0x10000, BasicTestsGetImport, NULL);
     175    rc = kLdrModGetBits(pMod, pvBits2, ~(KUPTR)0 / 2 - 0x10000, BasicTestsGetImport, NULL);
    176176    if (rc)
    177177        return Failure("failed to get image bits, rc=%d (%s) (c4)", rc, kLdrErrStr(rc));
    … …  
    180180
    181181    /* return */
    182     rc = kLdrModRelocateBits(pMod, pvBits, (uintptr_t)pvBits, ~(uintptr_t)0 / 2 - 0x10000, BasicTestsGetImport, NULL);
     182    rc = kLdrModRelocateBits(pMod, pvBits, (KUPTR)pvBits, ~(KUPTR)0 / 2 - 0x10000, BasicTestsGetImport, NULL);
    183183    if (rc)
    184184        return Failure("failed to relocate, rc=%d (%s) (c5)", rc, kLdrErrStr(rc));
    185185    memset(pvBits2, 0xcd, cbImage);
    186     rc = kLdrModGetBits(pMod, pvBits2, (uintptr_t)pvBits, BasicTestsGetImport, NULL);
     186    rc = kLdrModGetBits(pMod, pvBits2, (KUPTR)pvBits, BasicTestsGetImport, NULL);
    187187    if (rc)
    188188        return Failure("failed to get image bits, rc=%d (%s) (c5)", rc, kLdrErrStr(rc));
    … …  
    197197 * Dump symbols and check that we can query each of them recursivly.
    198198 */
    199 static int BasicTestsEnumSymCallback(PKLDRMOD pMod, uint32_t iSymbol, const char *pchSymbol, size_t cchSymbol,
    200                                      const char *pszVersion, KLDRADDR uValue, uint32_t fKind, void *pvUser)
     199static int BasicTestsEnumSymCallback(PKLDRMOD pMod, KU32 iSymbol, const char *pchSymbol, KSIZE cchSymbol,
     200                                     const char *pszVersion, KLDRADDR uValue, KU32 fKind, void *pvUser)
    201201{
    202202    KLDRADDR    uValue2;
    203     uint32_t    fKind2;
     203    KU32        fKind2;
    204204    int         rc;
    205205
    … …  
    249249 * Dump debugger information and check it for correctness.
    250250 */
    251 static int BasicTestEnumDbgInfoCallback(PKLDRMOD pMod, uint32_t iDbgInfo, KLDRDBGINFOTYPE enmType,
    252                                         int16_t iMajorVer, int16_t iMinorVer, KLDRFOFF offFile, KLDRADDR LinkAddress,
     251static int BasicTestEnumDbgInfoCallback(PKLDRMOD pMod, KU32 iDbgInfo, KLDRDBGINFOTYPE enmType,
     252                                        KI16 iMajorVer, KI16 iMinorVer, KLDRFOFF offFile, KLDRADDR LinkAddress,
    253253                                        KLDRSIZE cb, const char *pszExtFile, void *pvUser)
    254254{
    … …  
    272272static int BasicTestsSub2(PKLDRMOD pMod, void *pvBits)
    273273{
    274     int32_t cImports;
    275     int32_t i;
     274    KI32 cImports;
     275    KI32 i;
    276276    int rc;
    277     uint32_t fKind;
     277    KU32 fKind;
    278278    KLDRADDR Value;
    279279    KLDRADDR MainEPAddress;
    … …  
    395395{
    396396    int         rc;
    397     uint32_t    i;
     397    KU32        i;
    398398    void       *pvBits;
    399     size_t      cbImage;
     399    KSIZE       cbImage;
    400400
    401401    /*
    … …  
    479479    printf("* Testing user mapping...\n");
    480480
    481     cbImage = (size_t)kLdrModSize(pMod);
     481    cbImage = (KSIZE)kLdrModSize(pMod);
    482482    if (cbImage != kLdrModSize(pMod))
    483483        return Failure("aborting test because the image is too huge!");
    484     pvBits = malloc((size_t)cbImage);
     484    pvBits = malloc((KSIZE)cbImage);
    485485    if (!pvBits)
    486486        return Failure("failed to allocate %d bytes for the image", cbImage);
    487487
    488     rc = kLdrModGetBits(pMod, pvBits, (uintptr_t)pvBits, BasicTestsGetImport, NULL);
     488    rc = kLdrModGetBits(pMod, pvBits, (KUPTR)pvBits, BasicTestsGetImport, NULL);
    489489    if (rc)
    490490        return Failure("failed to get image bits, rc=%d (%s)", rc, kLdrErrStr(rc));
    … …  
    499499         * Test relocating the bits in a few different ways before we're done with them.
    500500         */
    501         void *pvBits2 = malloc((size_t)cbImage);
     501        void *pvBits2 = malloc((KSIZE)cbImage);
    502502        if (pvBits2)
    503503        {
Note: See TracChangeset for help on using the changeset viewer.