process.c

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

            case 3:
                Output( "  %5:%X" CRLF, line_num, offset );
                break;
            default:
                Output( "  %5:%X", line_num, offset );
                break;
            }
            ++count;
        } while( ! EndRec() );
        if( count % 4 != 0 ) {  /* if count % 4 == 0 then CRLF already output */
            Output( CRLF );
        }
    }
}

static void DoLinNumsHLL( void )
/******************************/
{
    unsigned_16         line_num;
    unsigned_16         file_num;
    unsigned_32         offset;
    static unsigned_16  type = 0x100;   // indicate no current type
    unsigned_16         seg;
    unsigned_16         base_grp;
    unsigned_16         base_seg;
    unsigned_32         count;
    static unsigned_32  entry_num;
    static unsigned_16  num_entries;
    unsigned_32         size;
    unsigned_32         i;

    base_grp = GetIndex();
    base_seg = GetIndex();

    // New table is starting
    if( type == 0x100 ) {
        line_num = GetUInt();

        if( !line_num ) {
            // This is the first entry
            type        = GetUInt();
            num_entries = GetUInt();
            seg         = GetUInt();
            entry_num   = 0;
        }
        switch( type ) {
        case 0:     // Source line numbers table
            Output( INDENT "Source line numbers" CRLF );
            size = GetLInt();   // Address of logical segment - filled out by
                                // linker, zero in object file
            break;
        case 1:     // Listing line numbers table
            Output( INDENT "Listing line numbers (not formatting data)" CRLF );
            break;
        case 2:     // Listing and line numbers combined
            Output( INDENT "Source/listing line numbers (not formatting data)" CRLF );
            break;
        case 3:     // File names table
            Output( INDENT "File names table" CRLF );
            // Note - the descriptions are taken from LINK386 and are not
            // necessarily correct, as IBM tools don't appear to use the
            // 'start' and 'number of records' entries
            size = GetLInt();
            i = GetLInt();
            Output( INDENT "Record Number of Start of Source: %5" CRLF, i );
            i = GetLInt();
            Output( INDENT "Number of Primary Source Records: %5" CRLF, i );
            count = GetLInt();
            break;
        case 4:
            Output( INDENT "Path table (not formatting data)" CRLF );
            break;
        }
    } else {
        Output( INDENT "Continuing previous LINNUM record" CRLF );
    }
    // Process entries in a table that may be a continuation from previous
    // LINNUM record
    switch( type ) {
    case 0:             // line/offset info
        if( Descriptions )
            Output( INDENT "Src line   Src file  segment:offset" CRLF );

        while( (entry_num < num_entries) && ((RecPtr - RecBuff) < RecLen) ) {
            line_num = GetUInt();
            file_num = GetUInt();
            offset   = GetLInt();
            Output( INDENT "  %5  %5  %5:%X" CRLF, line_num, file_num, base_seg, offset );
            ++entry_num;
        }
        break;
    case 3:             // file names table
        while( (entry_num < num_entries) && ((RecPtr - RecBuff) < RecLen) ) {
            GetName();
            Output( INDENT "  Source file %5: %N" CRLF, entry_num + 1 );
            ++entry_num;
        }
        break;
    }
    if( entry_num == num_entries ) {
        // We're done; otherwise table will continue in next LINNUM record
        type = 0x100;
    }
}

void ProcLinNums( void )
/**********************/
{
    switch( DbgStyle ) {
    case DBG_CODEVIEW:
        getBase( TRUE );
        DoLinNumsMS();
        break;
    case DBG_HLL:
        DoLinNumsHLL();
        break;
    default:
        Output( INDENT "Unknown debugging style - not interpreting LINNUM"
                " records" CRLF);
    }
}


void ProcLineSym( void )
/**********************/
{
    unsigned    flag;
    unsigned    sym;

    flag = GetByte();
    sym = GetIndex();
    Output( INDENT "sym:%u", sym );
    if( flag & 1 ) {
        Output( " - continued" );
    }
    Output( CRLF );
    DoLinNumsMS();
}


static void idBlock( unsigned indent, unsigned_16 first_block_offset )
{
    unsigned_32 rpt_count;
    unsigned_16 blk_count;
    byte        data_count;
    data_ptr    next_block;

    rpt_count = IsMS386 ? GetLInt() : GetUInt();
    Output( "%>Repeated %X times" CRLF, indent, rpt_count );
    blk_count = GetUInt();
    if( blk_count == 0 ) {
        data_count = GetByte();
        next_block = RecPtr + data_count;
        OutputData( (unsigned_32)( RecOffset() - first_block_offset ),
            (uint_32)data_count );
#if 0
        Output( "%>", indent );
        for( num = 0; num < data_count; ++num ) {
            Output( "%b ", GetByte() );
            if( ( num & 0x7 ) == 7 ) {
                Output( CRLF "%>", indent );
            }
        }
        if( ( data_count & 0x7 ) != 7 ) {
            Output( CRLF );
        }
#endif
        RecPtr = next_block;
    } else {
        while( blk_count != 0 ) {
            idBlock( indent + (INDWIDTH/2), first_block_offset );
            --blk_count;
        }
    }
}

static unsigned_32 begData( void )
{
    unsigned_16 seg;
    unsigned_32 offset;
    Segdeflist  *sd;
    char        *segname;

    seg = GetIndex();
    offset = GetEither();
    if( TranslateIndex ) {
        sd = GetSegdef( seg );
        if( sd != NULL ) {
           segname = GetLname( sd->segind );
        } else {
           segname = "";
        }
        Output( INDENT "Seg index:%u - '%s' offset:%X" CRLF,
            seg, segname, offset );
    } else {
        Output( INDENT "Seg index:%u offset:%X" CRLF, seg, offset );
    }
    return( offset );
}


static void DoLidata( void )
/**************************/
{
    unsigned_16 first_block_offset;

    first_block_offset = RecOffset();
    while( ! EndRec() ) {
        idBlock( INDWIDTH, first_block_offset );
    }
}


void ProcLidata( void )
/*********************/
{
    begData();
    DoLidata();
}

void ProcLedata( void )
/*********************/
{
    unsigned_32 offset;

    offset = begData();
    OutputData( offset, 0L );
}

static void doFrame( byte frame )
{
    switch( frame ) {
    case FRAME_SEG:     Output( "SI(%u)%<", GetIndex(), 8 );     break;
    case FRAME_GRP:     Output( "GI(%u)%<", GetIndex(), 8 );     break;
    case FRAME_EXT:     Output( "EI(%u)%<", GetIndex(), 8 );     break;
    case FRAME_ABS:     Output( "%x%<", GetUInt(), 8 );          break;
    case FRAME_LOC:     Output( "LOCATION" );                    break;
    case FRAME_TARG:    Output( "TARGET  " );                    break;
    case FRAME_NONE:    Output( "NONE    " );                    break;
    default:
        Output( BAILOUT "Unknown frame(%b)" CRLF, frame );
        longjmp( BailOutJmp, 1 );
    }
}

static void doTarget( byte target )
{
    switch( target & 0x03 ) {
    case TARGET_SEGWD:   Output( "SI(%u)", GetIndex() );         break;
    case TARGET_GRPWD:   Output( "GI(%u)", GetIndex() );         break;
    case TARGET_EXTWD:   Output( "EI(%u)", GetIndex() );         break;
    case TARGET_ABSWD:   Output( "%x", GetUInt() );              break;
    }
}

static bool doFrameTranslateIndex( byte frame, size_t *printpos )
{
    Segdeflist  *sd;
    Grpdeflist  *gd;
    unsigned_16 idx;
    bool        needcrlf = FALSE;
    size_t      deltacol;

#define         FRAMECOL     39u

    if( FRAMECOL > *printpos ) {
        deltacol = FRAMECOL - *printpos;
    } else {
        deltacol = 0;
    }
    switch( frame ) {
    case FRAME_SEG:
        idx = GetIndex();
        sd = GetSegdef( idx );
        if( sd != NULL ) {
            *printpos = Output( "%<- '%s'", deltacol, GetLname( sd->segind ) );
            needcrlf = TRUE;
        }
        break;
    case FRAME_GRP:
        idx = GetIndex();
        gd = GetGrpdef( idx );
        if( gd != NULL ) {
            *printpos = Output( "%<- '%s'", deltacol, GetLname( gd->grpind ) );
            needcrlf = TRUE;
        }
        break;

    case FRAME_EXT:
        idx = GetIndex();
        if( TranslateIndex ) {
            *printpos = Output( "%<- '%s'", deltacol, GetXname( idx ) );
            needcrlf = TRUE;
        }
        break;
    case FRAME_ABS:
        GetUInt();
//        Output( "%x%<", GetUInt(), 8 );
        break;

#if 0
    case FRAME_LOC:     Output( "LOCATION" );                    break;
    case FRAME_TARG:    Output( "TARGET  " );                    break;
    case FRAME_NONE:    Output( "NONE    " );                    break;
    default:
        Output( BAILOUT "Unknown frame(%b)" CRLF, frame );
        longjmp( BailOutJmp, 1 );
#endif

    }
    return( needcrlf );
}

static bool doTargetTranslateIndex( byte target, size_t *printpos )
{
    Segdeflist  *sd;
    Grpdeflist  *gd;
    unsigned_16 idx;
    bool        needcrlf = FALSE;
    size_t      deltacol;

#define         TARGETCOL     58u

    if( TARGETCOL > *printpos ) {
        deltacol = TARGETCOL - *printpos;
    } else {
        deltacol = 0;
    }
    switch( target & 0x03 ) {
    case TARGET_SEGWD:
        idx = GetIndex();
        sd = GetSegdef( idx );
        if( sd != NULL ) {
            *printpos = Output( "%<- '%s'", deltacol, GetLname( sd->segind ) );
            needcrlf = TRUE;
        }
        break;
    case TARGET_GRPWD:
        idx = GetIndex();
        gd = GetGrpdef( idx );
        if( gd != NULL ) {
            *printpos = Output( "%<- '%s'", deltacol, GetLname( gd->grpind ) );
            needcrlf = TRUE;
        }
        break;
    case TARGET_EXTWD:
        idx = GetIndex();
        if( TranslateIndex ) {
            *printpos = Output( "%<- '%s'", deltacol, GetXname( idx ) );
            needcrlf = TRUE;
        }
        break;
    case TARGET_ABSWD:
        GetUInt();
//        Output( "%x", GetUInt() );
        break;
    }
    return( needcrlf );
}

static void threadFixup( byte typ )
{
    byte    num;
    byte    frame;

    num = typ & 0x03;
    frame = ( typ >> 2 ) & 0x07;
    if( ( typ & TRDDAT_DBIT ) != 0 ) {
        Output( INDENT "Thread: FRAME  %u: ", num );
        doFrame( frame );
    } else {
        Output( INDENT "Thread: TARGET %u: ", num );
        doTarget( frame );
    }
    Output( CRLF );
}

static void explicitFixup( byte typ )
{
    byte        loc;
    unsigned_16 offset;
    byte        frame;
    data_ptr    RecPtrsave;
    data_ptr    RecPtrsave1;
    bool        needcrlf = FALSE;
    size_t      printpos;

    offset = ( ( typ & 0x03 ) << 8 ) + GetByte();
    Output( INDENT "%x %s", offset, ( typ & FIXDAT_MBIT ) ? "Seg " : "Self" );
    loc = ( ( typ >> 2 ) & 0x0f );
    if( IsPharLap ) {
        if( loc > LOC_BASE_OFFSET_32 ) {
            Output( BAILOUT "Unknown loc, type = %b" CRLF, typ );
            longjmp( BailOutJmp, 1 );
        } else if( loc == LOC_MS_LINK_OFFSET ) {
            loc = LOC_MS_OFFSET_32;
        }
    } else if( IsIntel ) {
        if( loc > LOC_MS_LINK_OFFSET ) {
            Output( BAILOUT "Unknown loc, type = %b" CRLF, typ );
            longjmp( BailOutJmp, 1 );
        }
    }
    switch( loc ) {
    case LOC_OFFSET_LO:         Output( "  LOBYTE     " );   break;
    case LOC_OFFSET:            Output( "  OFFSET     " );   break;
    case LOC_BASE:              Output( "  BASE       " );   break;
    case LOC_BASE_OFFSET:       Output( "  POINTER    " );   break;
    case LOC_OFFSET_HI:         Output( "  HIBYTE     " );   break;