Changeset 1410

Timestamp:

Apr 30, 2004, 10:40:31 AM (22 years ago)

Author:

bird

Message:

Long symbols should work now.

Location:

trunk/src/emx/src/emxomf

Files:

• emxomf.c (modified) (8 diffs, 1 prop)
• weakld.c (modified) (19 diffs, 1 prop)

trunk/src/emx/src/emxomf/emxomf.c

@@ -351 +351 @@
 static char base_dir[256];
 
-/* This variable holds a normalized module name used with weak syms.  See get_mod_name(). */
-static char weak_mod_name[256];
+/* This variable holds the simple weak marker for the current module. See get_mod_name(). */
+static char weak_marker_simple[128];
+static int  weak_marker_simple_size;
+
+/* This variable holds the timestamped weak marker for the current module. See get_mod_name(). */
+static char weak_marker_ts[148];
+static int  weak_marker_ts_size;
 
 /* This growing array holds the file name table for generating line
@@ -777 +782 @@
   buffer_init (&sst);
   buffer_init (&sst_reloc);
+
+
+
+
+
+
+
 }
 
@@ -913 +925 @@
 
 
-/* Put the null-terminated string SRC into the current OMF record.  In
-   the OMF record, the string is preceded by a length byte.  The
+/* Put the null-terminated string 
+   the OMF record, the string is preceded by a length byte.  The
    string length must not exceed 255; if it is too long, display a
    warning and truncate the string.  Moreover, there must be enough
@@ -920 +932 @@
    message and abort. */
 
-static void put_str (const char *src)
-{
-  char sz[256];
-  int len;
-
-  len = strlen (src);
-  if (len > 255)
-    { /* Hash the symbol to help making it unique. */
-      const char *  psz = src;
-      unsigned      uhash = 0;
-      char          szhash[16];
-      warning ("Symbol length truncated to 255 characters for `%s'", src);
-      for (; *psz; psz++)
-        uhash = ((uhash << 3) ^ (*psz & 0x15)); /** @todo fix this rather bad hash algorithm. */
-      len = sprintf(szhash, "!_%X", 0x7fffffff & uhash);
-      memcpy(sz, src, 255);
-      memcpy(sz + 255 - len, szhash, len + 1);
-      len = 255;
-      src = &sz[0];
-    }
-  if (!fits (1+len))
-    doesn_fit ();
-  out_data[out_idx++] = (byte)len;
-  memcpy (out_data+out_idx, src, len);
-  out_idx += len;
+static void put_str(const char *pszName)
+{
+    int cch = strlen(pszName);
+    if (cch > 255)
+    {
+        /* Hash the symbol to help making it unique. 
+         * NOTE that the hash algorithm is not fixed, so is the !_%X marker too.
+         *      the weakld is parsing it!
+         */
+        char        szHash[16];
+        int         cch2;
+        const char *psz;
+        unsigned    uHash;
+        for (psz = pszName, uHash = 5381; *psz; psz++)   /* hash alg: original djb2. */
+            uHash += (uHash << 5) + *psz;
+        cch2 = sprintf(szHash, "!_%X", 0x7fffffff & uHash);
+
+        if (!fits(1+255))
+            doesn_fit();
+        out_data[out_idx++] = 255;
+        memcpy(out_data + out_idx, pszName, 255);
+        memcpy(out_data + out_idx + 255 - cch2, szHash, cch2);
+        out_idx += 255;
+
+        warning ("Symbol length truncated to 255 characters (from %d) for `%s'", cch, pszName);
+    }
+    else
+    {
+        if (!fits(1+cch))
+            doesn_fit();
+        out_data[out_idx++] = (byte)cch;
+        memcpy(out_data+out_idx, pszName, cch);
+        out_idx += cch;
+    }
 }
 
@@ -1264 +1285 @@
  *                      new name will be written.
  * @param   cchName     Size of the buffer pointed to by pachName.
+
  * @remark I'm sorry this function is written in my coding style - not!
  * @remark Weak Hack Method 2.
@@ -1287 +1309 @@
         case N_WEAKB:               /* 0x11  Weak bss symbol. */
         {
-            if (!opt_weakts)
-                snprintf(pachName, cchName, "%s$w$%s",
-                         pszOrgName, weak_mod_name);
-            else
+            int cch = strlen(pszOrgName);
+            int cch2;
+            
+            /* Init the markers if not done already. */
+            if (!weak_marker_simple[0])
             {
-                struct timeval tv = {0, 0};
+                static struct timeval   tv_prev;
+                static unsigned         iOpaque = 1;
+                struct timeval          tv = {0, 0};
+                const char             *p1;
+                char                   *p2, *p3;
+
+                /* simple */
+                memcpy(weak_marker_simple, "$w$", 4);
+                for (p1 = "\\/:", p2 = mod_name; *p1; p1++)
+                  if ((p3 = strrchr(p2, *p1)) != NULL)
+                    p2 = p3 + 1;
+                p1 = &weak_marker_simple[sizeof(weak_marker_simple) - 1];
+                for (p3 = &weak_marker_simple[3]; *p2 && p3 < p1; p2++)
+                  if (isalnum(*p2) || *p2 == '_' || *p2 == '@')
+                      *p3++ = *p2;
+                  else if (*p2 == '.')
+                      *p3++ = '_';
+                *p3 = '\0';
+                weak_marker_simple_size = p3 - &weak_marker_simple[0];
+
+                /* timestamped: $w$[1-7][1-4]#[-1-7]#[1-123] */
                 gettimeofday(&tv, NULL);
-                snprintf(pachName, cchName, "%s$w$%s%lx%lx",
-                         pszOrgName, weak_mod_name, tv.tv_sec, tv.tv_usec);
+                memcpy(&weak_marker_ts[0], "$w$", 4);
+                ltoa(tv.tv_sec, &weak_marker_ts[3], 36); 
+                cch2 = 3 + strlen(&weak_marker_ts[3]);
+                ltoa(tv.tv_usec, &weak_marker_ts[cch2], 36);
+                cch2 += strlen(&weak_marker_ts[cch2]);
+                weak_marker_ts[cch2++] = '#';
+                if (tv_prev.tv_usec == tv.tv_usec && tv_prev.tv_sec == tv.tv_sec)
+                {
+                    if (!iOpaque)   
+                    {
+                        unsigned short seed[3];
+                        seed[0] = (unsigned short)tv.tv_usec;
+                        seed[1] = (unsigned short)tv.tv_sec;
+                        seed[2] = (unsigned short)tv.tv_sec >> 16;
+                        iOpaque = nrand48(seed);
+                    }
+                    iOpaque++;
+                    ltoa(tv.tv_usec, &weak_marker_ts[cch2], 36);
+                    cch2 += strlen(&weak_marker_ts[cch2]);
+                    weak_marker_ts[cch2++] = '#';
+                }
+                tv_prev = tv;
+                memcpy(&weak_marker_ts[cch2], &weak_marker_simple[3], weak_marker_simple_size - 3 + 1);
+                weak_marker_ts_size = cch2 + weak_marker_simple_size - 3;
             }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
             return pachName;
         }
@@ -2822 +2913 @@
   int i, len, ok;
   const char *p1, *p2;
-  char *p3;
 
   base_dir[0] = '\0';
@@ -2885 +2975 @@
       base_dir[1] = ':';
     }
-
-  /* Find the base name and length (excluding extension)
-     This is used for weak symbol handling. */
-  for (p1 = "\\/:", p2 = mod_name; *p1; p1++)
-    if ((p3 = strrchr(p2, *p1)) != NULL)
-      p2 = p3 + 1;
-  for (p3 = weak_mod_name; *p2; p2++)
-    if (isalnum(*p2) || *p2 == '$' || *p2 == '_' || *p2 == '@')
-        *p3++ = *p2;
-    else if (*p2 == '.')
-        *p3++ = '_';
-  *p3 = '\0';
 }
 

trunk/src/emx/src/emxomf/weakld.c

@@ -54 +54 @@
 #define WLDINTERR(pWld, pMod)   wldIntErr(pWld, pMod, __FILE__, __LINE__, __FUNCTION__);
 
-/*#define WLD_ENABLED_DBG*/
+/
 #ifdef WLD_ENABLED_DBG
 #define SYMDBG(pSym, pszMsg)    symDbg(pSym, pszMsg);
@@ -72 +72 @@
                                   )
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
@@ -81 +97 @@
 #include <stdarg.h>
 #include <string.h>
+
 #include <sys/types.h>
 #include <sys/time.h>
@@ -170 +187 @@
 
 /**
+
+
+
+
+
+
+
+
+
+
+
  * Symbol structure.
  */
@@ -178 +206 @@
     /** Weak name - for weak symbols only. */
     const char *        pszWeakName;
+
+
+
+
 
     /** Symbol flags. */
@@ -241 +273 @@
          */
         WLDSF_WEAKALIASDONE = 0x8000,
+
+
+
+
+
     }                   fFlags;
 
@@ -441 +478 @@
 } WLDSLEPARAM, *PWLDSLEPARAM;
 static int          symSearchLibEnum(PWLD pWld, PWLDSYM pSym, void *pvUser);
-static inline unsigned symHash(const char* pszSym, unsigned cch);
+static inline unsigned symHash(const char* pszSym, unsigned cch, unsigned fWldCaseFlag);
+static int          symCompareTrucated(PWLD pWld, PWLDSYM pSym1, const char *pszName2, unsigned cchName2);
 static const char * symGetDescr(PWLDSYM pSym);
 static void         symDumpReferers(PWLDSYM pSym);
@@ -1191 +1229 @@
  * Calculate the hash value of a symbol.
  * @returns hash value.
- * @param   pszSym  Symbol to calculate it for.
- * @param   cch     Symbol length.
+ * @param   pszSym          Symbol to calculate it for.
+ * @param   cch             Symbol length.
+ * @param   fWldCaseFlag    Case flag from the linker instance.
+ *                          Not implemented yet.
  * @todo    This ain't respecting case sensitivity.
  */
-static inline unsigned symHash(const char* pszSym, unsigned cch)
-{
-    unsigned uHash = 0;
+static inline unsigned symHash(const char* pszSym, unsigned cch, unsigned fWldCaseFlag)
+{
+    /* hash alg: original djb2. */
+    unsigned uHash = 5381;
     while (     cch
            &&   (pszSym[0] != '$' || pszSym[1] != 'w' || pszSym[2] != '$')
              )
     {
-        uHash = uHash * 63377 + *pszSym;
+        if (    pszSym[0] == '!'
+            &&  pszSym[1] == '_'
+            &&  cch > 200)
+        {
+            uHash = strtol(&pszSym[2], NULL, 16);
+            break;
+        }
+        uHash += (uHash << 5) + *pszSym;
         pszSym++;
         cch--;
     }
-    uHash %= WLDSYM_HASH_SIZE;
     return uHash;
 }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 /**
@@ -1222 +1312 @@
     const char *psz;
     unsigned    cchName;
-    unsigned    uHash;
+    unsigned    fFlags = 0;
+    unsigned    uHash = 0;
 
     /*
-     * Calculate the hash of the symbol
-     *
      * It's easier just to add it to the string table than starting to
      * check the correct case function and such. As there is a good
@@ -1233 +1322 @@
      * (if possible) and gain everywhere.
      */
-    psz = strstr(pszName, "$w$");
-    cchName = psz ? psz - pszName : strlen(pszName);
+
+    /* look for weak suffix and trucation */
+    cchName = strlen(pszName);
+    for (psz = pszName + cchName - 1; psz > pszName; psz--)
+        if (    psz[0] == '$'
+            &&  psz[1] == 'w'
+            &&  psz[2] == '$')
+        {
+            cchName = psz - pszName;
+            if (cchName > 200)
+                break;
+        }
+        else if (    psz[0] == '!'
+                 &&  psz[1] == '_'
+                 &&  psz - psz > 200)
+        {
+            uHash = strtol(&psz[2], NULL, 16);
+            fFlags |= WLDSF_TRUNCATED;
+            cchName = psz - pszName;
+            break;
+        }
+
     pszName = (pWld->fFlags & WLDC_CASE_INSENSITIVE ? strpool_addnu : strpool_addn)(pWld->pStrMisc, pszName, cchName);
-    uHash = symHash(pszName, cchName);
+    if (!fFlags)
+        uHash = symHash(pszName, cchName, pWld->fFlags & WLDC_CASE_INSENSITIVE);
 
     /* look it up */
-    for (pSym = pWld->Global.ap[uHash]; pSym; pSym = pSym->pHashNext)
-       if (pSym->pszName == pszName)
+    for (pSym = pWld->Global.ap[uHash]; pSym; pSym = pSym->pHashNext)
+       if ()
            return pSym;
 
@@ -1383 +1493 @@
 static int          symMatchUnDef(PWLD pWld, const unsigned char *pachPascalString, PWLDSYM pSym)
 {
-    int         cch = *pachPascalString;
-    const char *psz = pachPascalString + 1;
-    const char *pszWeak;
-    int (*pfn)(const char *, const char *, size_t) = (pWld->fFlags & WLDC_CASE_INSENSITIVE) ? strnicmp : strncmp;
-
-    /* look for weak suffix */
-    for (pszWeak = psz + cch - 1; pszWeak > psz; pszWeak--)
-        if (    pszWeak[0] == '$'
-            &&  pszWeak[1] == 'w'
-            &&  pszWeak[2] == '$')
-        {
-            cch = pszWeak - psz;
+    int         cchName = *pachPascalString;
+    const char *pszName = pachPascalString + 1;
+    const char *psz;
+    unsigned    fFlags = 0;
+    unsigned    uHash = 0;
+    int        (*pfn)(const char *, const char *, size_t) = pWld->fFlags & WLDC_CASE_INSENSITIVE ? strnicmp : strncmp;
+
+    /* look for weak suffix and trucation */
+    for (psz = pszName + cchName - 1; psz > pszName; psz--)
+        if (    psz[0] == '$'
+            &&  psz[1] == 'w'
+            &&  psz[2] == '$')
+        {
+            cchName = psz - pszName;
+            if (cchName > 200)
+                break;
+        }
+        else if (    psz[0] == '!'
+                 &&  psz[1] == '_'
+                 &&  psz - pszName > 200)
+        {
+            uHash = strtol(&psz[2], NULL, 16);
+            fFlags |= WLDSF_TRUNCATED;
+            cchName = psz - pszName;
             break;
         }
+
+
+
+
 
     /* compare */
     if (pSym)
-        return !pfn(pSym->pszName, psz, cch) && !pSym->pszName[cch];
+        return ;
     else
     {
-        /* @todo: this isn't 100% correct when we're talking case in sensitivity. */
-        unsigned uHash = symHash(psz, cch);
-        for (pSym = pWld->Global.ap[uHash]; pSym; pSym = pSym->pHashNext)
+        for (pSym = pWld->Global.ap[uHash % WLDSYM_HASH_SIZE]; pSym; pSym = pSym->pHashNext)
         {
             if ((pSym->fFlags & (WLDSF_TYPEMASK | WLDSF_WEAK)) == WLDSF_UNDEF)
             {
-                if (!pfn(pSym->pszName, psz, cch) && !pSym->pszName[cch])
+                if ()
                     return 1;
             }
@@ -1550 +1674 @@
     const char *pszName;                /* The symbol name in the string pool */
     int         cchNameWeak = 0;        /* Indicator and length of the weak name. (0 if not weak) */
+
     /* general stuff */
     const char *    pach;
@@ -1558 +1683 @@
         cchName = strlen(pachName);
 
-    /* adjust namelength / check for weak name / hash name */
+    /* adjust namelength / check for weak name / hash name */
     pach = pachName + cchName - 2;      /* "$w$" */
     while (pach-- > pachName)
+
         if (    pach[0] == '$'
             &&  pach[1] == 'w'
@@ -1571 +1697 @@
             if ((fFlags & WLDSF_TYPEMASK) == WLDSF_WKEXT)
                 fFlags = (fFlags & ~WLDSF_TYPEMASK) | WLDSF_UNDEF;
+
+
+
+
+
+
+
+
+
+
+
+
             break;
         }
+
     pszName = (pWld->fFlags & WLDC_CASE_INSENSITIVE ? strpool_addnu : strpool_addn)(pWld->pStrMisc, pachName, cchName);
-    uHash = symHash(pszName, cchName);
+    if (!(fFlags & WLDSF_TRUNCATED))
+        uHash = symHash(pszName, cchName, pWld->fFlags & WLDC_CASE_INSENSITIVE);
 
     /* search for existing symbol  */
-    pSym = pWld->Global.ap[uHash];
-    while (pSym && pSym->pszName != pszName)
-        pSym = pSym->pHashNext;
+    
+    )
+        ;
 
     if (!pSym)
     {
         /*
-         * new symol - this is easy!
+         * new symol - this is easy!
          */
         pSym = xmalloc(sizeof(*pSym));
         memset(pSym, 0, sizeof(*pSym));
-        pSym->fFlags = fFlags;
+        pSym->fFlags = fFlags;
         pSym->pszName = pszName;
+
         if (cchNameWeak)
         {
@@ -1596 +1737 @@
             WLDINFO(pWld, ("Weak symbol '%s'.", pSym->pszWeakName));
         }
-        pSym->pHashNext = pWld->Global.ap[uHash];
-        pWld->Global.ap[uHash] = pSym;
+        pSym->pHashNext = pWld->Global.ap[uHash];
+        pWld->Global.ap[uHash] = pSym;
         if (peAction) *peAction = WLDSA_NEW;
         WLDDBG2(("symAdd: New symbol '%s'", pSym->pszName));
@@ -1728 +1869 @@
 
     /*
-     * Maintain the module pointer and referers.
+     * Maintain the module pointers.
      */
     if (pSym)
@@ -1745 +1886 @@
                     pSym->paReferers = xrealloc(pSym->paReferers, sizeof(pSym->paReferers[0]) * (pSym->cReferers + 64));
                 pSym->paReferers[pSym->cReferers++] = pMod;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
             }
         }
@@ -3257 +3420 @@
 static int      wldGenerateObjEnum(PWLD pWld, PWLDSYM pSym, void *pvUser)
 {
+
+
+
+
+
+
+
+
+
     if (pSym->pszWeakName)
     {
-        PWLDGOEPARAM    pParam = (PWLDGOEPARAM)pvUser;
-        #pragma pack(1)
-        struct omfstuff
-        {
-            OMFREC  hdr;
-            union
+        Trunc.pNext   = pSym->pTrunc;
+        Trunc.pszName = pSym->pszName;
+        pTrunc = &Trunc;
+    }
+    else
+    {
+        pTrunc = pSym->pTrunc;
+        pszSubName = pSym->pszName;
+    }
+    cch = strlen(pszSubName);
+
+    /*
+     * Walk trunc record list.
+     */
+    while (pTrunc)
+    {
+        if (pTrunc->pszName != pszSubName)
+        {
+            #pragma pack(1)
+            struct omfstuff
             {
-                char        ach[640];
-                OMFLIBHDRX  libhdr;
-            };
-        } omf;
-        #pragma pack()
-        int             cch = strlen(pSym->pszWeakName);
-        int             cchAlias = strlen(pSym->pszName);
-
-        WLDINFO(pWld, ("using weak %s for %s", pSym->pszWeakName, pSym->pszName));
-
-        /* paranoia */
-        if (cchAlias > 255)
-        {
-            wldErr(pWld, "Symbol '%s' are too long (%d).", pSym->pszName, cchAlias);
-            return -1;
-        }
-        if (cch > 255)
-        {
-            wldErr(pWld, "Symbol '%s' are too long (%d).", pSym->pszWeakName, cch);
-            return -1;
-        }
-
-        /* end the current object? */
-        if ((pWld->fFlags & WLDC_LINKER_LINK386) && pParam->cAliases >= 32)
-        {
-            int rc = wldObjEnd(pWld, pParam->phFile, 32);
-            if (rc)
-                return rc;
-            pParam->cAliases = 0;
-        }
-
-        /* make new object ? */
-        if (!pParam->cAliases)
-        {
-            sprintf(omf.ach, "wk%d.obj", pParam->iLibFile++);
-            int rc = wldObjStart(pWld, pParam->phFile, omf.ach);
-            if (rc)
-                return rc;
-        }
-
-        /* Alias record */
-        omf.hdr.chType = ALIAS;
-        omf.hdr.cb = cchAlias + cch + 3;
-        omf.ach[0] = cchAlias;
-        memcpy(&omf.ach[1], pSym->pszName, cchAlias);           /* alias */
-        omf.ach[cchAlias + 1] = cch;
-        memcpy(&omf.ach[cchAlias + 2], pSym->pszWeakName, cch); /* subtitute */
-        omf.ach[cchAlias + cch + 2] = 0; /* crc */
-        if (fwrite(&omf, omf.hdr.cb + sizeof(OMFREC), 1, pParam->phFile) != 1)
-        {
-            wldErr(pWld, "Error occured while writing weak aliases. (2)");
-            return -1;
-        }
-        pParam->cAliases++;
-    }
+                OMFREC  hdr;
+                union
+                {
+                    char        ach[640];
+                    OMFLIBHDRX  libhdr;
+                };
+            } omf;
+            #pragma pack()
+            int             cchAlias = strlen(pTrunc->pszName);
+
+            WLDINFO(pWld, ("using weak/trunc %s for %s", pszSubName, pTrunc->pszName));
+
+            /* paranoia */
+            if (cchAlias > 255)
+            {
+                wldErr(pWld, "Symbol '%s' are too long (%d).", pTrunc->pszName, cchAlias);
+                return -1;
+            }
+            if (cch > 255)
+            {
+                wldErr(pWld, "Symbol '%s' are too long (%d).", pszSubName, cch);
+                return -1;
+            }
+
+            /* end the current object? */
+            if ((pWld->fFlags & WLDC_LINKER_LINK386) && pParam->cAliases >= 32)
+            {
+                int rc = wldObjEnd(pWld, pParam->phFile, 32);
+                if (rc)
+                    return rc;
+                pParam->cAliases = 0;
+            }
+
+            /* make new object ? */
+            if (!pParam->cAliases)
+            {
+                sprintf(omf.ach, "wk%d.obj", pParam->iLibFile++);
+                int rc = wldObjStart(pWld, pParam->phFile, omf.ach);
+                if (rc)
+                    return rc;
+            }
+
+            /* Alias record */
+            omf.hdr.chType = ALIAS;
+            omf.hdr.cb = cchAlias + cch + 3;
+            omf.ach[0] = cchAlias;
+            memcpy(&omf.ach[1], pTrunc->pszName, cchAlias);           /* alias */
+            omf.ach[cchAlias + 1] = cch;
+            memcpy(&omf.ach[cchAlias + 2], pszSubName, cch); /* subtitute */
+            omf.ach[cchAlias + cch + 2] = 0; /* crc */
+            if (fwrite(&omf, omf.hdr.cb + sizeof(OMFREC), 1, pParam->phFile) != 1)
+            {
+                wldErr(pWld, "Error occured while writing weak/trunc aliases. (2)");
+                return -1;
+            }
+            pParam->cAliases++;
+        }
+
+        /* next */
+        pTrunc = pTrunc->pNext;
+    }
+
     return 0;
 }
@@ -3651 +3844 @@
                          * See defect #483 for details. Short summary: an array calculation in ilink is
                          * assuming that library objects have less EXTDEFs than the object ones. So, for
-                         * pass2 an EXTDEF array may become too short.
+                         * pass2 an EXTDEF array may become too s.
                          */
                         WLDINFO(pWld, ("cWeakAliases=%d cMaxObjExts=%d cMaxLibExts=%d",