Changeset 3542 for trunk


Ignore:
Timestamp:
Aug 25, 2007, 6:40:45 AM (18 years ago)
Author:
bird
Message:

Refactorying kLdrRdr into kRdr.

File:
1 copied

Legend:

Unmodified
Added
Removed

  • trunk/kStuff/include/k/kRdr.h

    r3537 r3542  
    11/* $Id$ */
    22/** @file
     3 * kRdr - The File Provider.
     4 */
     5
     6/*
     7 * Copyright (c) 2006-2007 knut st. osmundsen <bird-src-spam@anduin.net>
    38 *
    4  * kLdr - The Dynamic Loader.
     9 * This file is part of kStuff.
    510 *
    6  * Copyright (c) 2006 knut st. osmundsen <bird@anduin.net>
    7  *
    8  *
    9  * This file is part of kLdr.
    10  *
    11  * kLdr is free software; you can redistribute it and/or modify
    12  * it under the terms of the GNU General Public License as published by
    13  * the Free Software Foundation; either version 2 of the License, or
     11 * kStuff is free software; you can redistribute it and/or modify
     12 * it under the terms of the GNU Lesser General Public License as published
     13 * by the Free Software Foundation; either version 2 of the License, or
    1414 * (at your option) any later version.
    1515 *
    16  * kLdr is distributed in the hope that it will be useful,
     16 * kStuff is distributed in the hope that it will be useful,
    1717 * but WITHOUT ANY WARRANTY; without even the implied warranty of
    1818 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    19  * GNU General Public License for more details.
     19 * GNU Lesser General Public License for more details.
    2020 *
    21  * You should have received a copy of the GNU General Public License
    22  * along with kLdr; if not, write to the Free Software
     21 * You should have received a copy of the GNU Lesser General Public License
     22 * along with kStuff; if not, write to the Free Software
    2323 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
    2424 *
    2525 */
    2626
    27 #ifndef ___kLdr_h___
    28 #define ___kLdr_h___
     27#ifndef ___kRdr_h___
     28#define ___kRdr_h___
     29
     30#include <k/kDefs.h>
     31#ifndef ___k_kLdr___
     32/* avoid dragging in kLdr.h */
     33typedef enum KLDRPROT { KLDRPROT_32BIT_HACK = 0x7fffffff } KLDRPROT;
     34typedef const struct KLDRSEG *PCKLDRSEG;
     35#endif
    2936
    3037#ifdef __cplusplus
    … …  
    3239#endif
    3340
    34 /*
    35  * Include the base typedefs and macros.
    36  */
    37 #include "kLdrBase.h"
    3841
    39 
    40 /** @defgroup grp_kLdrBasic     kLdr Basic Types
    41  * @{ */
    42 
    43 /** The kLdr address type. */
    44 typedef uint64_t KLDRADDR;
    45 /** Pointer to a kLdr address. */
    46 typedef KLDRADDR *PKLDRADDR;
    47 /** Pointer to a const kLdr address. */
    48 typedef const KLDRADDR *PCKLDRADDR;
    49 
    50 /** NIL address. */
    51 #define NIL_KLDRADDR    (~(uint64_t)0)
    52 
    53 /** @def PRI_KLDRADDR
    54  * printf format type. */
    55 #ifdef _MSC_VER
    56 # define PRI_KLDRADDR    "I64x"
    57 #else
    58 # define PRI_KLDRADDR    "llx"
    59 #endif
    60 
    61 
    62 /** The kLdr size type. */
    63 typedef uint64_t KLDRSIZE;
    64 /** Pointer to a kLdr size. */
    65 typedef KLDRSIZE *PKLDRSIZE;
    66 /** Pointer to a const kLdr size. */
    67 typedef const KLDRSIZE *PCKLDRSIZE;
    68 
    69 /** @def PRI_KLDRSIZE
    70  * printf format type. */
    71 #ifdef _MSC_VER
    72 # define PRI_KLDRSIZE    "I64x"
    73 #else
    74 # define PRI_KLDRSIZE    "llx"
    75 #endif
    76 
    77 
    78 /** The kLdr file offset type. */
    79 typedef long KLDRFOFF;
    80 /** Pointer to a kLdr file offset type. */
    81 typedef KLDRFOFF *PKLDRFOFF;
    82 /** Pointer to a const kLdr file offset type. */
    83 typedef const KLDRFOFF *PCKLDRFOFF;
    84 
    85 /** @def PRI_KLDRFOFF
    86  * printf format type. */
    87 #define PRI_KLDRFOFF     "lx"
    88 
    89 
    90 /**
    91  * Union of all the integer types.
    92  */
    93 typedef union KLDRU
    94 {
    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. */
    110 
    111     signed char     ch;     /**< signed char view. */
    112     unsigned char   uch;    /**< unsigned char view. */
    113     signed short    s;      /**< signed short view. */
    114     unsigned short  us;     /**< unsigned short view. */
    115     signed int      i;      /**< signed int view. */
    116     unsigned int    u;      /**< unsigned int view. */
    117     signed long     l;      /**< signed long view. */
    118     unsigned long   ul;     /**< unsigned long view. */
    119     void           *pv;     /**< void pointer view. */
    120 
    121     KLDRADDR        Addr;   /**< kLdr address view. */
    122     KLDRSIZE        Size;   /**< kLdr size view. */
    123 } KLDRU;
    124 /** Pointer to an integer union. */
    125 typedef KLDRU *PKLDRU;
    126 /** Pointer to a const integer union. */
    127 typedef const KLDRU *PCKLDRU;
    128 
    129 
    130 /**
    131  * Union of pointers to all the integer types.
    132  */
    133 typedef union KLDRPU
    134 {
    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. */
    143 
    144     signed char    *pch;    /**< signed char view. */
    145     unsigned char  *puch;   /**< unsigned char view. */
    146     signed short   *ps;     /**< signed short view. */
    147     unsigned short *pus;    /**< unsigned short view. */
    148     signed int     *pi;     /**< signed int view. */
    149     unsigned int   *pu;     /**< unsigned int view. */
    150     signed long    *pl;     /**< signed long view. */
    151     unsigned long  *pul;    /**< unsigned long view. */
    152     void           *pv;     /**< void pointer view. */
    153 } KLDRPU;
    154 /** Pointer to an integer pointer union. */
    155 typedef KLDRPU *PKLDRPU;
    156 /** Pointer to a const integer pointer union. */
    157 typedef const KLDRPU *PCKLDRPU;
    158 
    159 
    160 /**
    161  * Memory Mapping Protections.
    162  *
    163  * @remark Shared segments can be mapped using the non copy-on-write variant.
    164  *         (Normally the copy-on-write variant is used because changes must
    165  *         be private and not shared with other processes mapping the file.)
    166  */
    167 typedef enum KLDRPROT
    168 {
    169     /** The usual invalid 0. */
    170     KLDRPROT_INVALID = 0,
    171     /** No access (page not present). */
    172     KLDRPROT_NOACCESS,
    173     /** Read only. */
    174     KLDRPROT_READONLY,
    175     /** Read & write. */
    176     KLDRPROT_READWRITE,
    177     /** Read & copy on write. */
    178     KLDRPROT_WRITECOPY,
    179     /** Execute only. */
    180     KLDRPROT_EXECUTE,
    181     /** Execute & read. */
    182     KLDRPROT_EXECUTE_READ,
    183     /** Execute, read & write. */
    184     KLDRPROT_EXECUTE_READWRITE,
    185     /** Execute, read & copy on write. */
    186     KLDRPROT_EXECUTE_WRITECOPY,
    187     /** The usual end value. (exclusive) */
    188     KLDRPROT_END,
    189     /** Blow the type up to 32-bits. */
    190     KLDRPROT_32BIT_HACK = 0x7fffffff
    191 } KLDRPROT;
    192 
    193 /** Pointer to a loader segment. */
    194 typedef struct KLDRSEG *PKLDRSEG;
    195 /** Pointer to a loader segment. */
    196 typedef const struct KLDRSEG *PCKLDRSEG;
    197 
    198 /** @} */
    199 
    200 
    201 /** @defgroup grp_kLdrRdr   kLdrRdr - The file provider
     42/** @defgroup grp_kRdr      kRdr - The File Provider
    20243 * @{ */
    20344
    20445/** Pointer to a file provider instance core. */
    205 typedef struct KLDRRDR *PKLDRRDR;
     46typedef struct KRDR *PKRDR;
    20647/** Pointer to a file provider instance core pointer. */
    207 typedef struct KLDRRDR **PPKLDRRDR;
     48typedef struct KRDR **PPKRDR;
    20849
    20950/**
    21051 * File provider instance operations.
    21152 */
    212 typedef struct KLDRRDROPS
     53typedef struct KRDROPS
    21354{
    21455    /** The name of this file provider. */
    21556    const char *pszName;
    21657    /** Pointer to the next file provider. */
    217     const struct KLDRRDROPS *pNext;
     58    const struct KRDROPS *pNext;
    21859
    21960    /** Try create a new file provider instance.
    … …  
    22364     * @param   pszFilename The filename to open.
    22465     */
    225     int     (* pfnCreate)(  PPKLDRRDR ppRdr, const char *pszFilename);
     66    int     (* pfnCreate)(  PPKRDR ppRdr, const char *pszFilename);
    22667    /** Destroy the file provider instance.
    22768     *
    … …  
    23071     * @param   pRdr        The file provider instance.
    23172     */
    232     int     (* pfnDestroy)( PKLDRRDR pRdr);
    233     /** @copydoc kLdrRdrRead */
    234     int     (* pfnRead)(    PKLDRRDR pRdr, void *pvBuf, size_t cb, KLDRFOFF off);
    235     /** @copydoc kLdrRdrAllMap */
    236     int     (* pfnAllMap)(  PKLDRRDR pRdr, const void **ppvBits);
    237     /** @copydoc kLdrRdrAllUnmap */
    238     int     (* pfnAllUnmap)(PKLDRRDR pRdr, const void *pvBits);
    239     /** @copydoc kLdrRdrSize */
    240     KLDRFOFF (* pfnSize)(    PKLDRRDR pRdr);
    241     /** @copydoc kLdrRdrTell */
    242     KLDRFOFF (* pfnTell)(    PKLDRRDR pRdr);
    243     /** @copydoc kLdrRdrName */
    244     const char * (* pfnName)(PKLDRRDR pRdr);
    245     /** @copydoc kLdrRdrPageSize */
    246     size_t  (* pfnPageSize)(PKLDRRDR pRdr);
    247     /** @copydoc kLdrRdrMap */
    248     int     (* pfnMap)(     PKLDRRDR pRdr, void **ppvBase, uint32_t cSegments, PCKLDRSEG paSegments, unsigned fFixed);
    249     /** @copydoc kLdrRdrRefresh */
    250     int     (* pfnRefresh)( PKLDRRDR pRdr, void *pvBase, uint32_t cSegments, PCKLDRSEG paSegments);
    251     /** @copydoc kLdrRdrProtect */
    252     int     (* pfnProtect)( PKLDRRDR pRdr, void *pvBase, uint32_t cSegments, PCKLDRSEG paSegments, unsigned fUnprotectOrProtect);
    253     /** @copydoc kLdrRdrUnmap */
    254     int     (* pfnUnmap)(   PKLDRRDR pRdr, void *pvBase, uint32_t cSegments, PCKLDRSEG paSegments);
    255     /** @copydoc kLdrRdrDone */
    256     void    (* pfnDone)(    PKLDRRDR pRdr);
     73    int     (* pfnDestroy)( PKRDR pRdr);
     74    /** @copydoc kRdrRead */
     75    int     (* pfnRead)(    PKRDR pRdr, void *pvBuf, size_t cb, KLDRFOFF off);
     76    /** @copydoc kRdrAllMap */
     77    int     (* pfnAllMap)(  PKRDR pRdr, const void **ppvBits);
     78    /** @copydoc kRdrAllUnmap */
     79    int     (* pfnAllUnmap)(PKRDR pRdr, const void *pvBits);
     80    /** @copydoc kRdrSize */
     81    KFOFF   (* pfnSize)(    PKRDR pRdr);
     82    /** @copydoc kRdrTell */
     83    KFOFF   (* pfnTell)(    PKRDR pRdr);
     84    /** @copydoc kRdrName */
     85    const char * (* pfnName)(PKRDR pRdr);
     86    /** @copydoc kRdrPageSize */
     87    KSIZE   (* pfnPageSize)(PKRDR pRdr);
     88    /** @copydoc kRdrMap */
     89    int     (* pfnMap)(     PKRDR pRdr, void **ppvBase, KU32 cSegments, PCKLDRSEG paSegments, unsigned fFixed);
     90    /** @copydoc kRdrRefresh */
     91    int     (* pfnRefresh)( PKRDR pRdr, void *pvBase, KU32 cSegments, PCKLDRSEG paSegments);
     92    /** @copydoc kRdrProtect */
     93    int     (* pfnProtect)( PKRDR pRdr, void *pvBase, KU32 cSegments, PCKLDRSEG paSegments, unsigned fUnprotectOrProtect);
     94    /** @copydoc kRdrUnmap */
     95    int     (* pfnUnmap)(   PKRDR pRdr, void *pvBase, KU32 cSegments, PCKLDRSEG paSegments);
     96    /** @copydoc kRdrDone */
     97    void    (* pfnDone)(    PKRDR pRdr);
    25798    /** The usual non-zero dummy that makes sure we've initialized all members. */
    258     uint32_t u32Dummy;
    259 } KLDRRDROPS;
     99    KU32    u32Dummy;
     100} KRDROPS;
    260101/** Pointer to file provider operations. */
    261 typedef KLDRRDROPS *PKLDRRDROPS;
     102typedef KRDROPS *PKRDROPS;
    262103/** Pointer to const file provider operations. */
    263 typedef const KLDRRDROPS *PCKLDRRDROPS;
     104typedef const KRDROPS *PCKRDROPS;
    264105
    265106
    … …  
    267108 * File provider instance core.
    268109 */
    269 typedef struct KLDRRDR
     110typedef struct KRDR
    270111{
    271112    /** Magic number (KLDRRDR_MAGIC). */
    272     uint32_t     u32Magic;
     113    KU32        u32Magic;
    273114    /** Pointer to the file provider operations. */
    274     PCKLDRRDROPS pOps;
    275 } KLDRRDR;
     115    PCKRDROPS  pOps;
     116} KRDR;
    276117
    277 /** The magic for KLDRRDR::u32Magic. (Katsu Aki (Katsuaki Nakamura)) */
    278 #define KLDRRDR_MAGIC   0x19610919
     118/** The magic for KRDR::u32Magic. (Katsu Aki (Katsuaki Nakamura)) */
     119#define KRDR_MAGIC   0x19610919
    279120
    280 void    kLdrRdrAddProvider(PKLDRRDROPS pAdd);
     121void    kRdrAddProvider(PKRDROPS pAdd);
    281122
    282 int     kLdrRdrOpen(    PPKLDRRDR ppRdr, const char *pszFilename);
    283 int     kLdrRdrClose(   PKLDRRDR pRdr);
    284 int     kLdrRdrRead(    PKLDRRDR pRdr, void *pvBuf, size_t cb, KLDRFOFF off);
    285 int     kLdrRdrAllMap(  PKLDRRDR pRdr, const void **ppvBits);
    286 int     kLdrRdrAllUnmap(PKLDRRDR pRdr, const void *pvBits);
    287 KLDRFOFF kLdrRdrSize(    PKLDRRDR pRdr);
    288 KLDRFOFF kLdrRdrTell(    PKLDRRDR pRdr);
    289 const 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);
    295 void    kLdrRdrDone(    PKLDRRDR pRdr);
     123int     kRdrOpen(PPKRDR ppRdr, const char *pszFilename);
     124int     kRdrOpenBuffered(PPKRDR ppRdr, const char *pszFilename);
     125
     126int     kRdrClose(   PKRDR pRdr);
     127int     kRdrRead(    PKRDR pRdr, void *pvBuf, size_t cb, KLDRFOFF off);
     128int     kRdrAllMap(  PKRDR pRdr, const void **ppvBits);
     129int     kRdrAllUnmap(PKRDR pRdr, const void *pvBits);
     130KFOFF   kRdrSize(    PKRDR pRdr);
     131KFOFF   kRdrTell(    PKRDR pRdr);
     132const char *kRdrName(PKRDR pRdr);
     133KIPTR   kRdrNativeFH(PKRDR pRdr);
     134
     135KSIZE   kRdrPageSize(PKRDR pRdr);
     136int     kRdrMap(     PKRDR pRdr, void **ppvBase, KU32 cSegments, PCKLDRSEG paSegments, unsigned fFixed);
     137int     kRdrRefresh( PKRDR pRdr, void *pvBase, KU32 cSegments, PCKLDRSEG paSegments);
     138int     kRdrProtect( PKRDR pRdr, void *pvBase, KU32 cSegments, PCKLDRSEG paSegments, unsigned fUnprotectOrProtect);
     139int     kRdrUnmap(   PKRDR pRdr, void *pvBase, KU32 cSegments, PCKLDRSEG paSegments);
     140void    kRdrDone(    PKRDR pRdr);
    296141
    297142/** @} */
    298 
    299 
    300 
    301 /** @defgroup grp_kLdrMod   kLdrMod - The executable image intepreter
    302  * @{ */
    303 
    304 /**
    305  * CPU Architecture.
    306  * @todo Double check the non intel architectures.
    307  */
    308 typedef enum KLDRARCH
    309 {
    310     /** The usual invalid one. */
    311     KLDRARCH_INVALID = 0,
    312     /** Clone or Intel 16-bit x86. */
    313     KLDRARCH_X86_16,
    314     /** Clone or Intel 32-bit x86. */
    315     KLDRARCH_X86_32,
    316     /** AMD64 (including clones). */
    317     KLDRARCH_AMD64,
    318     /** Itanic (64-bit). */
    319     KLDRARCH_IA64,
    320     /** ALPHA (64-bit). */
    321     KLDRARCH_ALPHA,
    322     /** ALPHA limited to 32-bit. */
    323     KLDRARCH_ALPHA_32,
    324     /** 32-bit ARM. */
    325     KLDRARCH_ARM_32,
    326     /** 64-bit ARM. */
    327     KLDRARCH_ARM_64,
    328     /** 32-bit MIPS. */
    329     KLDRARCH_MIPS_32,
    330     /** 64-bit MIPS. */
    331     KLDRARCH_MIPS_64,
    332     /** 32-bit PowerPC. */
    333     KLDRARCH_POWERPC_32,
    334     /** 64-bit PowerPC. */
    335     KLDRARCH_POWERPC_64,
    336     /** 32-bit SPARC. */
    337     KLDRARCH_SPARC_32,
    338     /** 64-bit SPARC. */
    339     KLDRARCH_SPARC_64,
    340     /** The end of the valid architecture values (exclusive). */
    341     KLDRARCH_END,
    342     /** Hack to blow the type up to 32-bit. */
    343     KLDRARCH_32BIT_HACK = 0x7fffffff
    344 } KLDRARCH;
    345 /** Pointer to a CPU architecture type. */
    346 typedef KLDRARCH *PKLDRARCH;
    347 
    348 /**
    349  * CPU models.
    350  */
    351 typedef enum KLDRCPU
    352 {
    353     /** The usual invalid cpu. */
    354     KLDRCPU_INVALID = 0,
    355     /** @name KLDRARCH_X86_16
    356      * @{ */
    357     KLDRCPU_I8086,
    358     KLDRCPU_I8088,
    359     KLDRCPU_I80186,
    360     KLDRCPU_I80286,
    361     KLDRCPU_I386_16,
    362     KLDRCPU_I486_16,
    363     KLDRCPU_I486SX_16,
    364     KLDRCPU_I586_16,
    365     KLDRCPU_I686_16,
    366     KLDRCPU_P4_16,
    367     KLDRCPU_CORE2_16,
    368     KLDRCPU_K6_16,
    369     KLDRCPU_K7_16,
    370     KLDRCPU_K8_16,
    371     KLDRCPU_FIRST_X86_16 = KLDRCPU_I8086,
    372     KLDRCPU_LAST_X86_16 = KLDRCPU_K8_16,
    373     /** @} */
    374 
    375     /** @name KLDRARCH_X86_32
    376      * @{ */
    377     KLDRCPU_X86_32_BLEND,
    378     KLDRCPU_I386,
    379     KLDRCPU_I486,
    380     KLDRCPU_I486SX,
    381     KLDRCPU_I586,
    382     KLDRCPU_I686,
    383     KLDRCPU_P4,
    384     KLDRCPU_CORE2_32,
    385     KLDRCPU_K6,
    386     KLDRCPU_K7,
    387     KLDRCPU_K8_32,
    388     KLDRCPU_FIRST_X86_32 = KLDRCPU_I386,
    389     KLDRCPU_LAST_X86_32 = KLDRCPU_K8_32,
    390     /** @} */
    391 
    392     /** @name KLDRARCH_AMD64
    393      * @{ */
    394     KLDRCPU_AMD64_BLEND,
    395     KLDRCPU_K8,
    396     KLDRCPU_P4_64,
    397     KLDRCPU_CORE2,
    398     KLDRCPU_FIRST_AMD64 = KLDRCPU_K8,
    399     KLDRCPU_LAST_AMD64 = KLDRCPU_CORE2,
    400     /** @} */
    401 
    402     /** The end of the valid cpu values (exclusive). */
    403     KLDRCPU_END,
    404     /** Hack to blow the type up to 32-bit. */
    405     KLDRCPU_32BIT_HACK = 0x7fffffff
    406 } KLDRCPU;
    407 /** Pointer to a CPU type. */
    408 typedef KLDRCPU *PKLDRCPU;
    409 
    410 void kLdrGetArchCpu(PKLDRARCH penmArch, PKLDRCPU penmCpu);
    411 int kLdrCompareCpus(KLDRARCH enmCodeArch, KLDRCPU enmCodeCpu, KLDRARCH enmArch, KLDRCPU enmCpu);
    412 
    413 
    414 /**
    415  * Debug info type (from the loader point of view).
    416  */
    417 typedef enum KLDRDBGINFOTYPE
    418 {
    419     /** The usual invalid enum value. */
    420     KLDRDBGINFOTYPE_INVALID = 0,
    421     /** Unknown debug info format. */
    422     KLDRDBGINFOTYPE_UNKNOWN,
    423     /** Stabs. */
    424     KLDRDBGINFOTYPE_STABS,
    425     /** Debug With Arbitrary Record Format (DWARF). */
    426     KLDRDBGINFOTYPE_DWARF,
    427     /** Microsoft Codeview debug info. */
    428     KLDRDBGINFOTYPE_CODEVIEW,
    429     /** Watcom debug info. */
    430     KLDRDBGINFOTYPE_WATCOM,
    431     /** IBM High Level Language debug info.. */
    432     KLDRDBGINFOTYPE_HLL,
    433     /** The end of the valid debug info values (exclusive). */
    434     KLDRDBGINFOTYPE_END,
    435     /** Blow the type up to 32-bit. */
    436     KLDRDBGINFOTYPE_32BIT_HACK = 0x7fffffff
    437 } KLDRDBGINFOTYPE;
    438 /** Pointer to a kLdr debug info type. */
    439 typedef KLDRDBGINFOTYPE *PKLDRDBGINFOTYPE;
    440 
    441 
    442 /**
    443  * Stack information.
    444  */
    445 typedef struct KLDRSTACKINFO
    446 {
    447     /** The base address of the stack (sub) segment.
    448      * Set this to NIL_KLDRADDR if the module doesn't include any stack segment. */
    449     KLDRADDR        Address;
    450     /** The base address of the stack (sub) segment, link address.
    451      * Set this to NIL_KLDRADDR if the module doesn't include any stack (sub)segment. */
    452     KLDRADDR        LinkAddress;
    453     /** The stack size of the main thread.
    454      * If no stack (sub)segment in the module, this is the stack size of the main thread.
    455      * If the module doesn't contain this kind of information this field will be set to 0. */
    456     KLDRSIZE        cbStack;
    457     /** The stack size of non-main threads.
    458      * If the module doesn't contain this kind of information this field will be set to 0. */
    459     KLDRSIZE        cbStackThread;
    460 } KLDRSTACKINFO;
    461 /** Pointer to stack information. */
    462 typedef KLDRSTACKINFO *PKLDRSTACKINFO;
    463 /** Pointer to const stack information. */
    464 typedef const KLDRSTACKINFO *PCKLDRSTACKINFO;
    465 
    466 
    467 /**
    468  * Loader segment.
    469  */
    470 typedef struct KLDRSEG
    471 {
    472     /** Variable free to use for the kLdr user. */
    473     void           *pvUser;
    474     /** The segment name. (Might not be zero terminated!) */
    475     const char     *pchName;
    476     /** The length of the segment name. */
    477     uint32_t        cchName;
    478     /** The flat selector to use for the segment (i.e. data/code).
    479      * Primarily a way for the user to specify selectors for the LX/LE and NE interpreters. */
    480     uint16_t        SelFlat;
    481     /** The 16-bit selector to use for the segment.
    482      * Primarily a way for the user to specify selectors for the LX/LE and NE interpreters. */
    483     uint16_t        Sel16bit;
    484     /** Segment flags. */
    485     uint32_t        fFlags;
    486     /** The segment protection. */
    487     KLDRPROT        enmProt;
    488     /** The size of the segment. */
    489     KLDRSIZE        cb;
    490     /** The required segment alignment.
    491      * The to 0 if the segment isn't supposed to be mapped. */
    492     KLDRADDR        Alignment;
    493     /** The link address.
    494      * Set to NIL_KLDRADDR if the segment isn't supposed to be
    495      * mapped or if the image doesn't have link addresses. */
    496     KLDRADDR        LinkAddress;
    497     /** File offset of the segment.
    498      * Set to -1 if no file backing (like BSS). */
    499     KLDRFOFF        offFile;
    500     /** Size of the file bits of the segment.
    501      * Set to -1 if no file backing (like BSS). */
    502     KLDRFOFF        cbFile;
    503     /** The relative virtual address when mapped.
    504      * Set to NIL_KLDRADDR if the segment isn't supposed to be mapped. */
    505     KLDRADDR        RVA;
    506     /** The size of the segment including the alignment gap up to the next segment when mapped. */
    507     size_t          cbMapped;
    508     /** The address the segment was mapped at by kLdrModMap().
    509      * Set to 0 if not mapped. */
    510     uintptr_t       MapAddress;
    511 } KLDRSEG;
    512 
    513 
    514 /** @name Segment flags
    515  * @{ */
    516 /** The segment is 16-bit. When not set the default of the target architecture is assumed. */
    517 #define KLDRSEG_FLAG_16BIT          1
    518 /** The segment requires a 16-bit selector alias. (OS/2) */
    519 #define KLDRSEG_FLAG_OS2_ALIAS16    2
    520 /** Conforming segment (x86 weirdness). (OS/2) */
    521 #define KLDRSEG_FLAG_OS2_CONFORM    4
    522 /** IOPL (ring-2) segment. (OS/2) */
    523 #define KLDRSEG_FLAG_OS2_IOPL       8
    524 /** @} */
    525 
    526 
    527 /**
    528  * Loader module format.
    529  */
    530 typedef enum KLDRFMT
    531 {
    532     /** The usual invalid 0 format. */
    533     KLDRFMT_INVALID = 0,
    534     /** The native OS loader. */
    535     KLDRFMT_NATIVE,
    536     /** The AOUT loader. */
    537     KLDRFMT_AOUT,
    538     /** The ELF loader. */
    539     KLDRFMT_ELF,
    540     /** The LX loader. */
    541     KLDRFMT_LX,
    542     /** The Mach-O loader. */
    543     KLDRFMT_MACHO,
    544     /** The PE loader. */
    545     KLDRFMT_PE,
    546     /** The end of the valid format values (exclusive). */
    547     KLDRFMT_END,
    548     /** Hack to blow the type up to 32-bit. */
    549     KLDRFMT_32BIT_HACK = 0x7fffffff
    550 } KLDRFMT;
    551 
    552 
    553 /**
    554  * Loader module type.
    555  */
    556 typedef enum KLDRTYPE
    557 {
    558     /** The usual invalid 0 type. */
    559     KLDRTYPE_INVALID = 0,
    560     /** Object file. */
    561     KLDRTYPE_OBJECT,
    562     /** Executable module, fixed load address. */
    563     KLDRTYPE_EXECUTABLE_FIXED,
    564     /** Executable module, relocatable, non-fixed load address. */
    565     KLDRTYPE_EXECUTABLE_RELOCATABLE,
    566     /** Executable module, position independent code, non-fixed load address. */
    567     KLDRTYPE_EXECUTABLE_PIC,
    568     /** Shared library, fixed load address.
    569      * Typically a system library. */
    570     KLDRTYPE_SHARED_LIBRARY_FIXED,
    571     /** Shared library, relocatable, non-fixed load address. */
    572     KLDRTYPE_SHARED_LIBRARY_RELOCATABLE,
    573     /** Shared library, position independent code, non-fixed load address. */
    574     KLDRTYPE_SHARED_LIBRARY_PIC,
    575     /** DLL that contains no code or data only imports and exports. (Chiefly OS/2.) */
    576     KLDRTYPE_FORWARDER_DLL,
    577     /** Core or dump. */
    578     KLDRTYPE_CORE,
    579     /** The end of the valid types values (exclusive). */
    580     KLDRTYPE_END,
    581     /** Hack to blow the type up to 32-bit. */
    582     KLDRTYPE_32BIT_HACK = 0x7fffffff
    583 } KLDRTYPE;
    584 
    585 
    586 /**
    587  * Loader endian indicator.
    588  */
    589 typedef enum KLDRENDIAN
    590 {
    591     /** The usual invalid endian. */
    592     KLDRENDIAN_INVALID,
    593     /** Little endian. */
    594     KLDRENDIAN_LITTLE,
    595     /** Bit endian. */
    596     KLDRENDIAN_BIG,
    597     /** Endianness doesn't have a meaning in the context. */
    598     KLDRENDIAN_NA,
    599     /** The end of the valid endian values (exclusive). */
    600     KLDRENDIAN_END,
    601     /** Hack to blow the type up to 32-bit. */
    602     KLDRENDIAN_32BIT_HACK = 0x7fffffff
    603 } KLDRENDIAN;
    604 
    605 
    606 /** Pointer to a module interpreter method table. */
    607 typedef struct KLDRMODOPS *PKLDRMODOPS;
    608 /** Pointer to const module interpreter methods table. */
    609 typedef const struct KLDRMODOPS *PCKLDRMODOPS;
    610 
    611 /**
    612  * Module interpreter instance.
    613  * All members are read only unless you're kLdrMod or the module interpreter.
    614  */
    615 typedef struct KLDRMOD
    616 {
    617     /** Magic number (KLDRMOD_MAGIC). */
    618     uint32_t            u32Magic;
    619     /** The format of this module. */
    620     KLDRFMT             enmFmt;
    621     /** The type of module. */
    622     KLDRTYPE            enmType;
    623     /** The architecture this module was built for. */
    624     KLDRARCH            enmArch;
    625     /** The minium cpu this module was built for.
    626      * This might not be accurate, so use kLdrModCanExecuteOn() to check. */
    627     KLDRARCH            enmCpu;
    628     /** The endian used by the module. */
    629     KLDRENDIAN          enmEndian;
    630     /** The filename length (bytes). */
    631     uint32_t            cchFilename;
    632     /** The filename. */
    633     const char         *pszFilename;
    634     /** The module name. */
    635     const char         *pszName;
    636     /** The module name length (bytes). */
    637     uint32_t            cchName;
    638     /** The number of segments in the module. */
    639     uint32_t            cSegments;
    640     /** Pointer to the loader methods.
    641      * Not meant for calling directly thru! */
    642     PCKLDRMODOPS        pOps;
    643     /** Pointer to the read instance. (Can be NULL after kLdrModDone().)*/
    644     PKLDRRDR            pRdr;
    645     /** The module data. */
    646     void               *pvData;
    647     /** Segments. (variable size, can be zero) */
    648     KLDRSEG             aSegments[1];
    649 } KLDRMOD, *PKLDRMOD, **PPKLDRMOD;
    650 
    651 /** The magic for KLDRMOD::u32Magic. (Kosuke Fujishima) */
    652 #define KLDRMOD_MAGIC   0x19640707
    653 
    654 
    655 /** Special base address value alias for the link address. */
    656 #define KLDRMOD_BASEADDRESS_LINK            (~(KLDRADDR)1)
    657 /** Special base address value alias for the actual load address (must be mapped). */
    658 #define KLDRMOD_BASEADDRESS_MAP             (~(KLDRADDR)2)
    659 
    660 /** Special import module ordinal value used to indicate that there is no
    661  * specific module associated with the requested symbol. */
    662 #define NIL_KLDRMOD_IMPORT                  (~(uint32_t)0)
    663 
    664 /** Special symbol ordinal value used to indicate that the symbol
    665  * only has a string name. */
    666 #define NIL_KLDRMOD_SYM_ORDINAL             (~(uint32_t)0)
    667 
    668 
    669 /** @name Load symbol kind flags.
    670  * @{ */
    671 /** The bitness doesn't matter. */
    672 #define KLDRSYMKIND_NO_BIT                  0x00000000
    673 /** 16-bit symbol. */
    674 #define KLDRSYMKIND_16BIT                   0x00000001
    675 /** 32-bit symbol. */
    676 #define KLDRSYMKIND_32BIT                   0x00000002
    677 /** 64-bit symbol. */
    678 #define KLDRSYMKIND_64BIT                   0x00000003
    679 /** Mask out the bit.*/
    680 #define KLDRSYMKIND_BIT_MASK                0x00000003
    681 /** We don't know the type of symbol. */
    682 #define KLDRSYMKIND_NO_TYPE                 0x00000000
    683 /** The symbol is a code object (method/function/procedure/whateveryouwannacallit). */
    684 #define KLDRSYMKIND_CODE                    0x00000010
    685 /** The symbol is a data object. */
    686 #define KLDRSYMKIND_DATA                    0x00000020
    687 /** Mask out the symbol type. */
    688 #define KLDRSYMKIND_TYPE_MASK               0x00000030
    689 /** Valid symbol kind mask. */
    690 #define KLDRSYMKIND_MASK                    0x00000033
    691 /** Weak symbol. */
    692 #define KLDRSYMKIND_WEAK                    0x00000100
    693 /** Forwarder symbol. */
    694 #define KLDRSYMKIND_FORWARDER               0x00000200
    695 /** Request a flat symbol address. */
    696 #define KLDRSYMKIND_REQ_FLAT                0x00000000
    697 /** Request a segmented symbol address. */
    698 #define KLDRSYMKIND_REQ_SEGMENTED           0x40000000
    699 /** Request type mask. */
    700 #define KLDRSYMKIND_REQ_TYPE_MASK           0x40000000
    701 /** @} */
    702 
    703 /** @name kLdrModEnumSymbols flags.
    704  * @{ */
    705 /** Returns ALL kinds of symbols. The default is to only return public/exported symbols. */
    706 #define KLDRMOD_ENUM_SYMS_FLAGS_ALL         0x00000001
    707 /** @} */
    708 
    709 
    710 /**
    711  * Callback for resolving imported symbols when applying fixups.
    712  *
    713  * @returns 0 on success and *pValue and *pfKind filled.
    714  * @returns Non-zero OS specific or kLdr status code on failure.
    715  *
    716  * @param   pMod        The module which fixups are begin applied.
    717  * @param   iImport     The import module ordinal number or NIL_KLDRMOD_IMPORT.
    718  * @param   iSymbol     The symbol ordinal number or NIL_KLDRMOD_SYM_ORDINAL.
    719  * @param   pchSymbol   The symbol name. Can be NULL if iSymbol isn't nil. Doesn't have to be null-terminated.
    720  * @param   cchSymbol   The length of the symbol.
    721  * @param   pszVersion  The symbol version. NULL if not versioned.
    722  * @param   puValue     Where to store the symbol value.
    723  * @param   pfKind      Where to store the symbol kind flags.
    724  * @param   pvUser      The user parameter specified to the relocation function.
    725  */
    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);
    728 /** Pointer to a import callback. */
    729 typedef FNKLDRMODGETIMPORT *PFNKLDRMODGETIMPORT;
    730 
    731 /**
    732  * Symbol enumerator callback.
    733  *
    734  * @returns 0 if enumeration should continue.
    735  * @returns non-zero if the enumeration should stop. This status code will then be returned by kLdrModEnumSymbols().
    736  *
    737  * @param   pMod        The module which symbols are being enumerated.s
    738  * @param   iSymbol     The symbol ordinal number or NIL_KLDRMOD_SYM_ORDINAL.
    739  * @param   pchSymbol   The symbol name. This can be NULL if there is a symbol ordinal.
    740  *                      This can also be an empty string if the symbol doesn't have a name
    741  *                      or it's name has been stripped.
    742  *                      Important, this doesn't have to be a null-terminated string.
    743  * @param   cchSymbol   The length of the symbol.
    744  * @param   pszVersion  The symbol version. NULL if not versioned.
    745  * @param   uValue      The symbol value.
    746  * @param   fKind       The symbol kind flags.
    747  * @param   pvUser      The user parameter specified to kLdrModEnumSymbols().
    748  */
    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);
    751 /** Pointer to a symbol enumerator callback. */
    752 typedef FNKLDRMODENUMSYMS *PFNKLDRMODENUMSYMS;
    753 
    754 /**
    755  * Debug info enumerator callback.
    756  *
    757  * @returns 0 to continue the enumeration.
    758  * @returns non-zero if the enumeration should stop. This status code will then be returned by kLdrModEnumDbgInfo().
    759  *
    760  * @param   pMod        The module.
    761  * @param   iDbgInfo    The debug info ordinal number / id.
    762  * @param   enmType     The debug info type.
    763  * @param   iMajorVer   The major version number of the debug info format. -1 if unknow - implies invalid iMinorVer.
    764  * @param   iMinorVer   The minor version number of the debug info format. -1 when iMajorVer is -1.
    765  * @param   offFile     The file offset *if* this type has one specific location in the executable image file.
    766  *                      This is -1 if there isn't any specific file location.
    767  * @param   LinkAddress The link address of the debug info if it's loadable. NIL_KLDRADDR if not loadable.
    768  * @param   cb          The size of the debug information. -1 is used if this isn't applicable.
    769  * @param   pszExtFile  This points to the name of an external file containing the debug info.
    770  *                      This is NULL if there isn't any external file.
    771  * @param   pvUser      The user parameter specified to kLdrModEnumDbgInfo.
    772  */
    773 typedef int FNKLDRENUMDBG(PKLDRMOD pMod, uint32_t iDbgInfo, KLDRDBGINFOTYPE enmType, int16_t iMajorVer, int16_t iMinorVer,
    774                           KLDRFOFF offFile, KLDRADDR LinkAddress, KLDRSIZE cb, const char *pszExtFile, void *pvUser);
    775 /** Pointer to a debug info enumerator callback. */
    776 typedef FNKLDRENUMDBG *PFNKLDRENUMDBG;
    777 
    778 /**
    779  * Resource enumerator callback.
    780  *
    781  * @returns 0 to continue the enumeration.
    782  * @returns non-zero if the enumeration should stop. This status code will then be returned by kLdrModEnumResources().
    783  *
    784  * @param   pMod        The module.
    785  * @param   idType      The resource type id. NIL_KLDRMOD_RSRC_TYPE_ID if no type id.
    786  * @param   pszType     The resource type name. NULL if no type name.
    787  * @param   idName      The resource id. NIL_KLDRMOD_RSRC_NAME_ID if no id.
    788  * @param   pszName     The resource name. NULL if no name.
    789  * @param   idLang      The language id.
    790  * @param   AddrRsrc    The address value for the resource.
    791  * @param   cbRsrc      The size of the resource.
    792  * @param   pvUser      The user parameter specified to kLdrModEnumDbgInfo.
    793  */
    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);
    796 /** Pointer to a resource enumerator callback. */
    797 typedef FNKLDRENUMRSRC *PFNKLDRENUMRSRC;
    798 
    799 /** NIL resource name ID. */
    800 #define NIL_KLDRMOD_RSRC_NAME_ID    ( ~(uint32_t)0 )
    801 /** NIL resource type ID. */
    802 #define NIL_KLDRMOD_RSRC_TYPE_ID    ( ~(uint32_t)0 )
    803 /** @name Language ID
    804  *
    805  * Except for the special IDs #defined here, the values are considered
    806  * format specific for now since it's only used by the PE resources.
    807  *
    808  * @{ */
    809 /** NIL language ID. */
    810 #define NIL_KLDR_LANG_ID                ( ~(uint32_t)0 )
    811 /** Special language id value for matching any language. */
    812 #define KLDR_LANG_ID_ANY                ( ~(uint32_t)1 )
    813 /** Special language id value indicating language neutral. */
    814 #define KLDR_LANG_ID_NEUTRAL            ( ~(uint32_t)2 )
    815 /** Special language id value indicating user default language. */
    816 #define KLDR_LANG_ID_USER_DEFAULT       ( ~(uint32_t)3 )
    817 /** Special language id value indicating system default language. */
    818 #define KLDR_LANG_ID_SYS_DEFAULT        ( ~(uint32_t)4 )
    819 /** Special language id value indicating default custom locale. */
    820 #define KLDR_LANG_ID_CUSTOM_DEFAULT     ( ~(uint32_t)5 )
    821 /** Special language id value indicating unspecified custom locale. */
    822 #define KLDR_LANG_ID_CUSTOM_UNSPECIFIED ( ~(uint32_t)6 )
    823 /** Special language id value indicating default custom MUI locale. */
    824 #define KLDR_LANG_ID_UI_CUSTOM_DEFAULT  ( ~(uint32_t)7 )
    825 /** @} */
    826 
    827 
    828 int     kLdrModOpen(const char *pszFilename, PPKLDRMOD ppMod);
    829 int     kLdrModOpenFromRdr(PKLDRRDR pRdr, PPKLDRMOD ppMod);
    830 int     kLdrModOpenNative(const char *pszFilename, PPKLDRMOD ppMod);
    831 int     kLdrModOpenNativeByHandle(uintptr_t uHandle, PPKLDRMOD ppMod);
    832 int     kLdrModClose(PKLDRMOD pMod);
    833 
    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);
    837 int     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);
    841 int     kLdrModCanExecuteOn(PKLDRMOD pMod, const void *pvBits, KLDRARCH enmArch, KLDRCPU enmCpu);
    842 int     kLdrModGetStackInfo(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, PKLDRSTACKINFO pStackInfo);
    843 int     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);
    848 int     kLdrModEnumDbgInfo(PKLDRMOD pMod, const void *pvBits, PFNKLDRENUMDBG pfnCallback, void *pvUser);
    849 int     kLdrModHasDbgInfo(PKLDRMOD pMod, const void *pvBits);
    850 int     kLdrModMostlyDone(PKLDRMOD pMod);
    851 
    852 
    853 /** @name Operations On The Internally Managed Mapping
    854  * @{ */
    855 int     kLdrModMap(PKLDRMOD pMod);
    856 int     kLdrModUnmap(PKLDRMOD pMod);
    857 int     kLdrModAllocTLS(PKLDRMOD pMod);
    858 void    kLdrModFreeTLS(PKLDRMOD pMod);
    859 int     kLdrModReload(PKLDRMOD pMod);
    860 int     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);
    864 /** @} */
    865 
    866 /** @name Operations On The Externally Managed Mappings
    867  * @{ */
    868 KLDRADDR kLdrModSize(PKLDRMOD pMod);
    869 int     kLdrModGetBits(PKLDRMOD pMod, void *pvBits, KLDRADDR BaseAddress, PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
    870 int     kLdrModRelocateBits(PKLDRMOD pMod, void *pvBits, KLDRADDR NewBaseAddress, KLDRADDR OldBaseAddress,
    871                             PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
    872 /** @} */
    873 
    874 
    875 /**
    876  * The loader module operation.
    877  */
    878 typedef struct KLDRMODOPS
    879 {
    880     /** The name of this module interpreter. */
    881     const char         *pszName;
    882     /** Pointer to the next module interpreter. */
    883     PCKLDRMODOPS        pNext;
    884 
    885     /**
    886      * Create a loader module instance interpreting the executable image found
    887      * in the specified file provider instance.
    888      *
    889      * @returns 0 on success and *ppMod pointing to a module instance.
    890      *          On failure, a non-zero OS specific error code is returned.
    891      * @param   pOps            Pointer to the registered method table.
    892      * @param   pRdr            The file provider instance to use.
    893      * @param   offNewHdr       The offset of the new header in MZ files. -1 if not found.
    894      * @param   ppMod           Where to store the module instance pointer.
    895      */
    896     int (* pfnCreate)(PCKLDRMODOPS pOps, PKLDRRDR pRdr, KLDRFOFF offNewHdr, PPKLDRMOD ppMod);
    897     /**
    898      * Destroys an loader module instance.
    899      *
    900      * The caller is responsible for calling kLdrModUnmap() and kLdrFreeTLS() first.
    901      *
    902      * @returns 0 on success, non-zero on failure. The module instance state
    903      *          is unknown on failure, it's best not to touch it.
    904      * @param   pMod    The module.
    905      */
    906     int (* pfnDestroy)(PKLDRMOD pMod);
    907 
    908     /** @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);
    912     /** @copydoc kLdrModEnumSymbols */
    913     int (* pfnEnumSymbols)(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, uint32_t fFlags,
    914                            PFNKLDRMODENUMSYMS pfnCallback, void *pvUser);
    915     /** @copydoc kLdrModGetImport */
    916     int (* pfnGetImport)(PKLDRMOD pMod, const void *pvBits, uint32_t iImport, char *pszName, size_t cchName);
    917     /** @copydoc kLdrModNumberOfImports */
    918     int32_t (* pfnNumberOfImports)(PKLDRMOD pMod, const void *pvBits);
    919     /** @copydoc kLdrModCanExecuteOn */
    920     int (* pfnCanExecuteOn)(PKLDRMOD pMod, const void *pvBits, KLDRARCH enmArch, KLDRCPU enmCpu);
    921     /** @copydoc kLdrModGetStackInfo */
    922     int (* pfnGetStackInfo)(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, PKLDRSTACKINFO pStackInfo);
    923     /** @copydoc kLdrModQueryMainEntrypoint */
    924     int (* pfnQueryMainEntrypoint)(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, PKLDRADDR pMainEPAddress);
    925     /** @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);
    928     /** @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);
    931     /** @copydoc kLdrModEnumDbgInfo */
    932     int (* pfnEnumDbgInfo)(PKLDRMOD pMod, const void *pvBits, PFNKLDRENUMDBG pfnCallback, void *pvUser);
    933     /** @copydoc kLdrModHasDbgInfo */
    934     int (* pfnHasDbgInfo)(PKLDRMOD pMod, const void *pvBits);
    935     /** @copydoc kLdrModMap */
    936     int (* pfnMap)(PKLDRMOD pMod);
    937     /** @copydoc kLdrModUnmap */
    938     int (* pfnUnmap)(PKLDRMOD pMod);
    939     /** @copydoc kLdrModAllocTLS */
    940     int (* pfnAllocTLS)(PKLDRMOD pMod);
    941     /** @copydoc kLdrModFreeTLS */
    942     void (* pfnFreeTLS)(PKLDRMOD pMod);
    943     /** @copydoc kLdrModReload */
    944     int (* pfnReload)(PKLDRMOD pMod);
    945     /** @copydoc kLdrModFixupMapping */
    946     int (* pfnFixupMapping)(PKLDRMOD pMod, PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
    947     /** @copydoc kLdrModCallInit */
    948     int (* pfnCallInit)(PKLDRMOD pMod, uintptr_t uHandle);
    949     /** @copydoc kLdrModCallTerm */
    950     int (* pfnCallTerm)(PKLDRMOD pMod, uintptr_t uHandle);
    951     /** @copydoc kLdrModCallThread */
    952     int (* pfnCallThread)(PKLDRMOD pMod, uintptr_t uHandle, unsigned fAttachingOrDetaching);
    953     /** @copydoc kLdrModSize */
    954     KLDRADDR (* pfnSize)(PKLDRMOD pMod);
    955     /** @copydoc kLdrModGetBits */
    956     int (* pfnGetBits)(PKLDRMOD pMod, void *pvBits, KLDRADDR BaseAddress, PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
    957     /** @copydoc kLdrModRelocateBits */
    958     int (* pfnRelocateBits)(PKLDRMOD pMod, void *pvBits, KLDRADDR NewBaseAddress, KLDRADDR OldBaseAddress,
    959                             PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
    960     /** @copydoc kLdrModMostlyDone */
    961     int (* pfnMostlyDone)(PKLDRMOD pMod);
    962     /** Dummy which should be assigned a non-zero value. */
    963     uint32_t uEndOfStructure;
    964 } KLDRMODOPS;
    965 
    966 
    967 /** @} */
    968 
    969 
    970 
    971 
    972 /** @defgroup grp_kLdrDyld   kLdrDyld - The dynamic loader
    973  * @{ */
    974 
    975 /** The handle to a dynamic loader module. */
    976 typedef struct KLDRDYLDMOD *HKLDRMOD;
    977 /** Pointer to the handle to a dynamic loader module. */
    978 typedef HKLDRMOD *PHKLDRMOD;
    979 /** NIL handle value. */
    980 #define NIL_HKLDRMOD    ((HKLDRMOD)0)
    981 
    982 
    983 /**
    984  * File search method.
    985  *
    986  * In addition to it's own way of finding files, kLdr emulates
    987  * the methods employed by the most popular systems.
    988  */
    989 typedef enum KLDRDYLDSEARCH
    990 {
    991     /** The usual invalid file search method. */
    992     KLDRDYLD_SEARCH_INVALID = 0,
    993     /** Uses the kLdr file search method.
    994      * @todo invent me. */
    995     KLDRDYLD_SEARCH_KLDR,
    996     /** Use the emulation closest to the host system. */
    997     KLDRDYLD_SEARCH_HOST,
    998     /** Emulate the OS/2 file search method.
    999      * On non-OS/2 systems, BEGINLIBPATH, LIBPATH, ENDLIBPATH and LIBPATHSTRICT are
    1000      * taken form the environment. */
    1001     KLDRDYLD_SEARCH_OS2,
    1002     /** Emulate the standard window file search method. */
    1003     KLDRDYLD_SEARCH_WINDOWS,
    1004     /** Emulate the alternative window file search method. */
    1005     KLDRDYLD_SEARCH_WINDOWS_ALTERED,
    1006     /** Emulate the most common UNIX file search method. */
    1007     KLDRDYLD_SEARCH_UNIX_COMMON,
    1008     /** End of the valid file search method values. */
    1009     KLDRDYLD_SEARCH_END,
    1010     /** Hack to blow the type up to 32-bit. */
    1011     KLDRDYLD_SEARCH_32BIT_HACK = 0x7fffffff
    1012 } KLDRDYLDSEARCH;
    1013 
    1014 /** @name kLdrDyldLoad and kLdrDyldFindByName flags.
    1015  * @{ */
    1016 /** The symbols in the module should be loaded into the global unix namespace.
    1017  * If not specified, the symbols are local and can only be referenced directly. */
    1018 #define KLDRYDLD_LOAD_FLAGS_GLOBAL_SYMBOLS      0x00000001
    1019 /** The symbols in the module should be loaded into the global unix namespace and
    1020  * it's symbols should take precedence over all currently loaded modules.
    1021  * This implies KLDRYDLD_LOAD_FLAGS_GLOBAL_SYMBOLS. */
    1022 #define KLDRYDLD_LOAD_FLAGS_DEEP_SYMBOLS        0x00000002
    1023 /** The module shouldn't be found by a global module search.
    1024  * If not specified, the module can be found by unspecified module searches,
    1025  * typical used when loading import/dep modules. */
    1026 #define KLDRYDLD_LOAD_FLAGS_SPECIFIC_MODULE     0x00000004
    1027 /** Do a recursive initialization calls instead of defering them to the outermost call. */
    1028 #define KLDRDYLD_LOAD_FLAGS_RECURSIVE_INIT      0x00000008
    1029 /** We're loading the executable module.
    1030  * @internal */
    1031 #define KLDRDYLD_LOAD_FLAGS_EXECUTABLE          0x40000000
    1032 /** @} */
    1033 
    1034 
    1035 int     kLdrDyldLoad(const char *pszDll, const char *pszPrefix, const char *pszSuffix, KLDRDYLDSEARCH enmSearch,
    1036                      unsigned fFlags, PHKLDRMOD phMod, char *pszErr, size_t cchErr);
    1037 int     kLdrDyldUnload(HKLDRMOD hMod);
    1038 int     kLdrDyldFindByName(const char *pszDll, const char *pszPrefix, const char *pszSuffix, KLDRDYLDSEARCH enmSearch,
    1039                            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);
    1049 
    1050 /** @name OS/2 like API
    1051  * @{ */
    1052 #if defined(__OS2__)
    1053 # define KLDROS2API _System
    1054 #else
    1055 # define KLDROS2API
    1056 #endif
    1057 int     kLdrDosLoadModule(char *pszObject, size_t cbObject, const char *pszModule, PHKLDRMOD phMod);
    1058 int     kLdrDosFreeModule(HKLDRMOD hMod);
    1059 int     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);
    1064 int     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);
    1067 int     kLdrDosFreeResource(void *pvResAddr);
    1068 /** @} */
    1069 
    1070 /** @name POSIX like API
    1071  * @{ */
    1072 HKLDRMOD    kLdrDlOpen(const char *pszLibrary, int fFlags);
    1073 const char *kLdrDlError(void);
    1074 void *      kLdrDlSym(HKLDRMOD hMod, const char *pszSymbol);
    1075 int         kLdrDlClose(HKLDRMOD hMod);
    1076 /** @todo GNU extensions */
    1077 /** @} */
    1078 
    1079 /** @name Win32 like API
    1080  * @{ */
    1081 #if defined(_MSC_VER)
    1082 # define KLDRWINAPI __stdcall
    1083 #else
    1084 # define KLDRWINAPI
    1085 #endif
    1086 HKLDRMOD 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);
    1089 HKLDRMOD KLDRWINAPI kLdrWGetModuleHandle(const char *pszFilename);
    1090 int      KLDRWINAPI kLdrWGetModuleHandleEx(uint32_t fFlags, const char *pszFilename, HKLDRMOD hMod);
    1091 void *   KLDRWINAPI kLdrWGetProcAddress(HKLDRMOD hMod, const char *pszProcName);
    1092 uint32_t KLDRWINAPI kLdrWGetDllDirectory(size_t cchDir, char *pszDir);
    1093 int      KLDRWINAPI kLdrWSetDllDirectory(const char *pszDir);
    1094 int      KLDRWINAPI kLdrWFreeLibrary(HKLDRMOD hMod);
    1095 int      KLDRWINAPI kLdrWDisableThreadLibraryCalls(HKLDRMOD hMod);
    1096 
    1097 /** The handle to a resource that's been found. */
    1098 typedef struct KLDRWRSRCFOUND *HKLDRWRSRCFOUND;
    1099 /** The handle to a loaded resource. */
    1100 typedef struct KLDRWRSRCLOADED *HKLDRWRSRCLOADED;
    1101 HKLDRWRSRCFOUND  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);
    1104 HKLDRWRSRCLOADED KLDRWINAPI kLdrWLoadResource(HKLDRMOD hMod, HKLDRWRSRCFOUND hFoundRsrc);
    1105 void    *KLDRWINAPI kLdrWLockResource(HKLDRMOD hMod, HKLDRWRSRCLOADED hLoadedRsrc);
    1106 int      KLDRWINAPI kLdrWFreeResource(HKLDRMOD hMod, HKLDRWRSRCLOADED hLoadedRsrc);
    1107 
    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);
    1118 int      KLDRWINAPI kLdrWEnumResourceLanguagesEx(HKLDRMOD hMod, const char *pszType, const char *pszName,
    1119                                                  PFNKLDRWENUMRESLANG pfnEnum, uintptr_t uUser, uint32_t fFlags, uint16_t idLang);
    1120 /** @} */
    1121 
    1122 
    1123 /** @name Process Bootstrapping
    1124  * @{ */
    1125 
    1126 /**
    1127  * Argument package from the stub.
    1128  */
    1129 typedef struct KLDREXEARGS
    1130 {
    1131     /** Load & search flags, some which will become defaults. */
    1132     uint32_t        fFlags;
    1133     /** The default search method. */
    1134     KLDRDYLDSEARCH  enmSearch;
    1135     /** The executable file that the stub is supposed to load. */
    1136     char            szExecutable[260];
    1137     /** The default prefix used when searching for DLLs. */
    1138     char            szDefPrefix[16];
    1139     /** The default suffix used when searching for DLLs. */
    1140     char            szDefSuffix[16];
    1141     /** The LD_LIBRARY_PATH prefix for the process.. */
    1142     char            szLibPath[4096 - sizeof(uint32_t) - sizeof(KLDRDYLDSEARCH) - 16 - 16 - 260];
    1143 } KLDREXEARGS, *PKLDREXEARGS;
    1144 /** Pointer to a const argument package from the stub. */
    1145 typedef const KLDREXEARGS *PCKLDREXEARGS;
    1146 
    1147 void kLdrLoadExe(PCKLDREXEARGS pArgs, void *pvOS);
    1148 
    1149 /** @} */
    1150 
    1151 /** @} */
    1152 
    1153 
    1154 /** @defgroup grp_kLdrErr   kLdr Status Codes
    1155  * kLdr uses a mix of native status codes and it's own status codes.
    1156  * A status code of 0 means success, all other status codes means failure.
    1157  * @{
    1158  */
    1159 
    1160 #define KLDR_ERR_BASE                                       420000
    1161 
    1162 /** The image format is unknown. */
    1163 #define KLDR_ERR_UNKNOWN_FORMAT                             (KLDR_ERR_BASE + 0)
    1164 /** The MZ image format isn't supported by this kLdr build. */
    1165 #define KLDR_ERR_MZ_NOT_SUPPORTED                           (KLDR_ERR_BASE + 1)
    1166 /** The NE image format isn't supported by this kLdr build. */
    1167 #define KLDR_ERR_NE_NOT_SUPPORTED                           (KLDR_ERR_BASE + 2)
    1168 /** The LX image format isn't supported by this kLdr build. */
    1169 #define KLDR_ERR_LX_NOT_SUPPORTED                           (KLDR_ERR_BASE + 3)
    1170 /** The LE image format isn't supported by this kLdr build. */
    1171 #define KLDR_ERR_LE_NOT_SUPPORTED                           (KLDR_ERR_BASE + 4)
    1172 /** The PE image format isn't supported by this kLdr build. */
    1173 #define KLDR_ERR_PE_NOT_SUPPORTED                           (KLDR_ERR_BASE + 5)
    1174 /** The ELF image format isn't supported by this kLdr build. */
    1175 #define KLDR_ERR_ELF_NOT_SUPPORTED                          (KLDR_ERR_BASE + 6)
    1176 /** The mach-o image format isn't supported by this kLdr build. */
    1177 #define KLDR_ERR_MACHO_NOT_SUPPORTED                        (KLDR_ERR_BASE + 7)
    1178 /** The FAT image format isn't supported by this kLdr build or
    1179  * a direct open was attempt without going thru the FAT file provider.
    1180  * FAT images are also known as Universal Binaries. */
    1181 #define KLDR_ERR_FAT_NOT_SUPPORTED                          (KLDR_ERR_BASE + 8)
    1182 /** The a.out image format isn't supported by this kLdr build. */
    1183 #define KLDR_ERR_AOUT_NOT_SUPPORTED                         (KLDR_ERR_BASE + 9)
    1184 
    1185 /** Invalid parameter to a kLdr API. */
    1186 #define KLDR_ERR_INVALID_PARAMETER                          (KLDR_ERR_BASE + 32)
    1187 /** Invalid handle parameter to a kLdr API. */
    1188 #define KLDR_ERR_INVALID_HANDLE                             (KLDR_ERR_BASE + 33)
    1189 /** The module wasn't loaded dynamically. */
    1190 #define KLDR_ERR_NOT_LOADED_DYNAMICALLY                     (KLDR_ERR_BASE + 34)
    1191 /** The module wasn't found. */
    1192 #define KLDR_ERR_MODULE_NOT_FOUND                           (KLDR_ERR_BASE + 35)
    1193 /** A prerequisit module wasn't found. */
    1194 #define KLDR_ERR_PREREQUISITE_MODULE_NOT_FOUND              (KLDR_ERR_BASE + 36)
    1195 /** The module is being terminated and can therefore not be loaded. */
    1196 #define KLDR_ERR_MODULE_TERMINATING                         (KLDR_ERR_BASE + 37)
    1197 /** A prerequisit module is being terminated and can therefore not be loaded. */
    1198 #define KLDR_ERR_PREREQUISITE_MODULE_TERMINATING            (KLDR_ERR_BASE + 38)
    1199 /** The module initialization failed. */
    1200 #define KLDR_ERR_MODULE_INIT_FAILED                         (KLDR_ERR_BASE + 39)
    1201 /** The initialization of a prerequisite module failed. */
    1202 #define KLDR_ERR_PREREQUISITE_MODULE_INIT_FAILED            (KLDR_ERR_BASE + 40)
    1203 /** The module has already failed initialization and can't be attempted reloaded until
    1204  * after we've finished garbage collection. */
    1205 #define KLDR_ERR_MODULE_INIT_FAILED_ALREADY                 (KLDR_ERR_BASE + 41)
    1206 /** A prerequisite module has already failed initialization and can't be attempted
    1207  * reloaded until after we've finished garbage collection. */
    1208 #define KLDR_ERR_PREREQUISITE_MODULE_INIT_FAILED_ALREADY    (KLDR_ERR_BASE + 42)
    1209 /** Prerequisite recursed too deeply. */
    1210 #define KLDR_ERR_PREREQUISITE_RECURSED_TOO_DEEPLY           (KLDR_ERR_BASE + 43)
    1211 /** Failed to allocate the main stack. */
    1212 #define KLDR_ERR_MAIN_STACK_ALLOC_FAILED                    (KLDR_ERR_BASE + 44)
    1213 /** Buffer overflow. */
    1214 #define KLDR_ERR_BUFFER_OVERFLOW                            (KLDR_ERR_BASE + 45)
    1215 /** The specified ARCH+CPU isn't compatible with image. */
    1216 #define KLDR_ERR_ARCH_CPU_NOT_COMPATIBLE                    (KLDR_ERR_BASE + 46)
    1217 /** Symbol not found. */
    1218 #define KLDR_ERR_SYMBOL_NOT_FOUND                           (KLDR_ERR_BASE + 47)
    1219 /** A forward symbol was encountered but the caller didn't provide any means to resolve it. */
    1220 #define KLDR_ERR_FORWARDER_SYMBOL                           (KLDR_ERR_BASE + 48)
    1221 /** Encountered a bad fixup. */
    1222 #define KLDR_ERR_BAD_FIXUP                                  (KLDR_ERR_BASE + 49)
    1223 /** A memory allocation failed. */
    1224 #define KLDR_ERR_NO_MEMORY                                  (KLDR_ERR_BASE + 50)
    1225 /** The import ordinal was out of bounds. */
    1226 #define KLDR_ERR_IMPORT_ORDINAL_OUT_OF_BOUNDS               (KLDR_ERR_BASE + 51)
    1227 /** A forwarder chain was too long. */
    1228 #define KLDR_ERR_TOO_LONG_FORWARDER_CHAIN                   (KLDR_ERR_BASE + 52)
    1229 /** The module has no debug info. */
    1230 #define KLDR_ERR_NO_DEBUG_INFO                              (KLDR_ERR_BASE + 53)
    1231 /** The module is already mapped.
    1232  * kLdrModMap() can only be called once (without kLdrModUnmap() in between). */
    1233 #define KLDR_ERR_ALREADY_MAPPED                             (KLDR_ERR_BASE + 54)
    1234 /** The module was not mapped.
    1235  * kLdrModUnmap() should not called without being preceeded by a kLdrModMap(). */
    1236 #define KLDR_ERR_NOT_MAPPED                                 (KLDR_ERR_BASE + 55)
    1237 /** Couldn't fit the address value into the field. Typically a relocation kind of error. */
    1238 #define KLDR_ERR_ADDRESS_OVERFLOW                           (KLDR_ERR_BASE + 56)
    1239 /** Couldn't fit a calculated size value into the native size type of the host. */
    1240 #define KLDR_ERR_SIZE_OVERFLOW                              (KLDR_ERR_BASE + 57)
    1241 /** Thread attach failed. */
    1242 #define KLDR_ERR_THREAD_ATTACH_FAILED                       (KLDR_ERR_BASE + 58)
    1243 /** The file reader can't take more concurrent mappings. */
    1244 #define KLDR_ERR_TOO_MANY_MAPPINGS                          (KLDR_ERR_BASE + 59)
    1245 /** The module wasn't a DLL or object file. */
    1246 #define KLDR_ERR_NOT_DLL                                    (KLDR_ERR_BASE + 60)
    1247 /** The module wasn't an EXE. */
    1248 #define KLDR_ERR_NOT_EXE                                    (KLDR_ERR_BASE + 61)
    1249 /** Not implemented yet. */
    1250 #define KLDR_ERR_TODO                                       (KLDR_ERR_BASE + 62)
    1251 
    1252 
    1253 /** @name kLdrModPE status codes
    1254  * @{ */
    1255 #define KLDR_ERR_PE_BASE                                    (KLDR_ERR_BASE + 63)
    1256 /** The machine isn't supported by the interpreter. */
    1257 #define KLDR_ERR_PE_UNSUPPORTED_MACHINE                     (KLDR_ERR_PE_BASE + 0)
    1258 /** The file handler isn't valid. */
    1259 #define KLDR_ERR_PE_BAD_FILE_HEADER                         (KLDR_ERR_PE_BASE + 1)
    1260 /** The the optional headers isn't valid. */
    1261 #define KLDR_ERR_PE_BAD_OPTIONAL_HEADER                     (KLDR_ERR_PE_BASE + 2)
    1262 /** One of the section headers aren't valid. */
    1263 #define KLDR_ERR_PE_BAD_SECTION_HEADER                      (KLDR_ERR_PE_BASE + 3)
    1264 /** Bad forwarder entry. */
    1265 #define KLDR_ERR_PE_BAD_FORWARDER                           (KLDR_ERR_PE_BASE + 4)
    1266 /** Forwarder module not found in the import descriptor table. */
    1267 #define KLDR_ERR_PE_FORWARDER_IMPORT_NOT_FOUND              (KLDR_ERR_PE_BASE + 5)
    1268 /** Bad PE fixups. */
    1269 #define KLDR_ERR_PE_BAD_FIXUP                               (KLDR_ERR_PE_BASE + 6)
    1270 /** Bad PE import (thunk). */
    1271 #define KLDR_ERR_PE_BAD_IMPORT                              (KLDR_ERR_PE_BASE + 7)
    1272 /** @} */
    1273 
    1274 /** @name kLdrModLX status codes
    1275  * @{ */
    1276 #define KLDR_ERR_LX_BASE                                    (KLDR_ERR_PE_BASE + 8)
    1277 /** validation of LX header failed. */
    1278 #define KLDR_ERR_LX_BAD_HEADER                              (KLDR_ERR_LX_BASE + 0)
    1279 /** validation of the loader section (in the LX header) failed. */
    1280 #define KLDR_ERR_LX_BAD_LOADER_SECTION                      (KLDR_ERR_LX_BASE + 1)
    1281 /** validation of the fixup section (in the LX header) failed. */
    1282 #define KLDR_ERR_LX_BAD_FIXUP_SECTION                       (KLDR_ERR_LX_BASE + 2)
    1283 /** validation of the LX object table failed. */
    1284 #define KLDR_ERR_LX_BAD_OBJECT_TABLE                        (KLDR_ERR_LX_BASE + 3)
    1285 /** A bad page map entry was encountered. */
    1286 #define KLDR_ERR_LX_BAD_PAGE_MAP                            (KLDR_ERR_LX_BASE + 4)
    1287 /** Bad iterdata (EXEPACK) data. */
    1288 #define KLDR_ERR_LX_BAD_ITERDATA                            (KLDR_ERR_LX_BASE + 5)
    1289 /** Bad iterdata2 (EXEPACK2) data. */
    1290 #define KLDR_ERR_LX_BAD_ITERDATA2                           (KLDR_ERR_LX_BASE + 6)
    1291 /** Bad bundle data. */
    1292 #define KLDR_ERR_LX_BAD_BUNDLE                              (KLDR_ERR_LX_BASE + 7)
    1293 /** No soname. */
    1294 #define KLDR_ERR_LX_NO_SONAME                               (KLDR_ERR_LX_BASE + 8)
    1295 /** Bad soname. */
    1296 #define KLDR_ERR_LX_BAD_SONAME                              (KLDR_ERR_LX_BASE + 9)
    1297 /** Bad forwarder entry. */
    1298 #define KLDR_ERR_LX_BAD_FORWARDER                           (KLDR_ERR_LX_BASE + 10)
    1299 /** internal fixup chain isn't implemented yet. */
    1300 #define KLDR_ERR_LX_NRICHAIN_NOT_SUPPORTED                  (KLDR_ERR_LX_BASE + 11)
    1301 /** @} */
    1302 
    1303 /** @name
    1304  * @{ */
    1305 #define KLDR_ERR_MACHO_BASE                                 (KLDR_ERR_LX_BASE + 12)
    1306 /** Only native endian Mach-O files are supported. */
    1307 #define KLDR_ERR_MACHO_OTHER_ENDIAN_NOT_SUPPORTED           (KLDR_ERR_MACHO_BASE + 0)
    1308 /** 64-bit Mach-O files aren't supported yet. */
    1309 #define KLDR_ERR_MACHO_64BIT_NOT_SUPPORTED                  (KLDR_ERR_MACHO_BASE + 1)
    1310 /** The Mach-O header is bad or contains new and unsupported features. */
    1311 #define KLDR_ERR_MACHO_BAD_HEADER                           (KLDR_ERR_MACHO_BASE + 2)
    1312 /** The file type isn't supported. */
    1313 #define KLDR_ERR_MACHO_UNSUPPORTED_FILE_TYPE                (KLDR_ERR_MACHO_BASE + 3)
    1314 /** The machine (cputype / cpusubtype combination) isn't supported. */
    1315 #define KLDR_ERR_MACHO_UNSUPPORTED_MACHINE                  (KLDR_ERR_MACHO_BASE + 4)
    1316 /** Bad load command(s). */
    1317 #define KLDR_ERR_MACHO_BAD_LOAD_COMMAND                     (KLDR_ERR_MACHO_BASE + 5)
    1318 /** Encountered an unknown load command.*/
    1319 #define KLDR_ERR_MACHO_UNKNOWN_LOAD_COMMAND                 (KLDR_ERR_MACHO_BASE + 6)
    1320 /** Encountered a load command that's not implemented.*/
    1321 #define KLDR_ERR_MACHO_UNSUPPORTED_LOAD_COMMAND             (KLDR_ERR_MACHO_BASE + 7)
    1322 /** Bad section. */
    1323 #define KLDR_ERR_MACHO_BAD_SECTION                          (KLDR_ERR_MACHO_BASE + 8)
    1324 /** Encountered a section type that's not implemented.*/
    1325 #define KLDR_ERR_MACHO_UNSUPPORTED_SECTION                  (KLDR_ERR_MACHO_BASE + 9)
    1326 /** Encountered a section type that's not known to the loader. (probably invalid) */
    1327 #define KLDR_ERR_MACHO_UNKNOWN_SECTION                      (KLDR_ERR_MACHO_BASE + 10)
    1328 /** The sections aren't ordered by segment as expected by the loader. */
    1329 #define KLDR_ERR_MACHO_BAD_SECTION_ORDER                    (KLDR_ERR_MACHO_BASE + 11)
    1330 /** The image is 32-bit and contains 64-bit load commands or vise versa. */
    1331 #define KLDR_ERR_MACHO_BIT_MIX                              (KLDR_ERR_MACHO_BASE + 12)
    1332 /** Bad MH_OBJECT file. */
    1333 #define KLDR_ERR_MACHO_BAD_OBJECT_FILE                      (KLDR_ERR_MACHO_BASE + 13)
    1334 /** Bad symbol table entry. */
    1335 #define KLDR_ERR_MACHO_BAD_SYMBOL                           (KLDR_ERR_MACHO_BASE + 14)
    1336 /** Unsupported fixup type. */
    1337 #define KLDR_ERR_MACHO_UNSUPPORTED_FIXUP_TYPE               (KLDR_ERR_MACHO_BASE + 15)
    1338 /** @} */
    1339 
    1340 /** End of the valid kLdr status codes. */
    1341 #define KLDR_ERR_END                                        (KLDR_ERR_MACHO_BASE + 16)
    1342 
    1343 const char *kLdrErrStr(int rc);
    1344 
    1345 /** @} */
    1346 
    1347143
    1348144#ifdef __cplusplus
Note: See TracChangeset for help on using the changeset viewer.