dbgall.c

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

        }
        curr = RingStep( seg->pieces, curr );
    }
    size += prev->length;
    addfn( prev, 0, size, cookie, size != 0 );
}

extern void DBIComment( void )
/****************************/
{
}

extern void DBIAddModule( mod_entry *obj, section *sect )
/*******************************************************/
// called just before publics have been assigned addresses between p1 & p2
{
    if( LinkFlags & OLD_DBI_FLAG ) {
        ODBIAddModule( obj, sect );
    } else if( LinkFlags & DWARF_DBI_FLAG ) {
        DwarfAddModule( obj, sect );
    } else if( LinkFlags & CV_DBI_FLAG ) {
        CVAddModule( obj, sect );
    }
}

extern void DBIGenModule( void )
/******************************/
// called at the end of pass2 for a module
{
    if( MOD_NOT_DEBUGGABLE( CurrMod ) )
        return;
    if( LinkFlags & ANY_DBI_FLAG ) {
        Ring2Walk( CurrMod->segs, DBIGenLocal );
        DBIGenLines( CurrMod );
        if( LinkFlags & OLD_DBI_FLAG ) {
            ODBIGenModule();
        } else if( LinkFlags & DWARF_DBI_FLAG ) {
            DwarfGenModule();
        } else {
            CVGenModule();
        }
    }
}

extern void DBIDefClass( class_entry *cl, unsigned_32 size )
/**********************************************************/
// called during address calculation
{
    if( LinkFlags & OLD_DBI_FLAG ) {
        ODBIDefClass( cl, size );
    } else if( LinkFlags & DWARF_DBI_FLAG ) {
        DwarfDefClass( cl, size );
    } else if( LinkFlags & CV_DBI_FLAG ) {
        CVDefClass( cl, size );
    }
}

extern void DBIAddLocal( unsigned_16 info, offset length )
/********************************************************/
// called during pass 1 final segment processing.
{
    if( LinkFlags & OLD_DBI_FLAG ) {
        ODBIAddLocal( info, length );
    } else if( LinkFlags & CV_DBI_FLAG ) {
        CVAddLocal( info, length );
    }
}

static void DBIGenLocal( void *sdata )
/************************************/
// called during pass 2 segment processing
{
    if( LinkFlags & OLD_DBI_FLAG ) {
        ODBIGenLocal( sdata );
    }
}

extern void DBIModGlobal( void *_sym )
/************************************/
{
    symbol *sym = _sym;

    if( !IS_SYM_ALIAS( sym ) && !( sym->info & SYM_DEAD ) ) {
        if( IS_SYM_IMPORTED( sym )
            || ( sym->p.seg != NULL )
                && ( sym->p.seg->u.leader->dbgtype == NOT_DEBUGGING_INFO )
                && !sym->p.seg->isabs ) {
            DBIAddGlobal( sym );
        }
    }
}

extern void DBIAddGlobal( symbol *sym )
/*************************************/
// called during pass 1 symbol definition
{
    if( LinkFlags & OLD_DBI_FLAG ) {
        ODBIAddGlobal( sym );
    } else if( LinkFlags & DWARF_DBI_FLAG ) {
        DwarfAddGlobal( sym );
    } else if( LinkFlags & CV_DBI_FLAG ) {
        CVAddGlobal( sym );
    }
}

extern void DBIGenGlobal( symbol * sym, section *sect )
/*****************************************************/
// called during symbol address calculation (between pass 1 & pass 2)
// also called by loadpe between passes
{
    if( LinkFlags & OLD_DBI_FLAG ) {
        ODBIGenGlobal( sym, sect );
    } else if( LinkFlags & DWARF_DBI_FLAG ) {
        DwarfGenGlobal( sym, sect );
    } else if( LinkFlags & CV_DBI_FLAG ) {
        CVGenGlobal( sym, sect );
    }
#ifdef _NOVELL
    if( ( ( sym->info & SYM_STATIC ) == 0 )
        && ( LinkFlags & NOVELL_DBI_FLAG ) ) {
        NovDBIGenGlobal( sym );
    }
#endif
}

extern void DBIAddLines( segdata *seg, void *line, unsigned size, bool is32bit )
/******************************************************************************/
// called during pass 1 linnum processing
{
    lineinfo *  info;

    _PermAlloc( info, sizeof( lineinfo ) + size - 1 );
    info->seg = seg;
    info->size = size;
    if( is32bit )
        info->size |= LINE_IS_32BIT;
    memcpy( info->data, line, size );
    RingAppend( &CurrMod->lines, info );
}

extern unsigned CalcLineQty( unsigned size, bool is32bit )
/********************************************************/
{
    if( is32bit ) {
        size /= sizeof( ln_off_386 );
    } else {
        size /= sizeof( ln_off_286 );
    }
    return( size );
}

static bool DoLineWalk( void *_info, void *_cbfn )
/************************************************/
{
    void        (*cbfn)( segdata *, void *, unsigned, bool ) = _cbfn;
    lineinfo    *info = _info;
    unsigned    size;
    bool        is32bit;

    if( !info->seg->isdead ) {
        size = info->size & ~LINE_IS_32BIT;
        is32bit = ( ( info->size & LINE_IS_32BIT ) != 0 );
        cbfn( info->seg, info->data, size, is32bit );
    }
    return( FALSE );
}

extern void DBILineWalk( void *lines,
                         void (*cbfn)( segdata *, void *, unsigned, bool ) )
/**************************************************************************/
{
    RingLookup( lines, DoLineWalk, cbfn );
}

static void DBIGenLines( mod_entry *mod )
/***************************************/
// called during pass 2 linnum processing
{
    void (*fn)( segdata *, void *, unsigned, bool );

    if( LinkFlags & OLD_DBI_FLAG ) {
        fn = ODBIGenLines;
    } else if( LinkFlags & DWARF_DBI_FLAG ) {
        fn = DwarfGenLines;
    } else if( LinkFlags & CV_DBI_FLAG ) {
        fn = CVGenLines;
    }
    DBILineWalk( mod->lines, fn );
}

extern virt_mem DBIAlloc( unsigned long size )
/********************************************/
// handy virtual memory allocation routine used inside the debug info generators
{
    if( size == 0 )
        return( 0 );
    return( AllocStg( size ) );
}

extern void DBIAddrStart( void )
/******************************/
// called after address calculation is done.
{
#ifdef _NOVELL
    if( LinkFlags & NOVELL_DBI_FLAG ) {
        NovDBIAddrStart();
    }
#endif
    if( LinkFlags & CV_DBI_FLAG ) {
        CVAddrStart();
    }
    ProcAllSects( DBIAddrSectStart );
}

extern void DBIAddrSectStart( section * sect )
/********************************************/
// called for each section after address calculation is done.
{
    if( LinkFlags & OLD_DBI_FLAG ) {
        ODBIAddrSectStart( sect );
    } else if( LinkFlags & DWARF_DBI_FLAG ) {
        DwarfAddrSectStart( sect );
    }
}

extern void DBIP2Start( section *sect )
/*************************************/
// called for each section just before pass 2 starts
{
    if( LinkFlags & OLD_DBI_FLAG ) {
        ODBIP2Start( sect );
    } else if( LinkFlags & DWARF_DBI_FLAG ) {
        SectWalkClass( sect, DwarfGenAddrInfo );
    } else if( LinkFlags & CV_DBI_FLAG ) {
        SectWalkClass( sect, CVGenAddrInfo );
    }
}

extern void DBIFini( section *sect )
/**********************************/
// called after pass 2 is finished, but before load file generation
{
    if( LinkFlags & OLD_DBI_FLAG ) {
        ODBIFini( sect );
    } else if( LinkFlags & CV_DBI_FLAG ) {
        CVFini( sect );
    }
}

extern void DBISectCleanup( section *sect )
/*****************************************/
// called when burning down the house
{
    if( LinkFlags & OLD_DBI_FLAG ) {
        ODBISectCleanup( sect );
    }
}

extern void DBICleanup( void )
/****************************/
// called when burning down the house
{
    FreeGroups( DBIGroups );
}

extern void WriteDBI( void )
/**************************/
// called during load file generation.  It is assumed that the loadfile is
// positioned to the right spot.
{
    outfilelist symfile;
    outfilelist *save;

    if( !( LinkFlags & ANY_DBI_FLAG ) )
        return;
    if( SymFileName != NULL ) {
        InitBuffFile( &symfile, SymFileName, FALSE );
        OpenBuffFile( &symfile );
        save = Root->outfile;
        Root->outfile = &symfile;
    }
    if( LinkFlags & OLD_DBI_FLAG ) {
        OWriteDBI();
    } else if( LinkFlags & DWARF_DBI_FLAG ) {
        DwarfWriteDBI();
    } else if( LinkFlags & CV_DBI_FLAG ) {
        CVWriteDBI();
    }
    if( SymFileName != NULL ) {
        CloseBuffFile( &symfile );
        Root->outfile = save;
    }
}