Changeset 2889

Timestamp:

Nov 20, 2006, 11:27:03 AM (19 years ago)

Author:

bird

Message:

started on fixups.

Location:

trunk/kLdr

Files:

• kLdr.h (modified) (1 diff)
• kLdrModLX.c (modified) (6 diffs)
• kLdrModLX.h (modified) (2 diffs)

trunk/kLdr/kLdr.h

@@ -1089 +1089 @@
 /** Bad forwarder entry. */
 #define KLDR_ERR_LX_BAD_FORWARDER                           (KLDR_ERR_LX_BASE + 10)
+/** internal fixup chain isn't implemented yet. */
+#define KLDR_ERR_LX_NRICHAIN_NOT_SUPPORTED                  (KLDR_ERR_LX_BASE + 11)
 /** @} */
 
 /** End of the valid kLdr status codes. */
-#define KLDR_ERR_END                                        (KLDR_ERR_LX_BASE + 11)
+#define KLDR_ERR_END                                        (KLDR_ERR_LX_BASE + 12)
 
 /** @} */

trunk/kLdr/kLdrModLX.c

@@ -119 +119 @@
 static const uint8_t *kldrModLXDoNameTableLookupByOrdinal(const uint8_t *pbNameTable, int32_t cbNameTable, uint32_t iOrdinal);
 static int kldrModLXDoNameLookup(PKLDRMODLX pModLX, const char *pszSymbol, uint32_t *piSymbol);
+#if 0
 static const uint8_t *kldrModLXDoNameTableLookupByName(const uint8_t *pbNameTable, int32_t cbNameTable,
                                                        char *pchSymbol, size_t cchSymbol);
+#endif
 static int kldrModLXDoLoadBits(PKLDRMODLX pModLX, void *pvBits);
 static int kldrModLXDoIterDataUnpacking(uint8_t *pbDst, const uint8_t *pbSrc, int cbSrc);
@@ -131 +133 @@
 static int kldrModLXDoLoadFixupSection(PKLDRMODLX pModLX);
 static int32_t kldrModLXDoCall(uintptr_t uEntrypoint, uintptr_t uHandle, uint32_t uOp, void *pvReserved);
+static int kldrModLXDoReloc(uint8_t *pbPage, int off, KLDRADDR uValue, uint32_t fKind);
 
 
@@ -668 +671 @@
 
 
+#if 0
 /**
  * Hash a symbol using the algorithm from sdbm.
@@ -738 +742 @@
     return NULL;
 }
+#endif
 
 
@@ -791 +796 @@
         pbName = pModLX->pbImportProcs + pEntry->e32_variant.e32_fwd.value;
         if (    pbName >= pModLX->pbFixupSectionLast
-            ||  pbName < pModLX->pbFixupSectionLast
+            ||  pbName < pModLX->pbFixupSection
             || !*pbName)
             return KLDR_ERR_LX_BAD_FORWARDER;
@@ -1931 +1936 @@
                                  PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser)
 {
-    /*PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
-    int rc;*/
-
-    /** @todo Implement this. */
-
-    return -1;
+    PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
+    uint32_t i;
+    int rc;
+
+    /*
+     * Do we need to to *anything*?
+     */
+    if (    NewBaseAddress == OldBaseAddress
+        &&  NewBaseAddress == pModLX->paObjs[0].o32_base
+        &&  !pModLX->Hdr.e32_impmodcnt)
+        return 0;
+
+    /*
+     * Load the fixup section.
+     */
+    if (!pModLX->pbFixupSection)
+    {
+        rc = kldrModLXDoLoadFixupSection(pModLX);
+        if (rc)
+            return rc;
+    }
+
+    /*
+     * Iterate the segments.
+     */
+    for (i = 0; i < pModLX->Hdr.e32_objcnt; i++)
+    {
+        const struct o32_obj * const pObj = &pModLX->paObjs[i];
+        uint32_t        iPage;
+        uint8_t        *pbPage = (uint8_t *)pvBits + (uintptr_t)pModLX->pMod->aSegments[i].RVA;
+
+        /*
+         * Iterate the page map pages.
+         */
+        for (iPage = 0; !rc && iPage < pObj->o32_mapsize; iPage++, pbPage += OBJPAGELEN)
+        {
+            const uint8_t * const   pbFixupRecEnd = pModLX->pbFixupRecs + pModLX->paoffPageFixups[iPage + pObj->o32_pagemap];
+            const uint8_t          *pb            = pModLX->pbFixupRecs + pModLX->paoffPageFixups[iPage + pObj->o32_pagemap - 1];
+            KLDRADDR                uValue;
+            uint32_t                fKind;
+
+            /* sanity */
+            if (pbFixupRecEnd < pb)
+                return KLDR_ERR_BAD_FIXUP;
+            if (pbFixupRecEnd - 1 > pModLX->pbFixupSectionLast)
+                return KLDR_ERR_BAD_FIXUP;
+            if (pb < pModLX->pbFixupSection)
+                return KLDR_ERR_BAD_FIXUP;
+
+            /*
+             * Iterate the fixup record.
+             */
+            while (pb < pbFixupRecEnd)
+            {
+                union _rel
+                {
+                    const uint8_t *          pb;
+                    const struct r32_rlc    *prlc;
+                } u;
+
+                u.pb = pb;
+                pb += 3 + (u.prlc->nr_stype & NRCHAIN ? 0 : 1); /* place pch at the 4th member. */
+
+                /*
+                 * Figure out the target.
+                 */
+                switch (u.prlc->nr_flags & NRRTYP)
+                {
+                    /*
+                     * Internal fixup.
+                     */
+                    case NRRINT:
+                    {
+                        uint16_t iTrgObject;
+                        uint32_t offTrgObject;
+
+                        /* the object */
+                        if (u.prlc->nr_flags & NR16OBJMOD)
+                        {
+                            iTrgObject = *(const uint16_t *)pb;
+                            pb += 2;
+                        }
+                        else
+                            iTrgObject = *pb++;
+                        iTrgObject--;
+                        if (iTrgObject >= pModLX->Hdr.e32_objcnt)
+                            return KLDR_ERR_BAD_FIXUP;
+
+                        /* the target */
+                        if (u.prlc->nr_flags & NR32BITOFF)
+                        {
+                            offTrgObject = *(const uint32_t *)pb;
+                            pb += 4;
+                        }
+                        else
+                        {
+                            offTrgObject = *(const uint16_t *)pb;
+                            pb += 2;
+                        }
+
+                        /* calculate the symbol info. */
+                        uValue = offTrgObject + pMod->aSegments[i].MapAddress;
+                        fKind = 0;
+                        break;
+                    }
+
+                    /*
+                     * Import by symbol ordinal.
+                     */
+                    case NRRORD:
+                    {
+                        uint16_t iModule;
+                        uint32_t iSymbol;
+
+                        /* the module ordinal */
+                        if (u.prlc->nr_flags & NR16OBJMOD)
+                        {
+                            iModule = *(const uint16_t *)pb;
+                            pb += 2;
+                        }
+                        else
+                            iModule = *pb++;
+                        iModule--;
+                        if (iModule >= pModLX->Hdr.e32_impmodcnt)
+                            return KLDR_ERR_BAD_FIXUP;
+
+                        /* . */
+                        if (u.prlc->nr_flags & NR32BITOFF)
+                        {
+                            iSymbol = *(const uint32_t *)pb;
+                            pb += 4;
+                        }
+                        else if (!(u.prlc->nr_flags & NR8BITORD))
+                        {
+                            iSymbol = *(const uint16_t *)pb;
+                            pb += 2;
+                        }
+                        else
+                            iSymbol = *pb++;
+
+                        /* resolve it. */
+                        rc = pfnGetImport(pMod, iModule, iSymbol, NULL, &uValue, &fKind, pvUser);
+                        if (rc)
+                            return rc;
+                        break;
+                    }
+
+                    /*
+                     * Import by symbol name.
+                     */
+                    case NRRNAM:
+                    {
+                        uint32_t iModule;
+                        uint16_t offSymbol;
+                        const uint8_t *pbSymbol;
+                        char szSymbol[260];
+
+                        /* the module ordinal */
+                        if (u.prlc->nr_flags & NR16OBJMOD)
+                        {
+                            iModule = *(const uint16_t *)pb;
+                            pb += 2;
+                        }
+                        else
+                            iModule = *pb++;
+                        iModule--;
+                        if (iModule >= pModLX->Hdr.e32_impmodcnt)
+                            return KLDR_ERR_BAD_FIXUP;
+#if 1
+                        if (u.prlc->nr_flags & NRCHAIN)
+                            return KLDR_ERR_BAD_FIXUP;
+#endif
+
+                        /* . */
+                        if (u.prlc->nr_flags & NR32BITOFF)
+                        {
+                            offSymbol = *(const uint32_t *)pb;
+                            pb += 4;
+                        }
+                        else if (!(u.prlc->nr_flags & NR8BITORD))
+                        {
+                            offSymbol = *(const uint16_t *)pb;
+                            pb += 2;
+                        }
+                        else
+                            offSymbol = *pb++;
+                        pbSymbol = pModLX->pbImportProcs + offSymbol;
+                        if (    pbSymbol < pModLX->pbImportProcs
+                            ||  pbSymbol > pModLX->pbFixupSectionLast)
+                            return KLDR_ERR_BAD_FIXUP;
+
+                        /* resolve it. */
+                        kLdrHlpMemCopy(szSymbol, pbSymbol + 1, *pbSymbol);
+                        szSymbol[*pbSymbol] = '\0';
+                        rc = pfnGetImport(pMod, iModule, NIL_KLDRMOD_SYM_ORDINAL, szSymbol, &uValue, &fKind, pvUser);
+                        if (rc)
+                            return rc;
+                        break;
+                    }
+
+                    case NRRENT:
+                        KLDRMODLX_ASSERT(!"NRRENT");
+                    default:
+                        break;
+                }
+
+                /* addend */
+                if (u.prlc->nr_flags & NRADD)
+                {
+                    if (u.prlc->nr_flags & NR32BITADD)
+                    {
+                        uValue += *(const uint32_t *)pb;
+                        pb += 4;
+                    }
+                    else
+                    {
+                        uValue += *(const uint16_t *)pb;
+                        pb += 2;
+                    }
+                }
+
+                /*
+                 * Deal with the 'source' (i.e. the place that should be modified (very logical).
+                 */
+                if (!(u.prlc->nr_flags & NRCHAIN))
+                {
+                    rc = kldrModLXDoReloc(pbPage, u.prlc->r32_soff, uValue, fKind);
+                    if (rc)
+                        return rc;
+                }
+                else if (!(u.prlc->nr_flags & NRICHAIN))
+                {
+                    const uint16_t *poffSrc = (const uint16_t *)pb;
+                    uint8_t c = u.pb[2];
+                    while (c-- > 0)
+                    {
+                        rc = kldrModLXDoReloc(pbPage, *poffSrc++, uValue, fKind);
+                        if (rc)
+                            return rc;
+                    }
+                }
+                else
+                {
+                    KLDRMODLX_ASSERT(!"NRICHAIN");
+                    return KLDR_ERR_LX_NRICHAIN_NOT_SUPPORTED;
+                }
+            }
+        }
+    }
+
+    return 0;
+}
+
+
+/**
+ * Applies the relocation to one 'source' in a page.
+ *
+ * @returns 0 on success, non-zero kLdr status code on failure.
+ * @param   pbPage      The page in which to apply the fixup.
+ * @param   off         Page relative offset of where to apply the offset.
+ * @param   uValue      The target value.
+ * @param   fKind       The target kind.
+ * @todo inline this.
+ */
+static int kldrModLXDoReloc(uint8_t *pbPage, int off, KLDRADDR uValue, uint32_t fKind)
+{
+
+
+    return 0;
 }
 

trunk/kLdr/kLdrModLX.h

@@ -214 +214 @@
 /** @} */
 
-/** @name nr_stype
+/** @name nr_stype (source flags)
  * @{ */
 #define NRSBYT          0x00
@@ -229 +229 @@
 /** @} */
 
-/** @name nr_flags
+/** @name nr_flags (target flags)
  * @{ */
 #define NRRINT          0x00