drtype.c

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

                break;
            case DW_ATE_boolean:
                info->kind = DR_TYPEK_BOOL;
                info->modifier.sign = FALSE;
                break;
            case DW_ATE_complex_float:
                info->kind = DR_TYPEK_COMPLEX;
                break;
            case DW_ATE_float:
                info->kind = DR_TYPEK_REAL;
                break;
            case DW_ATE_signed:
                info->kind = DR_TYPEK_INTEGER;
                info->modifier.sign = TRUE;
                break;
            case DW_ATE_signed_char:
                info->kind  = DR_TYPEK_CHAR;
                info->modifier.sign = TRUE;
                break;
            case DW_ATE_unsigned:
                info->kind = DR_TYPEK_INTEGER;
                info->modifier.sign = FALSE;
                break;
            case DW_ATE_unsigned_char:
                info->kind  = DR_TYPEK_CHAR;
                info->modifier.sign = FALSE;
                break;
            default:
                goto error;
            }
        } else {
            info->modifier.sign = FALSE;
        }
        break;
    case DR_MOD_ADDR:
        if( !DWRGetConstAT( abbrev, entry, DW_AT_address_class, &value ) ) {
            value = DW_ADDR_none;
        }
        switch( value ) {
        case DW_ADDR_none:
            info->size = DWRGetAddrSize( DWRFindCompileUnit( entry ) );
            info->modifier.ptr = DR_PTR_none;
            break;
        case DW_ADDR_near16:
            info->size = 2;
            info->modifier.ptr = DR_PTR_near16;
            break;
        case DW_ADDR_far16:
            info->size = 4;
            info->modifier.ptr = DR_PTR_far16;
            break;
        case DW_ADDR_huge16:
            info->size = 4;
            info->modifier.ptr = DR_PTR_huge16;
            break;
        case DW_ADDR_near32:
            info->size = 4;
            info->modifier.ptr = DR_PTR_near32;
            break;
        case DW_ADDR_far32:
            info->size = 6;
            info->modifier.ptr = DR_PTR_far32;
            break;
        default:
            goto error;
        }
        break;
    }
    return( TRUE );
error:
    return( FALSE );
}

extern dr_ptr DRGetAddrClass( dr_handle entry )
/*********************************************/
{
    dr_handle   abbrev;
    dr_ptr      ret;
    int         value;

    abbrev = DWRGetAbbrev( &entry );
    if( DWRScanForAttrib( &abbrev, &entry, DW_AT_address_class ) ) {
        value = DWRReadConstant( abbrev, entry );
    } else {
        value = DW_ADDR_none;
    }
    switch( value ) {
    case DW_ADDR_none:
        ret = DR_PTR_none;
        break;
    case DW_ADDR_near16:
        ret = DR_PTR_near16;
        break;
    case DW_ADDR_far16:
        ret = DR_PTR_far16;
        break;
    case DW_ADDR_huge16:
        ret = DR_PTR_huge16;
        break;
    case DW_ADDR_near32:
        ret = DR_PTR_near32;
        break;
    case DW_ADDR_far32:
        ret = DR_PTR_far32;
        break;
    }
    return( ret );
}

extern dr_handle DRGetTypeAT( dr_handle entry )
/*********************************************/
{
    dr_handle   abbrev;
    dr_handle   type;

    abbrev = DWRGetAbbrev( &entry );
    type = NULL;
    if( DWRScanForAttrib( &abbrev, &entry, DW_AT_type ) != 0 ) {
        type = DWRReadReference( abbrev, entry );
    }
    return( type );
}

extern dr_array_stat DRGetArrayInfo( dr_handle entry, dr_array_info *info )
/*************************************************************************/
{
    dr_handle     abbrev;
    dr_array_stat stat;
    uint_32       value;
    unsigned_8    haschild;
    dw_tagnum     tag;

    stat = DR_ARRAY_NONE;
    abbrev = DWRVMReadULEB128( &entry );
    abbrev = DWRLookupAbbrev( entry, abbrev );
    tag = DWRVMReadULEB128( &abbrev );
    haschild = DWRVMReadByte( abbrev );
    ++abbrev; /* skip child flag */
    if( DWRGetConstAT( abbrev, entry, DW_AT_ordering, &value ) ) {
        info->ordering = value;
        stat |= DR_ARRAY_ORDERING;
    }
    if( DWRGetConstAT( abbrev, entry, DW_AT_byte_size, &value ) ) {
        info->byte_size = value;
        stat |= DR_ARRAY_BYTE_SIZE;
    }
    if( DWRGetConstAT( abbrev, entry, DW_AT_stride_size, &value ) ) {
        info->stride_size = value;
        stat |= DR_ARRAY_STRIDE_SIZE;
    }
    if( DWRGetConstAT( abbrev, entry, DW_AT_count, &value ) ) {
        info->count = value;
        stat |= DR_ARRAY_COUNT;
    }
    if( haschild ) {
        DWRSkipAttribs( abbrev, &entry );
        info->child = entry;
    } else {
        info->child = NULL;
    }
    return( stat );
}

extern dr_handle DRSkipTypeChain( dr_handle tref )
/************************************************/
// skip modifiers and typedefs
{
    dr_handle   abbrev;
    dr_handle   entry;
    uint_32     tag;

    for( ;; ) {
        entry = tref;
        abbrev = DWRVMReadULEB128( &entry );
        abbrev = DWRLookupAbbrev( entry, abbrev );
        tag = DWRVMReadULEB128( &abbrev );
        ++abbrev; /* skip child flag */
        switch( tag ) {
        case DW_TAG_const_type:
        case DW_TAG_volatile_type:
        case DW_TAG_packed_type:
        case DW_TAG_typedef:
            break;
        default:
            goto end_loop;
        }
        if( DWRScanForAttrib( &abbrev, &entry, DW_AT_type ) != 0 ) {
            entry = DWRReadReference( abbrev, entry );
            tref = entry;
        } else {
            tref = NULL;
            goto end_loop;
        }
    } end_loop:;
    return( tref );
}

static unsigned_16 const MemTag[DR_WLKBLK_STRUCT] = {
    DW_TAG_member, DW_TAG_inheritance, DW_TAG_variable, DW_TAG_subprogram, 0
};

extern int DRWalkStruct( dr_handle mod,  DRWLKBLK *wlks, void *d )
/****************************************************************/
// wlks[0] == member func, wlks[1] inherit func, wlks[2] default
{
    int ret;

    ret = DWRWalkChildren( mod, MemTag, wlks, d );
    return( ret );
}

static unsigned_16 const ArrayTag[DR_WLKBLK_ARRSIB] = {
    DW_TAG_subrange_type, DW_TAG_enumerator, 0
};

extern int DRWalkArraySibs( dr_handle mod,  DRWLKBLK *wlks, void *d )
/************************************************&******************/
// wlks[0] == subrange [1] = enumerator , 0 = Null
{
    int ret;

    ret = DWRWalkSiblings( mod, ArrayTag, wlks, d );
    return( ret );
}

static unsigned_16 const EnumTag[DR_WLKBLK_ENUMS] = {
    DW_TAG_enumerator, 0
};

extern int DRWalkEnum( dr_handle mod,  DRWLKBLK wlk, void *d )
/************************************************************/
// wlks[0] == Enum  func, [1] Null
{
    int         ret;
    DRWLKBLK    wlks[2];

    wlks[0] = wlk;
    wlks[1] = NULL;
    ret = DWRWalkChildren( mod, EnumTag, wlks, d );
    return( ret );
}

extern int DRConstValAT( dr_handle var, uint_32 *ret )
/****************************************************/
{
    dr_handle   abbrev;
    unsigned    form;
    uint_32     val;
    dwr_formcl  formcl;

    abbrev = DWRGetAbbrev( &var );
    if( DWRScanForAttrib( &abbrev, &var, DW_AT_const_value ) != 0 ) {
        form = DWRVMReadULEB128( &abbrev );
        for( ;; ) {
            formcl = DWRFormClass( form );
            switch( formcl ) {
            case DWR_FORMCL_indirect:
                form = DWRVMReadULEB128( &var );
                break;
            case DWR_FORMCL_data:
                val = ReadConst( form, var );
                *ret = val;
                goto found;
            default:
                goto not_found;
            }
        }
    }
not_found:
    return( FALSE );
found:
    return( TRUE );
}