watgbl.c

来自「开放源码的编译器open watcom 1.6.0版的源代码」· C语言 代码 · 共 660 行 · 第 1/2 页

/****************************************************************************
*
*                            Open Watcom Project
*
*    Portions Copyright (c) 1983-2002 Sybase, Inc. All Rights Reserved.
*
*  ========================================================================
*
*    This file contains Original Code and/or Modifications of Original
*    Code as defined in and that are subject to the Sybase Open Watcom
*    Public License version 1.0 (the 'License'). You may not use this file
*    except in compliance with the License. BY USING THIS FILE YOU AGREE TO
*    ALL TERMS AND CONDITIONS OF THE LICENSE. A copy of the License is
*    provided with the Original Code and Modifications, and is also
*    available at www.sybase.com/developer/opensource.
*
*    The Original Code and all software distributed under the License are
*    distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
*    EXPRESS OR IMPLIED, AND SYBASE AND ALL CONTRIBUTORS HEREBY DISCLAIM
*    ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF
*    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR
*    NON-INFRINGEMENT. Please see the License for the specific language
*    governing rights and limitations under the License.
*
*  ========================================================================
*
* Description:  WHEN YOU FIGURE OUT WHAT THIS FILE DOES, PLEASE
*               DESCRIBE IT HERE!
*
****************************************************************************/


#include "dipwat.h"
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include "demangle.h"

extern void             AddressMap( imp_image_handle *, addr_ptr * );
extern section_info     *FindInfo( imp_image_handle *, imp_mod_handle );
extern unsigned         ModOff2Idx(section_info *, unsigned);
extern search_result    LookupLclAddr( imp_image_handle *, address, imp_sym_handle * );
extern void             LocationCreate( location_list *, location_type, void * );
extern void             SetGblLink( imp_sym_handle *, void * );

static unsigned         GblNameOff;

typedef word            hash_link;

/*
 * NOTE: This structure *must* be a power of two size.
 */
typedef struct gbl_link {
        gbl_info        *gbl;
        hash_link       hash_off;
        byte            src_off;
        byte            src_len : 7;
        byte            dtor    : 1;
} gbl_link;

#define HL_END                  ((hash_link)-1)
#define MAKE_LP( la, off )      ((gbl_link *)((byte*)(la) + (off)))
#define MK_ADDR( a, ma, sect )  {a.mach=ma;a.sect_id=sect;a.indirect=1;}

#if defined(__DOS__) && !defined(__386__)
#define SYM_TAB_SIZE  128       /* for DOS */
#else
#define SYM_TAB_SIZE  256       /* for less memory constrained environs */
#endif

typedef struct gbl_link_info {
    gbl_link            *end;
    hash_link           hash[ SYM_TAB_SIZE ];
    gbl_link            link[1];
} gbl_link_info;


#define GBL_KIND( gbl )         (GblNameOff==0? 0 : ((gbl_info*)(gbl))->name[0])
#define GBL_NAME( gbl )         (&((gbl_info*)(gbl))->name[GblNameOff+1])
#define GBL_NAMELEN( gbl )      ((gbl)->name[GblNameOff])
#define GBL_MOD( gbl )          (((gbl_info*)(gbl))->mod)
/* I know -- this is evil. It's temporary and it's fast */
#define SET_GBLNAMEOFF( ctl )   (GblNameOff = (ctl)->v2 ^ 0x1)

#define LINK( blk )  ((gbl_link_info *)blk->link)

void GblSymFini( section_info *inf )
{
    info_block          *ptr;

    ptr = inf->gbl;
    while( ptr != NULL ) {
        DCFree( ptr->link );
        ptr->link = NULL;
        ptr = ptr->next;
    }
}


/*
 * GblNamHash -- hash a symbol name
 */

static int GblNameHash( char *name, size_t namlen )
{
    int     rtrn;

    rtrn = namlen;
    rtrn += toupper( name[ 0 ] );
    rtrn += toupper( name[ namlen / 2 ] );
    rtrn += toupper( name[ namlen - 1 ] );
    return( rtrn & (SYM_TAB_SIZE-1) );
}

static void GblCreate( imp_sym_handle *is, gbl_info *gbl )
{
    is->type = SH_GBL;
    is->im = GBL_MOD( gbl );
    is->name_off = GBL_NAME( gbl ) - (byte *)gbl - 1;
    is->u.gbl = gbl;
}

static int source_name( char *gstart, size_t glen,
                        char **rstart, size_t *rlen )
{
    int         type;

    type = __is_mangled_internal( gstart, glen );
    switch( type ) {
    case __NOT_MANGLED:
        *rstart = gstart;
        gstart = memchr( gstart, '@', glen );
        if( gstart != NULL ) {
            /* stupid MS stdcall with it's stupid trailing "@<num>" */
            glen = gstart - *rstart;
            type = __MANGLED;
        }
        *rlen = glen;
        break;
    case __MANGLED:
    case __MANGLED_INTERNAL:
        __unmangled_name( gstart, glen, (const char **)rstart, rlen );
        break;
    case __MANGLED_CTOR:
    case __MANGLED_DTOR:
        __scope_name( gstart, glen, 0, (const char **)rstart, rlen );
        break;
    }
    return( type );
}


/*
 * SearchGbl -- look up a global symbol name
 */
static search_result LkupGblName( section_info *inf, imp_mod_handle cim,
                        imp_mod_handle im, lookup_item *lc, void *d )
{
    gbl_link            *lnk;
    gbl_link            *lnk_array;
    gbl_info            *gbl;
    hash_link           lnk_off;
    int                 (*compare)();
    char                *gblname;
    size_t              gbllen;
    char                *nam;
    size_t              namlen;
    char                *snam;
    size_t              snamlen;
    char                *mangled;
    size_t              mangle_len;
    unsigned            entry;
    info_block          *blk;
    int                 lkup_dtor;
    int                 lkup_full;
    imp_sym_handle      *is;
    address             addr;
    search_result       sr;

    sr = SR_NONE;
    compare = lc->case_sensitive ? &memcmp : &memicmp;

    lkup_dtor = (lc->type == ST_DESTRUCTOR);
    /* only want to hash the source code portion of the name */
    switch( source_name( lc->name.start, lc->name.len, &snam, &snamlen ) ) {
    case __NOT_MANGLED:
        lkup_full = 0;
        nam = snam;
        namlen = snamlen;
        break;
    case __MANGLED_DTOR:
        lkup_dtor = 1;
        /* fall through */
    case __MANGLED_CTOR:
    case __MANGLED:
    case __MANGLED_INTERNAL:
        lkup_full = 1;
        nam = lc->name.start;
        namlen = lc->name.len;
        break;
    }
    for( blk = inf->gbl; blk != NULL; blk = blk->next ) {
        lnk_array = LINK( blk )->link;
        lnk_off = LINK( blk )->hash[ GblNameHash( snam, snamlen ) ];
        while( lnk_off != HL_END ) {
            lnk = MAKE_LP( lnk_array, lnk_off );
            gbl = lnk->gbl;
            if( lnk->dtor != lkup_dtor ) goto next_global;
            if( lkup_full ) {
                if( GBL_NAMELEN( gbl ) != namlen ) goto next_global;
            } else {
                if( lnk->src_len != namlen ) goto next_global;
            }
            if( im == NO_MOD ) {
                if( GBL_KIND( gbl ) & GBL_KIND_STATIC &&
                    cim != GBL_MOD( gbl ) ) goto next_global;
            } else {
                if( im != GBL_MOD( gbl ) ) goto next_global;
            }
            mangled = GBL_NAME( gbl );
            gblname = mangled;
            if( !lkup_full ) gblname += lnk->src_off;
            if( compare( gblname, nam, namlen ) != 0 ) goto next_global;
            if( lc->scope.start != NULL ) {
                mangle_len = GBL_NAMELEN( gbl );
                entry = 0;
                for( ;; ) {
                    if( !__scope_name( mangled, mangle_len, entry,
                             (const char **)&gblname, &gbllen ) ) goto next_global;
                    if( lc->scope.len == gbllen &&
                        compare( lc->scope.start, gblname, gbllen ) == 0 ) {
                        break;
                    }
                    ++entry;
                }
            }
            is = DCSymCreate( inf->ctl, d );
            is->im = GBL_MOD( gbl );
            MK_ADDR( addr, gbl->addr, inf->sect_id );
            /* need to see if there's a local symbol at the right
                    address and use that instead */
            if( cim == is->im ) {
                /* We've already checked the local symbols. It ain't there. */
                GblCreate( is, gbl );
            } else if( LookupLclAddr( inf->ctl, addr, is ) == SR_EXACT ) {
                SetGblLink( is, gbl );
            } else {
                GblCreate( is, gbl );
            }
            sr = SR_EXACT;
next_global:
            lnk_off = lnk->hash_off;
        }
    }
    return( sr );
}


search_result SearchGbl( imp_image_handle *ii, imp_mod_handle cim,
                        imp_mod_handle im, lookup_item *li, void *d )
{
    section_info        *inf;
    section_info        *end;
    search_result       sr;

    SET_GBLNAMEOFF( ii );
    sr = SR_NONE;
    end = &ii->sect[ii->num_sects];
    for( inf = ii->sect; inf < end; ++inf ) {
        if( LkupGblName( inf, cim, im, li, d ) != SR_NONE ) {
            sr = SR_EXACT;
        }
    }
    return( sr );
}


static int MachAddrComp( addr_ptr a, imp_mod_handle ma,
                         addr_ptr b, imp_mod_handle mb )
{
    if( a.segment < b.segment ) return( -1 );
    if( a.segment > b.segment ) return( 1 );
    if( a.offset < b.offset ) return( -1 );
    if( a.offset > b.offset ) return( 1 );
    if( ma < mb ) return( -1 );
    if( ma > mb ) return( 1 );
    return( 0 );
}

/*
 * LookupGblAddr -- look up a global address
 */
static search_result LkupGblAddr( info_block *inf, imp_sym_handle *is,
                                addr_ptr addr )
{
    gbl_link            *low, *high;
    gbl_link            *nearest;
    gbl_link            *target;
    gbl_info            *gbl;
    int                 comp_rtn;
    unsigned            diff;

    low = &LINK( inf )->link[0];
    nearest = NULL;
    high = LINK( inf )->end - 1;
    while( low <= high ) {
        /*
         * This next bit of grottiness is to avoid some useless and expensive
         * pointer scaling and to allow the code to work when the size
         * of the link block exceeds 32K.
         */
        diff = (byte *)high - (byte *)low;
        diff = (diff / 2) & ~(sizeof( gbl_link ) - 1);
        target = (gbl_link *)((byte *)low + diff);
        gbl = target->gbl;
        comp_rtn = MachAddrComp( addr, is->im, gbl->addr, GBL_MOD( gbl ) );
        if( comp_rtn < 0 ) {
            high = target - 1;
        } else if( comp_rtn > 0 ) {
            if( GBL_MOD( gbl )==is->im && gbl->addr.segment==addr.segment ) {
                nearest = target;
            }
            low = target + 1;
        } else {
            is->u.gbl = gbl;
            return( SR_EXACT );
        }
    }
    if( nearest == NULL ) return( SR_NONE );
    gbl = nearest->gbl;