dfsyms.c

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

        fname = SrcFNoFind( state->fno );
        DWSetFile( Client, fname );
        CurrFNo = state->fno;
    }
    DWLineNum( Client, DW_LN_STMT, state->line, state->col, lc );
}


#if _TARGET &( _TARG_IAPX86 | _TARG_80386 )
static  dw_loc_handle   SegLoc( sym_handle sym ){
/************************************************/
    dw_loc_id       locid;
    dw_loc_handle   df_loc;

    locid = DWLocInit( Client );
    DWLocSegment( Client, locid, (dw_sym_handle)sym );
    df_loc = DWLocFini( Client, locid );
    return( df_loc );
}
#endif
extern  void    DFGenStatic( sym_handle sym, dbg_loc loc ) {
/*******************************************************************/
    uint            flags;
    fe_attr         attr;
    char           *name;
    dw_loc_handle   dw_loc;
    dw_loc_handle   dw_segloc;
    dw_handle       obj;
    dbg_type        dbtype;

    attr = FEAttr( sym );
    if( attr & FE_GLOBAL ){
        flags = DW_FLAG_GLOBAL;
    }else{
        flags = 0;
    }
    name = FEName( sym );
    if( attr & FE_STATIC ){
#if _TARGET &( _TARG_IAPX86 | _TARG_80386 )
        if( _IsTargetModel( FLAT_MODEL ) ) {
            dw_segloc = NULL;
        }else{
            dw_segloc = SegLoc( sym );
        }
#else
       dw_segloc = NULL;
#endif
    }else{
        dw_segloc = NULL;
    }
    dbtype = FEDbgType( sym ); /* causes name side effects */
    dw_loc = DBGLoc2DF( loc );
    obj = DWVariable( Client, dbtype, dw_loc,
                NULL, dw_segloc, name, NULL, flags );
    if( attr &  FE_GLOBAL ){
        name = FEName( sym );
        DWPubname( Client, obj, name );
    }
    if( dw_loc != NULL ){
        DWLocTrash( Client, dw_loc );
    }
    if( dw_segloc != NULL ){
        DWLocTrash( Client, dw_segloc );
    }
}

extern  void    DFTypedef( char *nm, dbg_type tipe ){
/*** emit a user typedef ***************************/
     DWTypedef( Client, tipe, nm, 0, 0 );
}

static  void    GenRetSym( dbg_loc loc, dbg_type tipe ) {
/*******************************************************************/
    dw_loc_handle   dw_loc;

    dw_loc = DBGLoc2DF( loc );
    if( dw_loc != NULL ){
        DWVariable( Client, tipe, dw_loc,
                   NULL, NULL, ".return", NULL, DW_FLAG_ARTIFICIAL );
        DWLocTrash( Client, dw_loc );
    }
}
static void    SymParm( sym_handle sym, dw_loc_handle loc,
                                        dw_loc_handle entry ) {
/*******************************************************************/
    fe_attr         attr;
    char           *name;
    dw_handle       obj;
    dbg_type        dbtype;

    attr = FEAttr( sym );
    dbtype = FEDbgType( sym ); /* causes FEName side effects */
    name = FEName( sym );
    obj = DWFormalParameter( Client, dbtype, loc,
                entry,  name, DW_DEFAULT_NONE );
}

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

#if _TARGET &( _TARG_IAPX86 | _TARG_80386 )
static dw_loc_handle  RetLoc( uint_32 ret_offset ){
/**** make a loc for return address *************/
    dw_loc_id       locid;
    dw_loc_handle   df_loc;

    locid = DWLocInit( Client );
    DWLocOp( Client, locid, DW_LOC_fbreg, ret_offset );
    df_loc = DWLocFini( Client, locid );
    return( df_loc );
}

static dw_loc_handle  FrameLoc( void ){
/**** make a loc for frame  address *************/
    uint            dsp;
    dw_loc_id       locid;
    dw_loc_handle   df_loc;

    locid = DWLocInit( Client );
    dsp = DFDisplayReg();
    DWLocReg( Client, locid, dsp );
    df_loc = DWLocFini( Client, locid );
    return( df_loc );
}
#endif
static dw_loc_id StkLoc( uint_32 stk_offset, dw_loc_id locid ){
/**** make a loc for stack  address *************/
    uint            stk;

    stk = DFStkReg();
    DWLocOp( Client, locid, DW_LOC_breg, stk, stk_offset );
    return( locid );
}

static  dbg_local *UnLinkLoc( dbg_local **owner, sym_handle sym ) {
/********************************************/
// unlink dbg_local with sym from owner

    dbg_local           *curr;

    while( (curr = *owner) != NULL ) {
        if( curr->sym == sym ){
            *owner = curr->link;
            break;
        }
        owner = &(*owner)->link;
    }
    return( curr );
}


static  void GenParmLoc( dbg_local   *parm,
                    dbg_local   **locals ){
    dbg_local      *alt;
    dw_loc_handle   dw_loc;
    dw_loc_handle   dw_entry;
    dw_loc_id       df_locid;

    df_locid = DWLocInit( Client );
    if( parm->loc->class == LOC_CONST_4 ){
        df_locid = StkLoc( parm->loc->u.val, df_locid );
    }else{
        df_locid = DBGLoc2DFCont( parm->loc, df_locid );
    }
    alt = UnLinkLoc( locals, parm->sym );
    if( alt != NULL ){
        dbg_loc       alt_loc;
        dbg_loc       *alt_lnk;

        alt_loc = alt->loc;      // skip down to loc base
        alt_lnk = &alt_loc->next;
        if( *alt_lnk != NULL ){
            for(;;){
                alt_loc = *alt_lnk;
                if( alt_loc->next == NULL )break;
                alt_lnk = &alt_loc->next;
            }
            *alt_lnk = NULL;   // don't use base
            df_locid = DBGLoc2DFCont( alt->loc, df_locid );
            *alt_lnk = alt_loc;
        }
        dw_loc = DBGLoc2DF( alt->loc );
        DBLocFini( alt->loc );
        _Free( alt, sizeof( dbg_local ) );
    }else{
        dw_loc = DBGLoc2DF( NULL );
    }
    dw_entry = DWLocFini( Client, df_locid );
    SymParm( parm->sym, dw_loc, dw_entry );
    DWLocTrash( Client, dw_loc );
    DWLocTrash( Client, dw_entry );
}

#if _TARGET & _TARG_IAPX86
static int  DW_PTR_TYPE_FAR  = DW_PTR_TYPE_FAR16;
#elif _TARGET & _TARG_80386
static int  DW_PTR_TYPE_FAR  = DW_PTR_TYPE_FAR32;
#endif

extern  void    DFProEnd( dbg_rtn *rtn, offset lc ) {
/****************************************************/
    sym_handle          sym;
    dbg_type            tipe;
    fe_attr             attr;
    char               *name;
    call_class          *class_ptr;
    uint                flags;
    dw_loc_handle       dw_retloc;
    dw_loc_handle       dw_frameloc;
    dw_loc_handle       dw_segloc;
    dbg_local           *parm;
    dbg_local           *junk;
    dw_handle           obj;
    bck_info            *bck;
    sym_access          *access;

    lc = lc;
    sym = AskForLblSym( CurrProc->label );
    tipe = FEDbgRetType( sym );
    class_ptr = FEAuxInfo( FEAuxInfo( sym, AUX_LOOKUP ), CALL_CLASS );
    flags = 0;
#if _TARGET &( _TARG_IAPX86 | _TARG_80386 )
    if( *class_ptr & FAR ) {
        flags |= DW_PTR_TYPE_FAR;
    }
#endif
    attr = FEAttr( sym );
    name = FEName( sym );
    if( attr & FE_GLOBAL ){
        flags |= DW_FLAG_GLOBAL;
    }else{
        flags |= DW_SUB_STATIC;
    }
    if( attr & FE_COMPILER ){
        flags |= DW_FLAG_ARTIFICIAL;
    }
    flags |= DW_FLAG_PROTOTYPED;
    access = FEAuxInfo( sym,DBG_SYM_ACCESS );
    if( access != NULL ){
        if( *access == SYM_ACC_PUBLIC ){
            flags |= DW_FLAG_PUBLIC;
        }else if( *access == SYM_ACC_PROTECTED ){
            flags |= DW_FLAG_PROTECTED;
        }else if( *access == SYM_ACC_PRIVATE ){
            flags |= DW_FLAG_PRIVATE;
        }
    }
    DBLocFini( rtn->obj_loc );
#if _TARGET &( _TARG_IAPX86 | _TARG_80386 )
    dw_retloc = RetLoc( rtn->ret_offset );
    dw_frameloc = FrameLoc();
    if( _IsTargetModel( FLAT_MODEL ) ) {
        dw_segloc = NULL;
    }else{
        dw_segloc = SegLoc( sym );
    }
#else
    dw_retloc = NULL;
    dw_frameloc = NULL;
    dw_segloc = NULL;
#endif
    bck = FEBack( sym );
    rtn->end_lbl = MakeLabel();
    Pc_Low  = bck;
    Pc_High = rtn->end_lbl;
    obj = DWBeginSubroutine( Client, 0, tipe, dw_retloc,
                     dw_frameloc, NULL, rtn->obj_type,
                     dw_segloc, name, rtn->pro_size, flags );
    if( attr &  FE_GLOBAL ){
        if( rtn->obj_type != DBG_NIL_TYPE ) {
            name = FEAuxInfo( sym, CLASS_APPENDED_NAME );
        }else{
            name = FEName( sym );
        }
        DWPubname( Client, obj, name );
    }
    if( dw_retloc != NULL ){
        DWLocTrash( Client, dw_retloc );
    }
    if( dw_frameloc != NULL ){
        DWLocTrash( Client, dw_frameloc );
    }
    if( dw_segloc != NULL ){
        DWLocTrash( Client, dw_segloc );
    }
    parm = rtn->parms;
    while( parm != NULL ) {  /* flush these suckers */
        if( parm->sym != NULL ){
            GenParmLoc( parm, &rtn->blk->locals );
        }
        DBLocFini( parm->loc );
        junk = parm;
        parm = parm->link;
        _Free( junk, sizeof( dbg_local ) );
    }
    if( rtn->reeturn != NULL ){
        GenRetSym( rtn->reeturn, tipe );
        DBLocFini( rtn->reeturn );
    }
    DFBlkBeg( rtn->blk, lc );
//   DumpLocals( rtn->blk->locals );
}

extern  void    DFBlkBeg( dbg_block *blk, offset lc ) {
/****************************************************/
    bck_info    *bck;

    lc = lc;
    bck = MakeLabel();
    blk->end_lbl = MakeLabel();
    OutLabel( bck->lbl );
    Pc_Low  = bck;
    Pc_High = blk->end_lbl;
    DWBeginLexicalBlock( Client, NULL, NULL );
    BEFreeBack( bck );
    DumpLocals( blk->locals );
}

extern  void    DFBlkEnd( dbg_block *blk, offset lc ) {
/****************************************************/
    bck_info    *bck;

    lc = lc;
    bck = blk->end_lbl;
    OutLabel( bck->lbl );
    BEFreeBack( bck );
    DWEndLexicalBlock( Client );
}

extern  void    DFEpiBeg( dbg_rtn *rtn, offset lc ) {
/****************************************************/
    DFBlkEnd( rtn->blk, lc );
}

extern  void    DFRtnEnd( dbg_rtn *rtn, offset lc ) {
/****************************************************/
    bck_info            *bck;

    lc = 0;
    bck = rtn->end_lbl;
    OutLabel( bck->lbl );
    BEFreeBack( bck );
    DWEndSubroutine( Client );
}



static  void    DumpLocals( dbg_local *local ) {
/***********************************************/
    dbg_local   *junk;
    dbg_type    tipe;

    while( local != NULL ) {
        switch( local->kind ){
        case DBG_SYM_VAR:
            DFGenStatic( local->sym, local->loc );
            DBLocFini( local->loc );
            break;
        case DBG_SYM_TYPE:
            tipe = FEDbgType( local->sym );
            break;
        case DBG_SYM_TYPEDEF:
            tipe = FEDbgType( local->sym );
            DFTypedef( FEName( local->sym ), tipe );
            break;
        }
        junk = local;
        local = local->link;
        _Free( junk, sizeof( dbg_local ) );
    }
}