process.c

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

    case LOC_MS_LINK_OFFSET:    Output( "  LROFFSET   " );   break;
    case LOC_BASE_OFFSET_32:    /* fall through */
    case LOC_MS_BASE_OFFSET_32: Output( "  POINTER386 " );   break;
    case LOC_MS_OFFSET_32:      Output( "  OFFSET386  " );   break;
    case LOC_MS_LINK_OFFSET_32: Output( "  LROFFSET386" );   break;
    default:
        Output( BAILOUT "Unknown loc, type = %b" CRLF, typ );
        longjmp( BailOutJmp, 1 );
    }
    typ = GetByte();
    if( TranslateIndex ) {
        RecPtrsave = RecPtr;
    }
    frame = ( typ >> 4 ) & 0x07;
    Output( "  Frame: " );
    if( typ & FIXDAT_FTHREAD ) {
        Output( "THREAD %u", frame );
    } else {
        doFrame( frame );
    }
    loc = typ & 0x03;
    Output( "  Target: " );
    if( typ & FIXDAT_TTHREAD ) {
        Output( "THREAD %u", loc );
    } else {
        doTarget( loc );
    }
    if( typ & 0x04 ) {
        Output( CRLF );
    } else {
        Output( ",%X" CRLF, GetEither() );
    }
    if( TranslateIndex ) {
        RecPtrsave1 = RecPtr;
        RecPtr = RecPtrsave;
        printpos = 0;
        if( ! (typ & FIXDAT_FTHREAD) ) {
            needcrlf |= doFrameTranslateIndex( frame, &printpos );
        }
        if( ! (typ & FIXDAT_TTHREAD) ) {
            needcrlf |= doTargetTranslateIndex( loc, &printpos );
        }
        if( needcrlf ) {
            Output( CRLF );
        }
        RecPtr = RecPtrsave1;
    }
}

void ProcFixup( void )
/********************/
{
    byte    typ;

    if( Descriptions ) {
        Output( INDENT "Locat Mode    Method     "
            "  Fixup Frame    Fixup Target(,displacement)" CRLF );
        Output( INDENT "----- ----  -----------  "
            "---------------  ---------------------------" CRLF );
    }
    while( ! EndRec() ) {
        typ = GetByte();
        if( typ & FIXUPP_FIXUP ) {
            explicitFixup( typ );
        } else {
            threadFixup( typ );
        }
    }
}

void ProcModEnd( void )
/*********************/
{
    byte        mod_type;
    byte        typ;
    byte        frame;
    byte        loc;

    mod_type = GetByte();
    Output( INDENT "mod type:%smain module %s" CRLF,
        ( mod_type & 0x80 ) ? "":"non-",
        ( mod_type & 0x40 ) ? "with start address" : ""
    );
    if( mod_type & 0x1 && !EndRec() ) {
        typ = GetByte();
        frame = ( typ >> 4 ) & 0x07;
        Output( INDENT "Frame: " );
        if( typ & FIXDAT_FTHREAD ) {
            Output( "THREAD %u", frame );
        } else {
            doFrame( frame );
        }
        loc = typ & 0x03;
        Output( "  Target: " );
        if( typ & FIXDAT_TTHREAD ) {
            Output( "THREAD %u", loc & 0x03 );
        } else {
            doTarget( loc );
        }
        if( typ & 0x04 ) {
            Output( CRLF );
        } else {
            Output( ",%X" CRLF, GetEither() );
        }
    }
}

static void dmpBytes( int num )
{
    while( num-- > 0 ) {
        Output( " %b", GetByte() );
    }
}

void ProcGrpDef( void )
/*********************/
{
    byte        grptype;
    char        *grpname;
    char        *segname;
    char        *classname;
    unsigned_16 grpidx;
    unsigned_16 idx;
    unsigned_16 idxidx;

    grpidx = GetIndex();
    if( TranslateIndex ) {
        grpname = GetLname( grpidx );
        AddGrpdef( grpidx, 0 ); /* start new grpdef */
        Output( INDENT "name: %u - '%s'" CRLF, grpidx, grpname );
    } else {
        Output( INDENT "name: %u" CRLF, grpidx );
    }
    while( !EndRec() ) {
        grptype = GetByte();
        Output( INDENT "member: " );
        switch( grptype ) {
            case GRP_SEGIDX:
                idx = GetIndex();
                if( TranslateIndex ) {
                    AddGrpdef( grpidx, idx );
                    idxidx = GetGrpseg( idx );
                    segname = GetLname( idxidx );
                    Output( "seg %u - %u - '%s'", idx, idxidx, segname );
                } else {
                    Output( "seg %u", idx );
                }
                break;
            case GRP_EXTIDX:
                idx = GetIndex();
                if( TranslateIndex ) {
                    AddGrpdef( grpidx, idx );
                    segname = GetXname( idx );
                    Output( "ext %u - '%s'", idx, segname );
                } else {
                    Output( "ext %u", idx );
                }
                break;
            case GRP_FULLNAME:
                {
                    unsigned_16 seg;
                    unsigned_16 class;
                    unsigned_16 ovl;

                    seg = GetIndex();
                    class = GetIndex();
                    ovl = GetIndex();
                    if( TranslateIndex ) {
                        AddGrpdef( grpidx, idx );
                        idxidx = GetGrpseg( seg );
                        segname = GetLname( idxidx );
                        classname = GetLname( class );
                        Output( "seg %u - %u - '%s', class %u - '%s', ovl %u",
                            seg, idxidx, segname, class, classname, ovl );
                    } else {
                        Output( "seg %u, class %u, ovl %u", seg, class, ovl );
                    }
                }
                break;
            case GRP_LTLDATA:
                Output( "%b", grptype );
                dmpBytes( 6 );
                break;
            case GRP_ADDR:
                Output( "%b", grptype );
                dmpBytes( 4 );
                break;
            default:
                Output( BAILOUT "Unknown group type(%b)" CRLF, grptype );
                longjmp( BailOutJmp, 1 );
                break;
        }
        Output( CRLF );
    }
}

static unsigned_32 libDictOffs;
static unsigned_16 libDictSize;

void ProcLibHeader( void )
{
    byte                flags;

    Output( INDENT "Page size        : %u" CRLF, RecLen + 4 );
    libDictOffs = GetLInt();
    libDictSize = GetUInt();
    flags = GetByte();
    Output( INDENT "Dictionary Offset: %X" CRLF, libDictOffs );
    Output( INDENT "Dictionary Size  : %x" CRLF, libDictSize );
    Output( INDENT "Case-Sensitive   : %s" CRLF,
        ( flags & 1 ) ? "Yes" : "No" );
    OutputData( 0, 0 );
}

static void doBucket( int bucket )
{
    byte                bucket_value;

    bucket_value = GetByte();
    if( bucket_value == 0 ) {
        Output( "%b:     ", bucket );
    } else {
        Output( "%b:%x", bucket, 2*bucket_value );
    }
}

void ProcLibTrailer( FILE *fp )
{
    unsigned_16         dict_block;
    int                 i;
    int                 free;

    if( fseek( fp, libDictOffs, SEEK_SET ) != 0 ) {
        return;
    }
    ResizeBuff( 512 );
    for( dict_block = 0; dict_block < libDictSize; ++dict_block ) {
        if( fread( RecBuff, 512, 1, fp ) == 0 ) {
             break;
        }
        RecPtr = RecBuff;
        RecLen = 512;
        Output( CRLF "Dictionary Block %x:" CRLF
            INDENT "Buckets:" CRLF INDENT, dict_block );
        for( i = 0; i < 36; i += 6 ) {
            doBucket( i ); Output( "  " );
            doBucket( i + 1 ); Output( "  " );
            doBucket( i + 2 ); Output( "  " );
            doBucket( i + 3 ); Output( "  " );
            doBucket( i + 4 ); Output( "  " );
            doBucket( i + 5 ); Output( CRLF INDENT );
        }
        doBucket( 36 );
        free = GetByte() * 2;
        Output( CRLF INDENT "Free Byte: %x" CRLF INDENT "Entries:" CRLF,
            free );
        while( RecOffset() < free ) {
            i = RecOffset();
            GetName();
            Output( INDENT "%x: %N Page %x" CRLF, i, GetUInt() );
            if( RecOffset() & 1 ) {
                GetByte();
            }
        }
    }
}


static char *PatchType( void )
/****************************/
{
    char                *fix;

    switch( GetByte() ) {
    case 0: fix = "8-bit lobyte";       break;
    case 1: fix = "16-bit offset";      break;
    case 2: fix = "32-bit offset";      break;
    default: fix = "*** ill fix type ***"; break;
    }
    return( fix );
}


static void DoBackPat( void )
/***************************/
{
    unsigned_32         off;
    unsigned_32         val;

    while( !EndRec() ) {
        off = GetEither();
        val = GetEither();
        Output( INDENT "    offset:%X - value:%X" CRLF, off, val );
    }
}


void ProcBackPat( void )
/**********************/
{
    unsigned            seg;
    char                *fix;

    seg = GetIndex();
    fix = PatchType();
    Output( INDENT "Segment:%u - %s" CRLF, seg, fix );
    DoBackPat();
}


void ProcNameBackPat( void )
/**************************/
{
    unsigned            sym;
    char                *fix;

    fix = PatchType();
    sym = GetIndex();
    Output( INDENT "Symbol:%u - %s" CRLF, sym, fix );
    DoBackPat();
}


void ProcComDat( void )
/*********************/
{
    unsigned    flag;
    unsigned    attr;
    unsigned    sel;
    unsigned    alloc;
    unsigned    align;
    unsigned_32 offset;
    unsigned    typ;
    unsigned    sym;
    static char *ComAlign[] = {
        "SEGDEF", "BYTE", "WORD", "PARA", "4K", "DWORD"
    };
    static char *ComSel[] = {
        "NO MATCH", "ANY", "SAME SIZE", "EXACT MATCH"
    };
    static char *ComAlloc[] = {
        "EXPLICIT", "FAR CODE", "FAR DATA", "CODE32", "DATA32"
    };

    flag = GetByte();
    attr = GetByte();
    sel = (attr >> 4) & 0xf;
    alloc = attr & 0xf;
    if( sel > 3 || alloc > 4 ) {
        Output( BAILOUT "Unknown attr => %b" CRLF, attr );
        longjmp( BailOutJmp, 1 );
    }
    align = GetByte();
    if( align > 5 ) {
        Output( BAILOUT "Unknown align => %b" CRLF, align );
        longjmp( BailOutJmp, 1 );
    }
    offset = GetEither();
    typ = GetIndex();
    Output( INDENT "align:%s, select:%s, alloc:%s",
            ComAlign[align], ComSel[sel], ComAlloc[alloc] );
    if( alloc == 0 ) { /* explict allocation */
        Output( " ==> " );
        getBase( FALSE );
    }
    Output( CRLF );
    sym = GetIndex();
    Output( INDENT "sym:%u, typ:%u, offset:%X", sym, typ, offset );
    if( flag & 0x1 ) Output( " continued" );
    if( flag & 0x4 ) Output( " local" );
    if( flag & 0x2 ) Output( " iterated" );
    else             Output( " enumerated" );
    Output( CRLF );
    if( flag & 0x2 ) {
        DoLidata();
    } else {
        OutputData( offset, 0L );
    }
}


void ProcAlias( void )
/********************/
{
    GetName();
    Output( INDENT "alias = <%N> "  );
    GetName();
    Output( "substitue = <%N>" CRLF );
}


void ProcVerNum( void )
/*********************/
{
    GetName();
    Output( INDENT "***** TIS compliant OMF *****" CRLF );
    Output( INDENT INDENT "Version <%N>" CRLF );
}


void ProcVendExt( void )
/**********************/
{
    OutputData( 0L, 0L );
}