dbg.c

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

              , vbuf.buf
              );
        if( sym->sym_type != NULL ) {
            DumpFullType( sym->sym_type );
        }
        VbufFree( &vbuf );
        if( sym->flag2 & SF2_TOKEN_LOCN ) {
            dumpLocation( &sym->locn->tl );
        }
        switch( sym->id ) {
        case SC_CLASS_TEMPLATE:
            dumpTemplateInfo( sym->u.tinfo );
            break;
        case SC_NAMESPACE:
            dumpNameSpaceInfo( sym->u.ns );
            break;
        }
    }
}

#define ENTRY_ERROR             "TYP_ERROR",
#define ENTRY_BOOL              "TYP_BOOL",
#define ENTRY_CHAR              "TYP_CHAR",
#define ENTRY_SCHAR             "TYP_SCHAR",
#define ENTRY_UCHAR             "TYP_UCHAR",
#define ENTRY_WCHAR             "TYP_WCHAR",
#define ENTRY_SSHORT            "TYP_SSHORT",
#define ENTRY_USHORT            "TYP_USHORT",
#define ENTRY_SINT              "TYP_SINT",
#define ENTRY_UINT              "TYP_UINT",
#define ENTRY_SLONG             "TYP_SLONG",
#define ENTRY_ULONG             "TYP_ULONG",
#define ENTRY_SLONG64           "TYP_SLONG64",
#define ENTRY_ULONG64           "TYP_ULONG64",
#define ENTRY_FLOAT             "TYP_FLOAT",
#define ENTRY_DOUBLE            "TYP_DOUBLE",
#define ENTRY_LONG_DOUBLE       "TYP_LONG_DOUBLE",
#define ENTRY_ENUM              "TYP_ENUM",
#define ENTRY_POINTER           "TYP_POINTER",
#define ENTRY_TYPEDEF           "TYP_TYPEDEF",
#define ENTRY_CLASS             "TYP_CLASS",
#define ENTRY_BITFIELD          "TYP_BITFIELD",
#define ENTRY_FUNCTION          "TYP_FUNCTION",
#define ENTRY_ARRAY             "TYP_ARRAY",
#define ENTRY_DOT_DOT_DOT       "TYP_DOT_DOT_DOT",
#define ENTRY_VOID              "TYP_VOID",
#define ENTRY_MODIFIER          "TYP_MODIFIER",
#define ENTRY_MEMBER_POINTER    "TYP_MEMBER_POINTER",
#define ENTRY_GENERIC           "TYP_GENERIC",

static char *id_names[] = {
    #include "type_arr.h"
};

static char unknown_type[] = "***UNKNOWN**=xx";

void DumpType(                  // DUMP TYPE ENTRY
    TYPE tp )                   // - type pointer
{
    char *id;                   // - id for symbol

    if( tp == NULL ) {
        printf( "NULL type\n" );
        return;
    }
    if( tp->id >= TYP_MAX ) {
        utoa( tp->id, unknown_type + sizeof( unknown_type ) - 2, 16 );
        id = unknown_type;
    } else {
        id = id_names[ tp->id ];
    }
    printf( "TYPE"          F_BADDR
            " next"         F_PTR
            " id="          F_STRING
            " flag"         F_HEX_1
            " of"           F_PTR
            " u1"           F_PTR
            " u2"           F_PTR
            F_EOL
          , tp
          , tp->next
          , id
          , tp->flag
          , tp->of
          , tp->u.f.args
          , tp->u.f.pragma
          );
}

static void dumpFnType(         // DUMP EXTRA INFO FOR FUNCTION
    TYPE tp )                   // - type
{
    unsigned index;
    TYPE *  arg_list;

    if( ( tp != NULL ) && ( tp->u.f.args != NULL ) ) {
        for( arg_list = tp->u.f.args->type_list, index = 0
           ; index < tp->u.f.args->num_args
           ; ++ arg_list, ++ index ) {
            printf( "function arg[%d]:\n", index + 1 );
            DumpFullType( *arg_list );
        }
        printf( "--end of function arguments--" F_EOL );
    }
}


static void dumpBaseClass(      // DUMP BASE_CLASS
    void *_base )               // - points to information
{
    BASE_CLASS *base = _base;
    printf( "    BASECLASS" F_BADDR
            " next"         F_PTR
            " type"         F_PTR
            " delta"        F_TGT_OFFSET
            " vb_index"     F_TGT_OFFSET
            " flag"         F_HEX_1
                            F_EOL
            , base
            , base->next
            , base->type
            , base->delta
            , base->vb_index
            , base->flag
            );
}


void DumpClassInfo(             // DUMP CLASSINFO
    CLASSINFO *ci )             // - class information
{
    char *class_name;
    if( ci == NULL ) return;
    if( ci->name == NULL ) {
        class_name = "**UN-NAMED**";
    } else {
        class_name = ci->name;
    }
    printf( "    CLASSINFO" F_BADDR
            " bases"        F_PTR
            " friends"      F_PTR
            " name"         F_STRING
            " refno"        F_HEX_4
                            F_NL "  "
            " size"         F_TGT_OFFSET
            " vsize"        F_TGT_OFFSET
            " vb_offset"    F_HEX_4
            " vf_offset"    F_HEX_4
                            F_NL "  "
            " last_vfn"     F_HEX_2
            " last_vbase"   F_HEX_2
            " index"        F_HEX_2
            " max_align"    F_HEX_2
                            F_NL "  "
            " has_ctor"     F_HEX_2
            " has_dtor"     F_HEX_2
            " has_pure"     F_HEX_2
            " has_data"     F_HEX_2
            " has_vfn"      F_HEX_2
                            F_NL "  "
            " has_vcdtor"   F_HEX_2
            " has_vfptr"    F_HEX_2
            " has_vbptr"    F_HEX_2
                            F_NL "  "
            " needs_ctor"   F_HEX_2
            " needs_dtor"   F_HEX_2
            " needs_vdtor"  F_HEX_2
            " needs_assign" F_HEX_2
                            F_NL "  "
            " defined"      F_HEX_2
            " unnamed"      F_HEX_2
            " anonymous"    F_HEX_2
            " corrupted"    F_HEX_2
                            F_NL "  "
            " abstract"     F_HEX_2
            " abstract_OK"  F_HEX_2
                            F_NL "  "
            " const_copy"   F_HEX_2
            " const_assign" F_HEX_2
            " const_ref"    F_HEX_2
                            F_NL "  "
            " ctor_defined" F_HEX_2
            " copy_defined" F_HEX_2
            " dtor_defined" F_HEX_2
            " assign_defined" F_HEX_2
                            F_NL "  "
            " ctor_gen"     F_HEX_2
            " copy_gen"     F_HEX_2
            " dtor_gen"     F_HEX_2
            " assign_gen"   F_HEX_2
                            F_NL "  "
            " ctor_user_code" F_HEX_2
            " copy_user_code" F_HEX_2
            " dtor_user_code" F_HEX_2
            " assign_user_code" F_HEX_2
                            F_NL "  "
            " ctor_user_code_checked" F_HEX_2
            " copy_user_code_checked" F_HEX_2
                            F_NL "  "
            " dtor_user_code_checked" F_HEX_2
            " assign_user_code_checked" F_HEX_2
                            F_NL "  "
            " lattice" F_HEX_2
                            F_EOL
          , ci
          , ci->bases
          , ci->friends
          , class_name
          , ci->refno
          , ci->size
          , ci->vsize
          , ci->vb_offset
          , ci->vf_offset
          , ci->last_vfn
          , ci->last_vbase
          , ci->index
          , ci->max_align
          , ci->has_ctor
          , ci->has_dtor
          , ci->has_pure
          , ci->has_data
          , ci->has_vfn
          , ci->has_vcdtor
          , ci->has_vfptr
          , ci->has_vbptr
          , ci->needs_ctor
          , ci->needs_dtor
          , ci->needs_vdtor
          , ci->needs_assign
          , ci->defined
          , ci->unnamed
          , ci->anonymous
          , ci->corrupted
          , ci->abstract
          , ci->abstract_OK
          , ci->const_copy
          , ci->const_assign
          , ci->const_ref
          , ci->ctor_defined
          , ci->copy_defined
          , ci->dtor_defined
          , ci->assign_defined
          , ci->ctor_gen
          , ci->copy_gen
          , ci->dtor_gen
          , ci->assign_gen
          , ci->ctor_user_code
          , ci->copy_user_code
          , ci->dtor_user_code
          , ci->assign_user_code
          , ci->ctor_user_code_checked
          , ci->copy_user_code_checked
          , ci->dtor_user_code_checked
          , ci->assign_user_code_checked
          , ci->lattice
          );
}


static void dumpClassType(      // DUMP EXTRA INFO FOR CLASS
    TYPE tp )                   // - type
{
    CLASSINFO *ci;              // - class information

    ci = tp->u.c.info;
    DumpClassInfo( ci );
    RingWalk( ci->bases, &dumpBaseClass );
}

void PrintFullType(             // PRINT FULL TYPE INFORMATION
    TYPE tp )                   // - type pointer
{
    VBUF prefix, suffix;

    FormatType( tp, &prefix, &suffix );
    printf( "     Type[%x]: %s<id> %s" F_EOL, tp, prefix.buf, suffix.buf );
    VbufFree( &prefix );
    VbufFree( &suffix );
}

void DumpExpandedType(          // DUMP EXPANDED TYPE
    TYPE tp )                   // - type
{
    if( tp == NULL ) {
        printf( "NULL type\n" );
        return;
    }
    while( tp != NULL ) {
        DumpType( tp );
        if( tp->id == TYP_FUNCTION ) {
            dumpFnType( tp );
        } else if( tp->id == TYP_CLASS ) {
            dumpClassType( tp );
        }
        tp = tp->of;
    }
}

void DumpFullType(              // DUMP FULL TYPE INFORMATION
    TYPE tp )                   // - type
{
    if( PragDbgToggle.dump_noformat ) {
        DumpExpandedType( tp );
    } else {
        PrintFullType( tp );
    }
}

void DumpSymbolName(            // DUMP SYMBOL_NAME ENTRY
    SYMBOL_NAME sn )            // - symbol name entry
{
    printf( "SYMBOL_NAME"   F_BADDR
            " next"         F_PTR
            " name_type"    F_PTR
            " name_syms"    F_PTR
                            F_NL
            " name"         F_PTR
            "="             F_STRING
                            F_EOL
          , sn
          , sn->next
          , sn->name_type
          , sn->name_syms
          , sn->name
          , sn->name
          );
}


static void print_delimit_line( // PRINT DELIMITER LINE
    void )
{
    puts( "--------------------------------------" );
}


void DumpCommentary(            // DUMP COMMENTARY LINE
    const char *comment )       // - comment
{
    print_delimit_line();
    puts( comment );
}


void DumpSymInfo(               // DUMP COMPLETE INFO FOR SYMBOL
    SYMBOL sym )                // - symbol
{
    print_delimit_line();
    DumpSymbol( sym );
    if( sym->name != NULL ) {
        DumpSymbolName( sym->name );
    }
}


static void dumpFriendRef(      // DUMP REFERENCE TO FRIEND SCOPE
    void *_fr )                 // - the reference
{
    FRIEND *fr = _fr;
    printf( "   FRIEND"     F_BADDR
            " next"         F_PTR
            " sym"          F_PTR
            F_EOL
          , fr
          , fr->next
          , fr->sym
          );
}


static void dumpSymbolNameInfo( // DUMP SYMBOL_NAME ENTRY
    SYMBOL_NAME sn )            // - the entry
{
    DumpSymbolName( sn );
    DumpSymbol( sn->name_type );
    RingWalk( sn->name_syms, &DumpSymbol );
}


void DumpScope(                 // DUMP SCOPE INFO FOR SYMBOL
    SCOPE scope )               // - scope
{
    static char *scope_names[] = {
        #define SCOPE_DEF(a,b) # a
        SCOPE_DEFS
        #undef SCOPE_DEF
    };

    char *id;

    print_delimit_line();
    if( scope->id >= SCOPE_MAX ) {
        id = "***UNKNOWN***";
    } else {
        id = scope_names[ scope->id ];
    }
    printf( "SCOPE"         F_BADDR
            " enclosing"    F_PTR
            " names"        F_PTR
            " owner"        F_PTR
                            F_NL
            " id"           F_STRING
            " keep"         F_HEX_2
            " dtor_reqd"    F_HEX_2
            " dtor_naked"   F_HEX_2
            " try_catch"    F_HEX_2
            " in_unnamed"   F_HEX_2
            F_EOL
          , scope
          , scope->enclosing
          , scope->names
          , scope->owner.sym
          , id
          , scope->keep
          , scope->dtor_reqd
          , scope->dtor_naked
          , scope->try_catch
          , scope->in_unnamed
          );
    switch( scope->id ) {
    case SCOPE_CLASS:
        { TYPE ctype;     // class type
        ctype = ScopeClass( scope );
        if( ctype != NULL ) {
            DumpClassInfo( ctype->u.c.info );
        }
        } break;
    case SCOPE_FILE:
        dumpNameSpaceInfo( scope->owner.ns );
        break;
    }
    ScopeWalkNames( scope, &dumpSymbolNameInfo );
    RingWalk( ScopeFriends( scope ), &dumpFriendRef );
    RingWalk( ScopeInherits( scope ), &dumpBaseClass );
}


static void dump_sym_scope(     // DUMP SCOPE FOR A SYMBOL
    SYMBOL sym )                // - symbol
{
    TYPE tp;                    // - TYPE for scope symbol

    if( sym != NULL ) {
        for( tp = sym->sym_type; tp != NULL; tp = tp->of ) {
            if( tp->id == TYP_CLASS ) {
                DumpScopeInfo( tp->u.c.scope );
                break;
            }
        }
    }
}


static void dumpFriend(         // DUMP A FRIEND SCOPE
    void *_fr )                 // - symbol for the friend scope
{
    FRIEND *fr = _fr;
    dump_sym_scope( fr->sym );
}


void DumpScopeInfo(             // DUMP INFORMATION FOR SCOPE
    SCOPE scope )               // - starting scope
{
    DumpScope( scope );
    RingWalk( ScopeFriends( scope ), &dumpFriend );
    RingWalk( ScopeInherits( scope ), &dumpBaseClass );
}


typedef struct scope_defn SCOPE_DEFN;
struct scope_defn               // USED TO REMEMBER DEFINED SCOPES
{   SCOPE_DEFN *next;           // - next in ring
    SCOPE defn;                 // - a defined scope
};

static SCOPE_DEFN *scopes;      // ring of defined scopes


void DbgRememberScope(          // REMEMBER A NEWLY-DEFINED SCOPE
    SCOPE new_scope )           // - scope
{
    SCOPE_DEFN *new_defn;

    new_defn = RingAlloc( &scopes, sizeof( SCOPE_DEFN ) );
    new_defn->defn = new_scope;
}

static boolean findScope( void *e, const void *s )
{
    SCOPE_DEFN *holder = e;

    if( holder->defn == s ) {
        return( TRUE );
    }
    return( FALSE );
}

void DbgForgetScope(            // SCOPE is useless, so don't dump it
    SCOPE forget_me )
{
    SCOPE_DEFN *going_away;

    going_away = RingLookup( scopes, findScope, forget_me );
    RingDealloc( &scopes, going_away );
}