dwarf.c

Open Watcom 的 C 编译器源代码

        break;
    case TYPE_ULONG64:
        dh = DWFundamental( Client, "unsigned __int64", DW_FT_UNSIGNED, TypeSize( typ ) );
        type_update( typ, TF2_DWARF_DEF, dh );
        break;
    case TYPE_FLOAT:
        dh = DWFundamental( Client, "float", DW_FT_FLOAT, TypeSize( typ ) );
        type_update( typ, TF2_DWARF_DEF, dh );
        break;
    case TYPE_DOUBLE:
        dh = DWFundamental( Client, "double", DW_FT_FLOAT, TypeSize( typ ) );
        type_update( typ, TF2_DWARF_DEF, dh );
        break;
    case TYPE_LONG_DOUBLE:
        dh = DWFundamental( Client, "long double", DW_FT_FLOAT, TypeSize( typ ) );
        type_update( typ, TF2_DWARF_DEF, dh );
        break;
    case TYPE_ENUM:
        dh = dwarfEnum( typ );
        break;
    case TYPE_POINTER:
        dh = DWPointer( Client, dwarfType( typ->object, DC_DEFAULT ), 0 );
        type_update( typ, TF2_DWARF_DEF, dh );
        break;
    case TYPE_TYPEDEF:
        dh = dwarfType( typ->object, DC_DEFAULT );
        sym = SymGetPtr( typ->u.typedefn );
        dwarfLocation( sym );
        dh = DWTypedef( Client,
                        dh,
                        sym->name,
                        0,
                        0 );
        type_update( typ, TF2_DWARF_DEF, dh );
        break;
    case TYPE_STRUCT:
    case TYPE_UNION:
        dh = dwarfStructUnion( typ, DC_DEFAULT );
        break;
    case TYPE_FUNCTION:
        dh = dwarfTypeFunction( typ, NULL );
        break;
    case TYPE_ARRAY:
        dh = dwarfTypeArray( typ );
        break;
    case TYPE_VOID:
        dh = DWFundamental( Client, "void", DW_FT_UNSIGNED, 0 );
        type_update( typ, TF2_DWARF_DEF, dh );
        break;
    default:
        #ifdef FDEBUG
            DumpFullType( typ );
            CFatal( "dwarf: illegal type" );
        #endif
        break;
    }
    #ifdef FDEBUG
        if( dh == 0 && !(control & DC_RETURN) ) {
            DumpFullType( type );
            CFatal( "dwarf: unable to define type" );
        }
    #endif
    return( dh );
}

static void dwarfFunctionDefine(SYM_HANDLE  sym_handle, SYMPTR func_sym )
/********************************************************************/
{
    TYPEPTR     typ;
    dw_handle   return_dh;
    dw_handle   func_dh;
    dw_handle   dh;
    uint        call_type;
    uint        flags;
    SYMPTR      sym;

    call_type = 0;
    typ = func_sym->sym_type;
    if( func_sym->attrib & FLAG_NEAR ) {
        call_type = DW_SB_NEAR_CALL;
    } else if( func_sym->attrib &  FLAG_FAR ) {
        call_type = DW_SB_FAR_CALL;
    } else if( func_sym->attrib & FLAG_FAR16 ) {
        call_type = DW_SB_FAR16_CALL;
    }
    flags = DW_FLAG_PROTOTYPED;
    if( func_sym->stg_class == SC_STATIC ) {
        flags |= DW_SUB_STATIC;
    }
    return_dh = dwarfType( typ->object, DC_RETURN );
    func_dh = SymDWHandles[ sym_handle ];
    if( func_dh != 0 ){ //was forward ref'd
        DWHandleSet( Client, func_dh );
    }
    dwarfLocation( func_sym );
    func_dh = DWBeginSubroutine( Client,
                   call_type,
                   return_dh,
                   dummyLoc,
                   dummyLoc,
                   dummyLoc,
                   0,
                   dummyLoc,
                   func_sym->name,
                   0,
                   flags );
    SymDWHandles[ sym_handle ] = func_dh;
    for( sym_handle = func_sym->u.func.parms; sym_handle; ) {
        sym = SymGetPtr( sym_handle );
        dh = DWFormalParameter( Client,
                        dwarfType( sym->sym_type, DC_DEFAULT ),
                        NULL,
                        NULL,
                        sym->name,
                        DW_DEFAULT_NONE );
        SymDWHandles[ sym_handle ] = dh;
        sym_handle = sym->handle;
    }
    dwarfEmitVariables( func_sym->u.func.locals );
}

static dw_handle dwarfFunctionDecl( SYMPTR func_sym )
/*********************************************/
{
    TYPEPTR     typ;
    dw_handle   return_dh;
    dw_handle   func_dh;
    uint        call_type;
    uint        flags;

    call_type = 0;
    typ = func_sym->sym_type;
    if( func_sym->attrib & FLAG_NEAR ) {
        call_type = DW_SB_NEAR_CALL;
    } else if( func_sym->attrib &  FLAG_FAR ) {
        call_type = DW_SB_FAR_CALL;
    } else if( func_sym->attrib & FLAG_FAR16 ) {
        call_type = DW_SB_FAR16_CALL;
    }
    flags = DW_FLAG_PROTOTYPED;
    flags |= DW_FLAG_DECLARATION;
    if( func_sym->stg_class == SC_STATIC ) {
        flags |= DW_SUB_STATIC;
    }
    return_dh = dwarfType( typ->object, DC_RETURN );
    dwarfLocation( func_sym );
    func_dh = DWBeginSubroutine( Client,
                   call_type,
                   return_dh,
                   dummyLoc,
                   dummyLoc,
                   dummyLoc,
                   0,
                   dummyLoc,
                   func_sym->name,
                   0,
                   flags );
   DWEndSubroutine( Client );
   return( func_dh );
}

static dw_handle dwarfVariable( SYMPTR sym )
/******************************************/
{
    dw_handle dh;
    uint      flags;

    flags = 0;
    if( sym->stg_class == SC_NULL ) {
        flags = DW_FLAG_GLOBAL;
    }
    dh = dwarfType( sym->sym_type, DC_DEFAULT );
    dwarfLocation( sym );
    dh = DWVariable( Client,
                dh,
                dummyLoc,
                0,
                dummyLoc,
                sym->name,
                0,
                flags );
    return( dh );
}


static void dwarfEmitVariables( SYM_HANDLE sym_handle )
{
    SYMPTR      sym;
    TYPEPTR     typ;
    dw_handle   dh;

    while( sym_handle ) {
        sym = SymGetPtr( sym_handle );
        if( !(sym->flags & SYM_TEMP) ) {
            typ = sym->sym_type;
            dh = 0;
            if( sym->flags & SYM_FUNCTION ) {
                if( !(sym->flags & SYM_DEFINED) ) {
                    dh = dwarfFunctionDecl( sym );
                }
//              printf( "func: %s", sym->name );
            } else if( sym->stg_class == SC_TYPEDEF ) {
                dh = dwarfType( typ, DC_DEFAULT );
//              printf( "typedef: %s", sym->name );
            } else {
                dh = dwarfVariable( sym );
//              printf( "var:: %s", sym->name );
            }
            SymDWHandles[ sym_handle ] = dh;
//          printf( " defined on line %u\n", sym->d.defn_line );
        }
        sym_handle = sym->handle;
    }
}

void dwarfDumpNode( TREEPTR node )
{
    SYMPTR      sym;

    switch( node->op.opr ) {
    case OPR_FUNCTION:          // start of function
        sym = SymGetPtr( node->op.func.sym_handle );
        dwarfFunctionDefine( node->op.func.sym_handle, sym );
        break;
    case OPR_FUNCEND:           // end of function
        DWEndSubroutine( Client );
        break;
    case OPR_NEWBLOCK:          // start of new block { vars; }
        DWBeginLexicalBlock( Client, NULL, NULL );
        dwarfEmitVariables( node->op.sym_handle );
        break;
    case OPR_ENDBLOCK:          // end of new block { vars; }
        DWEndLexicalBlock( Client );
        break;
    case OPR_PUSHSYM:           // push sym_handle
    case OPR_PUSHADDR:          // push address of sym_handle
    case OPR_FUNCNAME:          // function name
        sym = SymGetPtr( node->op.sym_handle );
        if( !(sym->flags & SYM_TEMP) ) {
            dw_handle   dh;

            dh = SymDWHandles[ node->op.sym_handle ];
            if( dh == 0 ){   // forward ref
                dh = DWHandle( Client, DW_ST_NONE );
                SymDWHandles[ node->op.sym_handle ] = dh;
            }
            dwarfFile( CurFile );
            DWReference( Client, CurLine, 0, dh );
        }
        break;
    default:
        break;
    }
}


void dwarfEmitFunctions()
{
    TREEPTR     tree;

    tree = FirstStmt;
    while( tree != NULL ) {
        CurFile =  tree->op.source_fno;
        CurLine = tree->srclinenum;
        WalkExprTree( tree->right, dwarfDumpNode, NoOp, NoOp, dwarfDumpNode );
        tree = tree->left;
    }
}

void SetDwarfType( TYPEPTR typ )
{
    typ->type_flags &= ~TF2_DWARF;
    typ->dwarf_type = 0;
}

void SetFuncDwarfType( TYPEPTR typ, int index )
{
    // index;   /* unused */
    typ->type_flags &= ~TF2_DWARF;
    typ->dwarf_type = 0;
}

static void EmitAType( TYPEPTR typ )
{
    dwarfType( typ, DC_DEFAULT );
}

void InitDwarfTypes()
{
    WalkTypeList( SetDwarfType );
    WalkFuncTypeList( SetFuncDwarfType );
}

void dwarfEmit( void )
/********************/
{
    int         i;

    InitDwarfTypes();
    for( i = TYPE_CHAR; i <= TYPE_DOUBLE; i++ ) {
        dwarfType( GetType( i ), DC_DEFAULT );
    }
    WalkTypeList( EmitAType );
    dwarfEmitVariables( GlobalSym );
    dwarfEmitFunctions();
    InitDebugTypes();
}

static void InitSymDWHandles( void )
/***********************************/
{
    int i , count;

    count =  NextSymHandle + 1;
    SymDWHandles = (dw_handle *) CMemAlloc( count * sizeof(dw_handle) );
    for( i = 0; i < count; ++i ){
        SymDWHandles[i] = 0;
    }
}
extern void DwarfBrowseEmit( void )
/*********************************/
{
    InitSymDWHandles();
    Client = DwarfInit();
    dummyLoc = DWLocFini( Client, DWLocInit( Client ) );
    CurFile = 0;
    CurLine = 0;
    dwarfEmit();
    DWLocTrash( Client, dummyLoc );
    DwarfFini( Client );
    CMemFree( SymDWHandles );
}


extern void DwarfDebugInit( void )
/********************************/
{
    SymDWHandles = (dw_handle *)
                CMemAlloc( (NextSymHandle + 1) * sizeof(dw_handle) );
    Client = DFClient();
    dummyLoc = DWLocFini( Client, DWLocInit( Client ) );
}

extern void DwarfDebugFini( void )
/****************************/
{
    DWLocTrash( Client, dummyLoc );
    CMemFree( SymDWHandles );
    SymDWHandles = NULL;
}