Exemple #1
0
search_result DoLookupSym( imp_image_handle *ii,
                symbol_source ss, void *source, lookup_item *li,
                location_context *lc, void *d )
{
    int         (*cmp)(const void *, const void *, size_t);
    msym_sym    *s;

    source = source;
    switch( ss ) {
    case SS_MODULE:
    case SS_SCOPED:
        break;
    default:
        return( SR_NONE );
    }
    if( li->type != ST_NONE ) return( SR_NONE );
    if( li->scope.start != NULL ) return( SR_NONE );
    if( li->case_sensitive ) {
        cmp = memcmp;
    } else {
        cmp = memicmp;
    }
    for( s = ii->gbl; s != NULL; s = s->next ) {
        if( s->len == li->name.len && cmp( s->name, li->name.start, s->len ) == 0 ) {
            DCSymCreate( ii, d )->p = s;
            return( SR_EXACT );
        }
    }
    return( SR_NONE );
}
static bool AMemLookup( dr_handle var, int index, void *_d )
/**********************************************************/
{
    type_wlk_lookup *d = _d;
    imp_sym_handle  *is;
    char            *name;
    unsigned        len;

    name =  DRGetName( var );
    if( name == NULL ) {
        DCStatus( DS_FAIL );
        return( FALSE );
    }
    len = strlen( name );
    if( len == d->li->name.len && d->comp( name, d->li->name.start, len ) == 0 ) {
        is = DCSymCreate( d->com.ii, d->com.d );
        SetSymHandle( (type_wlk *)d, is );
        is->sym = var;
        switch( index ) {
        case 0:
            is->sclass = SYM_MEM;
            break;
        case 2:
            is->sclass = SYM_MEMVAR;     // static member
            break;
        case 3:
            if( DRGetVirtuality( var ) == DR_VIRTUALITY_VIRTUAL  ) {
                is->sclass = SYM_VIRTF;   // virtual func
            } else if( !DRIsSymDefined( var ) ) {
                is->sclass = SYM_MEMF;    // memfunc decl
            } else {
                is->sclass = SYM_MEMVAR;   // inlined defn treat like a var
            }
            break;
        }
        d->sr = SR_EXACT;
    }
    DCFree( name );
    return( TRUE );
}
static bool AEnumMemLookup( dr_handle var, int index, void *_d )
/**************************************************************/
{
    type_wlk_lookup *d = _d;
    imp_sym_handle  *is;
    char            *name;
    unsigned        len;

    index = index;
    name =  DRGetName( var );
    if( name == NULL ) {
        DCStatus( DS_FAIL );
        return( FALSE );
    }
    len = strlen( name );
    if( len == d->li->name.len && d->comp( name, d->li->name.start, len ) == 0 ) {
        is = DCSymCreate( d->com.ii, d->com.d );
        SetSymHandle( (type_wlk *)d, is );
        is->sym = var;
        d->sr = SR_EXACT;
    }
    DCFree( name );
    return( TRUE );
}
Exemple #4
0
static search_result DoLookupSym( imp_image_handle *ii, symbol_source ss,
                         void *source, lookup_item *li, location_context *lc, void *d )
{
    imp_mod_handle      im;
    search_result       sr;
    lookup_item         sym_li;
    char                *buff;
    const char          *src;
    char                *dst;
    size_t              len;
    unsigned            op_len;
    imp_sym_handle      *scope_is;

    lc = lc;
    if( GETU8( li->name.start ) == SH_ESCAPE ) {
        CollectSymHdl( li->name.start, DCSymCreate( ii, d ) );
        return( SR_EXACT );
    }
    if( li->type == ST_NAMESPACE )
        return( SR_NONE );
    sym_li = *li;
    if( ss == SS_SCOPESYM ) {
        char    *scope_name;
        scope_is = source;
        len = ImpInterface.SymName( ii, scope_is, NULL, SN_SOURCE, NULL, 0 );
        scope_name = __alloca( len + 1 );
        ImpInterface.SymName( ii, scope_is, NULL, SN_SOURCE, scope_name, len + 1 );
        sym_li.scope.start = scope_name;
        sym_li.scope.len = len;
        ss = SS_MODULE;
        sym_li.mod = IMH2MH( scope_is->im );
        source = &sym_li.mod;
    }
    if( sym_li.type == ST_OPERATOR ) {
        src = sym_li.name.start;
        len = sym_li.name.len;
        buff = __alloca( len + 20 );
        dst = buff;
        for( ;; ) {
            if( len == 0 )
                break;
            if( src == sym_li.source.start ) {
                op_len = __mangle_operator( src, sym_li.source.len, buff );
                if( op_len == 0 ) {
                    DCStatus( DS_ERR|DS_INVALID_OPERATOR );
                    return( SR_NONE );
                }
                dst += op_len;
                src += sym_li.source.len;
                len -= sym_li.source.len;
            } else {
                *dst++ = *src++;
                --len;
            }
        }
        sym_li.name.len = dst - buff;
        sym_li.name.start = buff;
    }
    sr = SR_NONE;
    im = IMH_NOMOD;
    switch( ss ) {
    case SS_SCOPED:
        if( ImpInterface.AddrMod( ii, *(address *)source, &im ) == SR_NONE ) {
            im = MH2IMH( sym_li.mod );
        } else if( MH2IMH( sym_li.mod ) == IMH_NOMOD || MH2IMH( sym_li.mod ) == im ) {
            if( !sym_li.file_scope && sym_li.type == ST_NONE ) {
                sr = SearchLclScope( ii, im, (address *)source, &sym_li, d );
            }
        } else {
            im = MH2IMH( sym_li.mod );
        }
        if( im != IMH_NOMOD && sr == SR_NONE ) {
            sr = SearchFileScope( ii, im, &sym_li, d );
        }
        break;
    case SS_MODULE:
        im = *(imp_mod_handle *)source;
        if( MH2IMH( sym_li.mod ) == IMH_NOMOD || MH2IMH( sym_li.mod ) == im ) {
            sr = SearchFileScope( ii, im, &sym_li, d );
        }
        break;
    case SS_TYPE:
        if( MH2IMH( sym_li.mod ) != IMH_NOMOD )
            return( SR_NONE );
        switch( sym_li.type ) {
        case ST_TYPE:
        case ST_STRUCT_TAG:
        case ST_CLASS_TAG:
        case ST_UNION_TAG:
        case ST_ENUM_TAG:
            return( SR_NONE );
        }
        return( SearchMbr( ii, (imp_type_handle *)source, &sym_li, d ) );
    }
    if( sr == SR_NONE ) {
        switch( sym_li.type ) {
        case ST_NONE:
        case ST_DESTRUCTOR:
        case ST_OPERATOR:
            sr = SearchGbl( ii, im, MH2IMH( sym_li.mod ), &sym_li, d );
            break;
        }
    }
    return( sr );
}
Exemple #5
0
search_result DoLookupSym( imp_image_handle *ii, symbol_source ss,
                         void *source, lookup_item *li, location_context *lc, void *d )
{
    imp_mod_handle      im;
    search_result       sr;
    lookup_item         item;
    char                *buff;
    char                *src;
    char                *dst;
    unsigned            len;
    unsigned            op_len;
    imp_sym_handle      *scope_is;

    if( *li->name.start == SH_ESCAPE ) {
        CollectSymHdl( (byte *)li->name.start, DCSymCreate( ii, d ) );
        return( SR_EXACT );
    }
    if( li->type == ST_NAMESPACE ) return( SR_NONE );
    item = *li;
    if( ss == SS_SCOPESYM ) {
        scope_is = source;
        len = ImpInterface.sym_name( ii, scope_is, NULL, SN_SOURCE, NULL, 0 );
        item.scope.start = __alloca( len + 1 );
        ImpInterface.sym_name( ii, scope_is, NULL, SN_SOURCE, item.scope.start, len + 1 );
        item.scope.len = len;
        ss = SS_MODULE;
        item.mod = scope_is->im;
        source = &item.mod;
    }
    if( item.type == ST_OPERATOR ) {
        src = item.name.start;
        len = item.name.len;
        buff = __alloca( len + 20 );
        dst = buff;
        for( ;; ) {
            if( len == 0 ) break;
            if( src == item.source.start ) {
                op_len = __mangle_operator( src, item.source.len, buff );
                if( op_len == 0 ) {
                    DCStatus( DS_ERR|DS_INVALID_OPERATOR );
                    return( SR_NONE );
                }
                dst += op_len;
                src += item.source.len;
                len -= item.source.len;
            } else {
                *dst++ = *src++;
                --len;
            }
        }
        item.name.len = dst - buff;
        item.name.start = buff;
    }
    sr = SR_NONE;
    switch( ss ) {
    case SS_SCOPED:
        if( ImpInterface.addr_mod( ii, *(address *)source, &im ) == SR_NONE ) {
            im = item.mod;
        } else if( item.mod == NO_MOD || item.mod == im ) {
            if( !item.file_scope && item.type == ST_NONE ) {
                sr = SearchLclScope( ii, im, (address *)source, &item, d );
            }
        } else {
            im = item.mod;
        }
        if( im != NO_MOD && sr == SR_NONE ) {
            sr = SearchFileScope( ii, im, &item, d );
        }
        break;
    case SS_MODULE:
        im = *(imp_mod_handle *)source;
        if( item.mod == NO_MOD || item.mod == im ) {
            sr = SearchFileScope( ii, im, &item, d );
        }
        break;
    case SS_TYPE:
        if( item.mod != NO_MOD ) return( SR_NONE );
        switch( item.type ) {
        case ST_TYPE:
        case ST_STRUCT_TAG:
        case ST_CLASS_TAG:
        case ST_UNION_TAG:
        case ST_ENUM_TAG:
            return( SR_NONE );
        }
        return( SearchMbr( ii, (imp_type_handle *)source, &item, d ) );
    }
    if( sr == SR_NONE ) {
        switch( item.type ) {
        case ST_NONE:
        case ST_DESTRUCTOR:
        case ST_OPERATOR:
            sr = SearchGbl( ii, im, (imp_mod_handle)item.mod, &item, d );
            break;
        }
    }
    return( sr );
}
Exemple #6
0
/*
 * SearchGbl -- look up a global symbol name
 */
static search_result LkupGblName( section_info *inf, imp_mod_handle cim,
                        imp_mod_handle im, lookup_item *li, void *d )
{
    gbl_link            *lnk;
    gbl_link            *lnk_array;
    gbl_info            *gbl;
    hash_link           lnk_off;
    int                 (*compare)(void const*,void const*,size_t);
    char                *gblname;
    size_t              gbllen;
    char                *nam = NULL;
    size_t              namlen = 0;
    char                *snam;
    size_t              snamlen;
    char                *mangled;
    size_t              mangle_len;
    unsigned            entry;
    info_block          *blk;
    int                 lkup_dtor;
    int                 lkup_full = 0;
    imp_sym_handle      *is;
    address             addr;
    search_result       sr;

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

    lkup_dtor = (li->type == ST_DESTRUCTOR);
    /* only want to hash the source code portion of the name */
    switch( source_name( li->name.start, li->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 = li->name.start;
        namlen = li->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 == IMH_NOMOD ) {
                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( li->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( li->scope.len == gbllen &&
                        compare( li->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 );
}
Exemple #7
0
imp_sym_handle * DIGCLIENT XDIPCliSymCreate( imp_image_handle *ii, void *d )
{
    return( DCSymCreate( ii, d ) );
}