dbsyms.c

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

        if( fno == 0 && col == 1 ){
            DBLineNum( line );
        }
    }else{
        idx = CueAdd( fno, line, col );
        SrcLine = idx;
    }
}

extern  void _CGAPI DBGenStMem( sym_handle sym, dbg_loc loc ) {
/*********************************************************/
#ifndef NDEBUG
    EchoAPI( "DBGenStMem( %s,%i)\n", sym, loc );
#endif
    if( _IsModel( DBG_DF ) ) {
        DFGenStatic( sym, loc );
    }else if( _IsModel( DBG_CV ) ) {
        CVGenStatic( sym, loc, TRUE );
    }else{
    }
}

static  void    AddLocal( dbg_local **owner, dbg_local *new  ){
/************************************************************/

    dbg_local *curr;

    while( (curr = *owner) != NULL ) {
        owner = &curr->link;
    }
    new->link = NULL;
    *owner = new;
}

extern  void _CGAPI DBGenSym( sym_handle sym, dbg_loc loc, int scoped ) {
/***********************************************************************/

    fe_attr     attr;
    dbg_block   *blk;
    dbg_local   *new;

#ifndef NDEBUG
    EchoAPI( "DBGenSym( %s, %i, %i )\n", sym, loc, scoped );
#endif
    if( _IsModel( DBG_LOCALS ) ) {
        attr = FEAttr( sym );
        if( (attr & FE_IMPORT) == 0 ) {
            if( attr & FE_PROC ) {
                CurrProc->state.attr |= ROUTINE_WANTS_DEBUGGING;
                _Alloc( CurrProc->targ.debug, sizeof( dbg_rtn ) );
                CurrProc_debug->blk = NULL;
                CurrProc_debug->parms = NULL;
                CurrProc_debug->reeturn = LocDupl( loc );
                CurrProc_debug->obj_type = DBG_NIL_TYPE;
                CurrProc_debug->obj_loc = NULL;
                MkBlock();
            } else if( scoped ) {
                blk = CurrProc_debug->blk;
                _Alloc( new, sizeof( dbg_local ) );
                new->sym = sym;
                new->loc = LocDupl( loc );
                new->kind = DBG_SYM_VAR;
                AddLocal( &blk->locals, new );
            } else {
                if( _IsModel( DBG_DF ) ) {
                    DFGenStatic( sym, loc );
                }else if( _IsModel( DBG_CV ) ) {
                    CVGenStatic( sym, loc, FALSE );
                }else{

                 #if _TARGET &( _TARG_IAPX86 | _TARG_80386 )
                    WVGenStatic( sym , loc );
                 #endif
                }
            }
        }
    }
}


extern  void    _CGAPI DBModSym( sym_handle sym, cg_type indirect ) {
/*******************************************************************/


    fe_attr     attr;
    dbg_loc     loc;

#ifndef NDEBUG
    EchoAPI( "DBModSym( %s, %t )\n",  sym, indirect );
#endif
    indirect = indirect;
    if( _IsModel( DBG_LOCALS ) ) {
        attr = FEAttr( sym );
        if( (attr & FE_IMPORT) == 0 ) {
            if( attr & FE_PROC ) {
                loc = NULL;
            } else {
                loc = DBLocInit();
                loc = DBLocSym( loc, sym );
            }
            DBGenSym( sym, loc, FALSE );
            DBLocFini( loc );
        }
    }
}


extern  void _CGAPI DBObject( dbg_type tipe, dbg_loc loc, cg_type ptr_type ) {
/************************************************************************/

#ifndef NDEBUG
    EchoAPI( "DBObject( %i, %i, %t )\n", tipe, loc, ptr_type );
#endif
    CurrProc_debug->obj_type = tipe;
    CurrProc_debug->obj_loc = LocDupl( loc );
    if( _IsModel( DBG_DF ) ) {
       //
    }else if( _IsModel( DBG_CV ) ) {
      //
    }else{
#if _TARGET &( _TARG_IAPX86 | _TARG_80386 )
        WVObjectPtr( ptr_type );
#endif
    }
}



extern  void    DBAllocReg( name *reg, name *temp ) {
/***************************************************/

    temp = temp;
    reg = reg;
}

extern void _CGAPI DBTypeDef( char *nm, dbg_type tipe ){
/******************************************************/
#ifndef NDEBUG
    EchoAPI( "DBTypeDef( %c, %t )\n", nm, tipe );
#endif
    if( _IsModel( DBG_DF ) ) {
         DFTypedef( nm, tipe );
    }else if( _IsModel( DBG_CV ) ) {
        CVTypedef( nm, tipe );
    }else{
     }
}

extern  void    _CGAPI DBLocalSym( sym_handle sym, cg_type indirect ) {
/*********************************************************************/


    fe_attr     attr;
    dbg_loc     loc;

#ifndef NDEBUG
    EchoAPI( "DBLocalSym( %s, %t )\n", sym, indirect );
#endif
    indirect = indirect;
    if( CurrProc->targ.debug != NULL ) {
        attr = FEAttr( sym );
        if( (attr & FE_IMPORT) == 0 ) {
            loc = DBLocInit();
            loc = DBLocSym( loc, sym );
            DBGenSym( sym, loc, TRUE );
            DBLocFini( loc );
        }
    }
}

extern  void    _CGAPI DBLocalType( sym_handle sym, char kind ) {
/***************************************************************/
    dbg_block   *blk;
    dbg_local   *new;

#ifndef NDEBUG
    EchoAPI( "DBLocalType( %s, %i)\n", sym, kind );
#endif
    if( _IsModel( DBG_LOCALS ) ) {
        if( _IsModel( DBG_CV | DBG_DF ) ) {
            blk = CurrProc_debug->blk;
            _Alloc( new, sizeof( dbg_local ) );
            new->sym = sym;
            new->loc = NULL;
            AddLocal( &blk->locals, new );
            if( kind ){
               new->kind = DBG_SYM_TYPE;
            }else{
                new->kind = DBG_SYM_TYPEDEF;
           }
        }
    }
}

extern  dbg_block *DoDBBegBlock( int fast_codegen ) {
/***************************************************/

    if( CurrProc->targ.debug == NULL ) return( NULL );
    MkBlock();
    if( !fast_codegen ) {
        /*%%%% stick a NOP in the instruction stream, point it at block*/
        AddBlockInfo( CurrProc_debug->blk, TRUE );
    }
    return( CurrProc_debug->blk );
}

extern  void _CGAPI     DBBegBlock() {
/************************************/
#ifndef NDEBUG
    EchoAPI( "DBBegBlock()\n" );
#endif
    DoDBBegBlock( 0 );
}


static  void    MkBlock( void ) {
/********************************/


    dbg_block   *new;

    _Alloc( new, sizeof( dbg_block ) );
    new->parent = CurrProc_debug->blk;
    CurrProc_debug->blk = new;
    new->locals = NULL;
    new->patches = NULL;
}


extern  void    DoDBEndBlock( int fast_codegen ) {
/************************************************/

    dbg_block   *blk;

#ifndef NDEBUG
    EchoAPI( "DBEndBlock()\n" );
#endif
    if( CurrProc->targ.debug != NULL ) {
        blk = CurrProc_debug->blk;
        if( !fast_codegen ) {
            AddBlockInfo( blk, FALSE );
        }
        CurrProc_debug->blk = blk->parent;
    }
}

extern  void _CGAPI     DBEndBlock() {
/************************************/

    DoDBEndBlock( 0 );
}


static  void    AddBlockInfo( dbg_block *blk, bool start ) {
/**********************************************************/


    instruction *ins;

    ins = MakeNop();
    ins->table = DbgInfo;
    ins->u.gen_table = ins->table;
    ins->flags.nop_flags = NOP_DBGINFO;
    if( start ) ins->flags.nop_flags |= NOP_DBGINFO_START;
    ins->operands[ 0 ] = (name *)blk;
    AddIns( ins );
}


extern  void    DbgSetBase() {
/****************************/

    if( _IsModel( DBG_DF ) ) {
    /* nothing */
    }else if( _IsModel( DBG_CV ) ) {
        CVSetBase();
    }else{
#if _TARGET &( _TARG_IAPX86 | _TARG_80386 )
        WVSetBase();
#endif
    }
}


extern  void    DbgParmLoc( name_def *parm, sym_handle sym ) {
/********************************************/
// sym is NULL if no front end sym

    dbg_local           *new;
    dbg_loc             loc;

    if( _IsntModel( DBG_DF ) ){
        if( parm->class != N_REGISTER  ){
            return;
        }
    }
    _Alloc( new, sizeof( dbg_local ) );
    loc = DBLocInit();
    loc = LocParm( loc, (name *) parm );
    new->loc = loc;
    new->sym = sym;
    new->kind = DBG_SYM_VAR;
    AddLocal( &CurrProc_debug->parms, new );
}


extern  void    DbgRetLoc() {
/***************************/


    dbg_loc     loc;

    if( CurrProc_debug->reeturn == NULL ) {
        loc = DBLocInit();
        loc = LocReg( loc, AllocRegName( CurrProc->state.return_reg ) );
#if _TARGET & ( _TARG_IAPX86 | _TARG_80386 )
        if( CurrProc->targ.return_points == NULL ) {
            /* nothing to do */
        } else if( CurrProc->state.attr & ROUTINE_ALLOCS_RETURN ) {
            loc->class = LOC_IND_REG + IND_RALLOC_NEAR;
        } else {
            loc->class = LOC_IND_REG + IND_CALLOC_NEAR;
        }
#endif
        CurrProc_debug->reeturn = loc;
    }
}


/**/
/* Going into optimizer queue*/
/**/


extern  void    DbgRetOffset( type_length offset ) {
/*******************************************/


    CurrProc_debug->ret_offset = offset;
}


extern  void    EmitRtnBeg() {
/****************************/


    EmitDbg( INFO_DBG_RTN_BEG, CurrProc->targ.debug );
}


extern  void    EmitProEnd() {
/****************************/


    EmitDbg( INFO_DBG_PRO_END, CurrProc->targ.debug );
}


extern  void    EmitDbgInfo( instruction *ins ) {
/***********************************************/


    if( ins->flags.nop_flags & NOP_DBGINFO_START ) {
        EmitDbg( INFO_DBG_BLK_BEG, ins->operands[ 0 ] );
   } else {
        EmitDbg( INFO_DBG_BLK_END, ins->operands[ 0 ] );
    }
}


extern  void    EmitEpiBeg() {
/****************************/


    EmitDbg( INFO_DBG_EPI_BEG, CurrProc->targ.debug );
}


extern  void    EmitRtnEnd() {
/****************************/


    seg_id      old;

    EmitDbg( INFO_DBG_RTN_END, CurrProc->targ.debug );
    old = SetOP( AskCodeSeg() );
    EmptyQueue();
    SetOP( old );
}


static  void    EmitDbg( byte class, pointer ptr ) {
/**************************************************/


    any_oc      temp;

    temp.oc_debug.op.class = OC_INFO + class;
    temp.oc_debug.op.reclen = sizeof( oc_debug );
    temp.oc_debug.op.objlen = 0;
    temp.oc_debug.ptr = ptr;
    InputOC( &temp );
}


/**/
/* Coming out of optimizer queue*/
/**/


extern  void    DbgRtnBeg( dbg_rtn *rtn,  offset lc ) {
/***************************************************/

    rtn->blk->start = lc;
    if( _IsModel( DBG_CV ) ) {
        CVRtnBeg( rtn, lc );
    }
}


extern  void    DbgProEnd( dbg_rtn *rtn, offset lc ) {
/**************************************************/

    rtn->pro_size = lc - rtn->blk->start;
    if( _IsModel( DBG_DF ) ) {
        DFProEnd( rtn, lc );
    }else if( _IsModel( DBG_CV ) ) {
        CVProEnd( rtn, lc );
    }
}


extern  void    DbgBlkBeg( dbg_block *blk, offset lc ) {
/****************************************************/


    blk->start = lc;
    if( _IsModel( DBG_DF ) ) {
        DFBlkBeg( blk, lc );
    }else if( _IsModel( DBG_CV ) ) {
        CVBlkBeg( blk, lc );
    }
}

extern  void    DbgBlkEnd( dbg_block *blk, offset lc ) {
/****************************************************/


    if( _IsModel( DBG_DF ) ) {
        DFBlkEnd( blk, lc );
    }else if( _IsModel( DBG_CV ) ) {
        CVBlkEnd( blk, lc );
    }else{
#if _TARGET &( _TARG_IAPX86 | _TARG_80386 )
        WVBlkEnd( blk, lc );
#endif
    }
    _Free( blk, sizeof( dbg_block ) );
}


extern  void    DbgEpiBeg( dbg_rtn *blk, offset lc ) {
/****************************************************/


    blk->epi_start = lc;
    if( _IsModel( DBG_DF ) ) {
        DFEpiBeg( blk, lc );
    }else if( _IsModel( DBG_CV ) ) {
        CVEpiBeg( blk, lc );
    }
}


extern  void    DbgRtnEnd( dbg_rtn *rtn, offset lc ) {
/****************************************************/


    if( _IsModel( DBG_DF ) ) {
        DFRtnEnd( rtn, lc );
    }else if( _IsModel( DBG_CV ) ) {
        CVRtnEnd( rtn, lc );
    }else{
#if _TARGET &( _TARG_IAPX86 | _TARG_80386 )
        WVRtnEnd( rtn, lc );
#endif
    }
    _Free( rtn->blk, sizeof( dbg_block ) );
    _Free( rtn, sizeof( dbg_rtn ) );
}