Changeset 2517


Ignore:
Timestamp:
Feb 4, 2006, 5:25:17 PM (20 years ago)
Author:
bird
Message:

#34: Removed all the silliness trying to deadl with truncated symbols.

Location:
branches/libc-0.6/src/emx
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • branches/libc-0.6/src/emx/ChangeLog.LIBC

    r2516 r2517  
    44
    552006-02-04: knut st. osmundsen <bird-gccos2-spam@anduin.net>
     6    - emxomfld:
     7        o #34: Removed all the silliness trying to deal with truncated symbols.
    68    - libsocket:
    79        o #25: Ensure correct address length returns from recvmsg and recvfrom.

  • branches/libc-0.6/src/emx/src/emxomf/weakld.c

    r2235 r2517  
    7373
    7474/** Compares a existing symbol with a new symbol. */
    75 #define SYM_EQUAL(pWld, pSym, _pszName, _fFlags, _uHash, _cchName) \
     75#define SYM_EQUAL(pWld, pSym, _pszName, _fFlags, _uHash, _cchName)                  \
    7676    (   (pSym)->uHash == (_uHash)                                                   \
    77      && ( !((_fFlags) & WLDSF_TRUNCATED) && !((pSym)->fFlags & WLDSF_TRUNCATED)     \
    78          ? (pSym)->pszName == (_pszName)                                            \
    79          : symCompareTrucated(pWld, pSym, _pszName, _cchName) )                     \
    80       )
     77     && (pSym)->pszName == (_pszName)                                               \
     78    )
    8179
    8280/** Compares a existing symbol with a potential symbol. */
    83 #define SYM_EQUAL2(pWld, pSym, _pszName, _fFlags, _uHash, _cchName, _pfn) \
     81#define SYM_EQUAL2(pWld, pSym, _pszName, _fFlags, _uHash, _cchName, _pfn)           \
    8482    (   (pSym)->uHash == (_uHash)                                                   \
    85      && ( !((_fFlags) & WLDSF_TRUNCATED) && !((pSym)->fFlags & WLDSF_TRUNCATED)     \
    86          ? !_pfn((pSym)->pszName, (_pszName), (_cchName)) && !(pSym)->pszName[(_cchName)] \
    87          : symCompareTrucated(pWld, pSym, _pszName, _cchName) )                     \
    88       )
     83     && !_pfn((pSym)->pszName, (_pszName), (_cchName))                              \
     84     && !(pSym)->pszName[(_cchName)]                                                \
     85    )
    8986
    9087
    … …  
    187184
    188185/**
    189  * Truncated EXTDEF name.
    190  */
    191 typedef struct wldsymtrunc
    192 {
    193     /** Full name. */
    194     const char *        pszName;
    195     /** Pointer to the next symbol. */
    196     struct wldsymtrunc *pNext;
    197 } WLDSYMTRUNC, *PWLDSYMTRUNC;
    198 
    199 /**
    200186 * Symbol structure.
    201187 */
    … …  
    208194    /** The full hash value. */
    209195    unsigned            uHash;
    210     /** LIFO of truncated name variations. */
    211     PWLDSYMTRUNC        pTrunc;
    212196
    213197    /** Symbol flags. */
    … …  
    278262         * in the definition file.
    279263         */
    280         WLDSF_WEAKALIASDONE = 0x8000,
    281 
    282         /** Internal flag which indicates that the symbol have been
    283          * truncated by emxomf. */
    284         WLDSF_TRUNCATED = 0x10000,
     264        WLDSF_WEAKALIASDONE = 0x8000
    285265    }                   fFlags;
    286266
    … …  
    486466static int          symSearchLibEnum(PWLD pWld, PWLDSYM pSym, void *pvUser);
    487467static inline unsigned symHash(const char* pszSym, unsigned cch, unsigned fWldCaseFlag);
    488 static int          symCompareTrucated(PWLD pWld, PWLDSYM pSym1, const char *pszName2, unsigned cchName2);
    489468static const char * symGetDescr(PWLDSYM pSym);
    490469static void         symDumpReferers(PWLDSYM pSym);
    … …  
    12651244
    12661245
    1267 /**
    1268  * Internal worker for SYM_EQUAL()
    1269  *
    1270  * Compares truncated symbols. The hash for these symbols matches and at least
    1271  * one of them is truncated.
    1272  *
    1273  * @returns 1 if matches
    1274  * @returns 0 if not matching.
    1275  * @param   pWld        Linker Instance.
    1276  * @param   pSym1       Symbol 1.
    1277  * @param   pszName2    Symbol 2 name.
    1278  * @param   cchName2    Symbol 2 name length.
    1279  */
    1280 static int symCompareTrucated(PWLD pWld, PWLDSYM pSym1, const char *pszName2, unsigned cchName2)
    1281 {
    1282     /* Truncated string comparision means comparing MIN(cchName2, strlen(pSym1->pszName)) chars. */
    1283     const char *pszName1 = pSym1->pszName;
    1284     if (pWld->fFlags & WLDC_CASE_INSENSITIVE)
    1285     {
    1286         while (cchName2-- > 0 && *pszName1)
    1287         {
    1288             if (toupper(*pszName1) != toupper(*pszName2))
    1289                 return 0;
    1290             pszName1++;
    1291             pszName2++;
    1292         }
    1293     }
    1294     else
    1295     {
    1296         while (cchName2-- > 0 && *pszName1)
    1297         {
    1298             if (*pszName1 != *pszName2)
    1299                 return 0;
    1300             pszName1++;
    1301             pszName2++;
    1302         }
    1303     }
    1304     return 1;
    1305 }
    1306 
    1307 
    13081246
    13091247/**
    … …  
    13411279                break;
    13421280        }
    1343         else if (    psz[0] == '!'
    1344                  &&  psz[1] == '_'
    1345                  &&  psz - psz > 200)
    1346         {
    1347             uHash = strtol(&psz[2], NULL, 16);
    1348             fFlags |= WLDSF_TRUNCATED;
    1349             cchName = psz - pszName;
    1350             break;
    1351         }
    13521281
    13531282    pszName = (pWld->fFlags & WLDC_CASE_INSENSITIVE ? strpool_addnu : strpool_addn)(pWld->pStrMisc, pszName, cchName);
    … …  
    15161445            if (cchName > 200)
    15171446                break;
    1518         }
    1519         else if (    psz[0] == '!'
    1520                  &&  psz[1] == '_'
    1521                  &&  psz - pszName > 200)
    1522         {
    1523             uHash = strtol(&psz[2], NULL, 16);
    1524             fFlags |= WLDSF_TRUNCATED;
    1525             cchName = psz - pszName;
    1526             break;
    15271447        }
    15281448
    … …  
    16811601    const char *pszName;                /* The symbol name in the string pool */
    16821602    int         cchNameWeak = 0;        /* Indicator and length of the weak name. (0 if not weak) */
    1683     int         cchNameTrunc = 0;       /* Full length of truncated symbol name.  */
    16841603    /* general stuff */
    16851604    const char *    pach;
    … …  
    17081627                break;
    17091628        }
    1710         else if (    pach[0] == '!'
    1711                  &&  pach[1] == '_'
    1712                  &&  pach - pachName > 200)
    1713         {
    1714             uHash = strtol(&pach[2], NULL, 16);
    1715             fFlags |= WLDSF_TRUNCATED;
    1716             cchNameTrunc = cchNameWeak ? cchNameWeak : cchName;
    1717             cchName = pach - pachName;
    1718             break;
    1719         }
    17201629    }
    17211630    pszName = (pWld->fFlags & WLDC_CASE_INSENSITIVE ? strpool_addnu : strpool_addn)(pWld->pStrMisc, pachName, cchName);
    1722     if (!(fFlags & WLDSF_TRUNCATED))
    1723         uHash = symHash(pszName, cchName, pWld->fFlags & WLDC_CASE_INSENSITIVE);
     1631    uHash = symHash(pszName, cchName, pWld->fFlags & WLDC_CASE_INSENSITIVE);
    17241632
    17251633    /* search for existing symbol  */
    … …  
    18951803            }
    18961804        }
    1897 
    1898         /*
    1899          * Maintain list of truncated aliases.
    1900          */
    1901         if (    !SYM_IS_DEFINED(fFlags)
    1902             && ((fFlags & WLDSF_TRUNCATED) || (pSym->fFlags & WLDSF_TRUNCATED)))
    1903         {
    1904             PWLDSYMTRUNC    pTrunc = pSym->pTrunc;
    1905             const char     *pszSubName = pSym->pszWeakName;
    1906             if (!pszSubName)
    1907                 pszSubName = strpool_addn(pWld->pStrMisc, pachName, cchNameTrunc);
    1908 
    1909             while (pTrunc && pTrunc->pszName != pszSubName)
    1910                 pTrunc = pTrunc->pNext;
    1911             if (!pTrunc)
    1912             {
    1913                 pTrunc = xmalloc(sizeof(*pTrunc));
    1914                 pTrunc->pszName = pszSubName;
    1915                 pTrunc->pNext = pSym->pTrunc;
    1916                 pSym->pTrunc = pTrunc;
    1917             }
    1918         }
    19191805    }
    19201806
    … …  
    34403326static int      wldGenerateObjEnum(PWLD pWld, PWLDSYM pSym, void *pvUser)
    34413327{
    3442     const char     *pszSubName = pSym->pszWeakName;
     3328    #pragma pack(1)
     3329    struct omfstuff
     3330    {
     3331        OMFREC  hdr;
     3332        union
     3333        {
     3334            char        ach[640];
     3335            OMFLIBHDRX  libhdr;
     3336        };
     3337    } omf;
     3338    #pragma pack()
    34433339    PWLDGOEPARAM    pParam = (PWLDGOEPARAM)pvUser;
     3340    int             cchAlias;
    34443341    int             cch;
    3445     WLDSYMTRUNC     Trunc;
    3446     PWLDSYMTRUNC    pTrunc;
    34473342
    34483343    /*
    3449      * If weak, we'll make fake trunc record.
     3344     * Skip non-weak symbols (a bit of paranoia).
    34503345     */
    3451     if (pSym->pszWeakName)
    3452     {
    3453         Trunc.pNext   = pSym->pTrunc;
    3454         Trunc.pszName = pSym->pszName;
    3455         pTrunc = &Trunc;
    3456     }
    3457     else
    3458     {
    3459         pTrunc = pSym->pTrunc;
    3460         pszSubName = pSym->pszName;
    3461     }
    3462     cch = strlen(pszSubName);
     3346    if (    !pSym->pszWeakName
     3347        ||  pSym->pszName == pSym->pszWeakName)
     3348    {
     3349        WLDDBG(("not weak: '%s'\n", pSym->pszName));
     3350        return 0;
     3351    }
    34633352
    34643353    /*
    3465      * Walk trunc record list.
     3354     * Create the alias record.
    34663355     */
    3467     while (pTrunc)
    3468     {
    3469         if (pTrunc->pszName != pszSubName)
    3470         {
    3471             #pragma pack(1)
    3472             struct omfstuff
    3473             {
    3474                 OMFREC  hdr;
    3475                 union
    3476                 {
    3477                     char        ach[640];
    3478                     OMFLIBHDRX  libhdr;
    3479                 };
    3480             } omf;
    3481             #pragma pack()
    3482             int             cchAlias = strlen(pTrunc->pszName);
    3483 
    3484             WLDINFO(pWld, ("using weak/trunc %s for %s", pszSubName, pTrunc->pszName));
    3485 
    3486             /* paranoia */
    3487             if (cchAlias > 255)
    3488             {
    3489                 wldErr(pWld, "Symbol '%s' are too long (%d).", pTrunc->pszName, cchAlias);
    3490                 return -1;
    3491             }
    3492             if (cch > 255)
    3493             {
    3494                 wldErr(pWld, "Symbol '%s' are too long (%d).", pszSubName, cch);
    3495                 return -1;
    3496             }
    3497 
    3498             /* end the current object? */
    3499             if ((pWld->fFlags & WLDC_LINKER_LINK386) && pParam->cAliases >= 32)
    3500             {
    3501                 int rc = wldObjEnd(pWld, pParam->phFile, 32);
    3502                 if (rc)
    3503                     return rc;
    3504                 pParam->cAliases = 0;
    3505             }
    3506 
    3507             /* make new object ? */
    3508             if (!pParam->cAliases)
    3509             {
    3510                 sprintf(omf.ach, "wk%d.obj", pParam->iLibFile++);
    3511                 int rc = wldObjStart(pWld, pParam->phFile, omf.ach);
    3512                 if (rc)
    3513                     return rc;
    3514             }
    3515 
    3516             /* Alias record */
    3517             omf.hdr.chType = ALIAS;
    3518             omf.hdr.cb = cchAlias + cch + 3;
    3519             omf.ach[0] = cchAlias;
    3520             memcpy(&omf.ach[1], pTrunc->pszName, cchAlias);           /* alias */
    3521             omf.ach[cchAlias + 1] = cch;
    3522             memcpy(&omf.ach[cchAlias + 2], pszSubName, cch); /* subtitute */
    3523             omf.ach[cchAlias + cch + 2] = 0; /* crc */
    3524             if (fwrite(&omf, omf.hdr.cb + sizeof(OMFREC), 1, pParam->phFile) != 1)
    3525             {
    3526                 wldErr(pWld, "Error occured while writing weak/trunc aliases. (2)");
    3527                 return -1;
    3528             }
    3529             pParam->cAliases++;
    3530         }
    3531 
    3532         /* next */
    3533         pTrunc = pTrunc->pNext;
    3534     }
     3356    cchAlias   = strlen(pSym->pszName);
     3357    cch        = strlen(pSym->pszWeakName);
     3358    WLDINFO(pWld, ("using weak %s for %s", pSym->pszWeakName, pSym->pszName));
     3359
     3360    /* paranoia */
     3361    if (cchAlias > 255)
     3362    {
     3363        wldErr(pWld, "Symbol '%s' are too long (%d).", pSym->pszName, cchAlias);
     3364        return -1;
     3365    }
     3366    if (cch > 255)
     3367    {
     3368        wldErr(pWld, "Symbol '%s' are too long (%d).", pSym->pszWeakName, cch);
     3369        return -1;
     3370    }
     3371
     3372    /* end the current object? */
     3373    if ((pWld->fFlags & WLDC_LINKER_LINK386) && pParam->cAliases >= 32)
     3374    {
     3375        int rc = wldObjEnd(pWld, pParam->phFile, 32);
     3376        if (rc)
     3377            return rc;
     3378        pParam->cAliases = 0;
     3379    }
     3380
     3381    /* make new object ? */
     3382    if (!pParam->cAliases)
     3383    {
     3384        sprintf(omf.ach, "wk%d.obj", pParam->iLibFile++);
     3385        int rc = wldObjStart(pWld, pParam->phFile, omf.ach);
     3386        if (rc)
     3387            return rc;
     3388    }
     3389
     3390    /* Alias record */
     3391    omf.hdr.chType = ALIAS;
     3392    omf.hdr.cb = cchAlias + cch + 3;
     3393    omf.ach[0] = cchAlias;
     3394    memcpy(&omf.ach[1], pSym->pszName, cchAlias);           /* alias */
     3395    omf.ach[cchAlias + 1] = cch;
     3396    memcpy(&omf.ach[cchAlias + 2], pSym->pszWeakName, cch); /* subtitute */
     3397    omf.ach[cchAlias + cch + 2] = 0; /* crc */
     3398    if (fwrite(&omf, omf.hdr.cb + sizeof(OMFREC), 1, pParam->phFile) != 1)
     3399    {
     3400        wldErr(pWld, "Error occured while writing weak/trunc aliases. (2)");
     3401        return -1;
     3402    }
     3403    pParam->cAliases++;
    35353404
    35363405    return 0;
Note: See TracChangeset for help on using the changeset viewer.