cinfo.c

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

        }
    }
    for( tseg = TextSegList; tseg != NULL; tseg = tseg->next ) {/*04-jun-94*/
        if( tseg->segment_number == requested_seg )  {
            // class name appears after the segment name
            classname = strchr( tseg->segname, '\0' ) + 1;
            // if class name not specified, then use the default
            if( *classname == '\0' )  classname = CodeClassName;
            return( classname );
        }
    }
    if( DataSegName != NULL && *DataSegName != '\0' ) {
        return( "FAR_DATA" );                           /* 10-nov-92 */
    }
    return( NULL );
}


void SetSegSymHandle( SYM_HANDLE sym_handle, int segment )
{
    struct seg_name     *seg;

    for( seg = &Predefined_Segs[0]; seg->name; seg++ ) {
        if( seg->segment == segment ) {
            seg->sym_handle = sym_handle;
            break;
        }
    }
}


SYM_HANDLE SegSymHandle( int segment )                  /* 15-mar-92 */
{
    struct seg_name     *seg;
    struct user_seg     *useg;
    char                *sym_name;

    for( seg = &Predefined_Segs[0]; seg->name; seg++ ) {
        if( seg->segment == segment ) {
            return( seg->sym_handle );
        }
    }
    for( useg = UserSegments; useg; useg = useg->next ) {
        if( useg->segment == segment ) {
            if( useg->sym_handle == 0 ) {
                sym_name = CMemAlloc( strlen( useg->name ) + 2 );
                strcpy( &sym_name[1], useg->name );
                sym_name[0] = '.';
                useg->sym_handle = SegSymbol( sym_name, 0 );
            }
            return( useg->sym_handle );
        }
    }
    return( 0 );
}

hw_reg_set *SegPeggedReg( unsigned requested_seg )
{
    struct user_seg     *useg;

    for( useg = UserSegments; useg; useg = useg->next ) {
        if( useg->segment == requested_seg )
            return( &useg->pegged_register );
    }
    return( NULL );
}


static unsigned SegAlign( unsigned suggested )
/********************************************/
{
    unsigned            align;

    align = suggested;
    if( CompFlags.unaligned_segs ) {
        align = 1;
    }
    return( align );
}

void    SetSegs( void )
/*********************/
{
    int                 seg;
    struct user_seg     *useg;
    struct textsegment  *tseg;
    int                 flags;
    char                *name;

    CompFlags.low_on_memory_printed = 0;
    flags = GLOBAL | INIT | EXEC;
    if( *TextSegName == '\0' ) {
        name = TS_SEG_CODE;
    } else {
        name = TextSegName;
        flags |= GIVEN_NAME;
    }
    BEDefSeg( SEG_CODE, flags, name,
                SegAlign( (OptSize == 0) ? BETypeLength( T_INTEGER ) : 1 ) );
    BEDefSeg( SEG_CONST, BACK|INIT|ROM, TS_SEG_CONST,
                SegAlign( SegAlignment[SEG_CONST] ) );
    BEDefSeg( SEG_CONST2, INIT | ROM, TS_SEG_CONST2,
                SegAlign( SegAlignment[SEG_CONST2] ) );
    BEDefSeg( SEG_DATA,  GLOBAL | INIT, TS_SEG_DATA,
                SegAlign( SegAlignment[SEG_DATA] ) );
    if( CompFlags.ec_switch_used ) {            /* 04-apr-92 */
        BEDefSeg( SEG_YIB,      GLOBAL | INIT,  TS_SEG_YIB, 2 );
        BEDefSeg( SEG_YI,       GLOBAL | INIT,  TS_SEG_YI,  2 );
        BEDefSeg( SEG_YIE,      GLOBAL | INIT,  TS_SEG_YIE, 2 );
    }
    if( CompFlags.bss_segment_used ) {
        BEDefSeg( SEG_BSS,      GLOBAL,         TS_SEG_BSS,
                SegAlign( SegAlignment[ SEG_BSS ] ) );
    }
    if( CompFlags.far_strings ) {
        FarStringSegment = SegmentNum;          /* 10-mar-95 */
        ++SegmentNum;
    }
    for( seg = FIRST_PRIVATE_SEGMENT; seg < SegmentNum; ++seg ) {
        sprintf( Buffer, "%s%d_DATA", ModuleName, seg );
        BEDefSeg( seg, INIT | PRIVATE, Buffer, SegAlign( 16 ) );
    }
    for( useg = UserSegments; useg != NULL ; useg = useg->next ) {
        seg = useg->segment;
        switch( useg->segtype ) {
//      case SEGTYPE_CODE:
//          BEDefSeg( seg, INIT | GLOBAL | EXEC, useg->name, 1 );
//          break;
        case SEGTYPE_DATA:  /* created through #pragma data_seg */
            BEDefSeg( seg, INIT | GLOBAL | NOGROUP, useg->name, SegAlign( TARGET_INT ) );
            break;
        case SEGTYPE_BASED:
            BEDefSeg( seg, INIT | PRIVATE | GLOBAL, useg->name, SegAlign( TARGET_INT ) );
            break;
        case SEGTYPE_INITFINI:
            BEDefSeg( useg->segment, INIT | GLOBAL, useg->name, SegAlign( 1 ) );
            break;
        case SEGTYPE_INITFINITR:
            BEDefSeg( useg->segment, INIT | GLOBAL| THREAD_LOCAL, useg->name, SegAlign( 1 ) );
            break;
        }
    }
    for( tseg = TextSegList; tseg != NULL; tseg = tseg->next ) {
        tseg->segment_number = ++SegmentNum;
        BEDefSeg( tseg->segment_number,  GLOBAL | INIT | EXEC | GIVEN_NAME,
                tseg->segname,
                SegAlign( (OptSize == 0) ? BETypeLength( T_INTEGER ) : 1 ) );
    }
}

void EmitSegLabels( void )                                  /* 15-mar-92 */
{
    int                 seg;
    struct user_seg     *useg;
    BACK_HANDLE         bck;
    SYM_ENTRY           sym;

    seg = FIRST_USER_SEGMENT;
    for( useg = UserSegments; useg; useg = useg->next ) {
        if( useg->sym_handle != 0 ) {
            SymGet( &sym, useg->sym_handle );
            bck = BENewBack( useg->sym_handle );
            sym.info.backinfo = bck;
            SymReplace( &sym, useg->sym_handle );
            BESetSeg( seg );
            DGLabel( bck );
        }
        ++seg;
    }
}


void FiniSegLabels( void )                                  /* 15-mar-92 */
{
    struct user_seg     *useg;
    SYM_ENTRY           sym;

    for( useg = UserSegments; useg; useg = useg->next ) {
        if( useg->sym_handle != 0 ) {
            SymGet( &sym, useg->sym_handle );
            BEFiniBack( sym.info.backinfo );
        }
    }
}


void FiniSegBacks( void )                                   /* 15-mar-92 */
{
    struct user_seg     *useg;
    SYM_ENTRY           sym;

    for( useg = UserSegments; useg; useg = useg->next ) {
        if( useg->sym_handle != 0 ) {
            SymGet( &sym, useg->sym_handle );
            BEFreeBack( sym.info.backinfo );
        }
    }
}


char *FEName( CGSYM_HANDLE cgsym_handle )
/**** return unmangled names ***********/
{
    SYM_HANDLE  sym_handle;
    SYMPTR      sym;

    sym_handle = cgsym_handle;
    if( sym_handle == 0 ) return( "*** NULL ***" );
    sym = SymGetPtr( sym_handle );
    return( sym->name );
}


void FEMessage( int class, void *parm )
/*************************************/
{
    char    msgtxt[80];
    char    msgbuf[MAX_MSG_LEN];

    switch( class ) {
    case MSG_SYMBOL_TOO_LONG:
        {
            SYM_ENTRY   *sym;

            sym = SymGetPtr( (SYM_HANDLE)parm );
            SetSymLoc( sym );
            CWarn( WARN_SYMBOL_NAME_TOO_LONG, ERR_SYMBOL_NAME_TOO_LONG, sym->name );
        }
        break;
    case MSG_BLIP:
        if( !CompFlags.quiet_mode ) {
            ConBlip();
        }
        break;
    case MSG_INFO_FILE:
    case MSG_INFO_PROC:
        NoteMsg( parm );
        break;
    case MSG_CODE_SIZE:
        if( !CompFlags.quiet_mode ) {
            CGetMsg( msgtxt, PHRASE_CODE_SIZE );
            sprintf( msgbuf, "%s: %u", msgtxt, (unsigned)parm );
            NoteMsg( msgbuf );
        }
        break;
    case MSG_DATA_SIZE:
        break;
    case MSG_ERROR:
        CErr2p( ERR_USER_ERROR_MSG, parm );
        break;
    case MSG_FATAL:
        CErr2p( ERR_FATAL_ERROR, parm );
        CloseFiles();       /* get rid of temp file */
        MyExit( 1 );        /* exit to DOS do not pass GO */
        break;
    case MSG_BAD_PARM_REGISTER:
        /* this will be issued after a call to CGInitCall or CGProcDecl */
        CErr2( ERR_BAD_PARM_REGISTER, (int)parm );
        break;
    case MSG_BAD_RETURN_REGISTER:
        CErr2p( ERR_BAD_RETURN_REGISTER, FEName( (CGSYM_HANDLE)parm ) );
        break;
    case MSG_SCHEDULER_DIED:                    /* 26-oct-91 */
    case MSG_REGALLOC_DIED:
    case MSG_SCOREBOARD_DIED:
        if( !(GenSwitches & NO_OPTIMIZATION) ) {
            if( LastFuncOutOfMem != (CGSYM_HANDLE)parm ) {
                CInfoMsg( INFO_NOT_ENOUGH_MEMORY_TO_FULLY_OPTIMIZE,
                            FEName( (CGSYM_HANDLE)parm ) );
                LastFuncOutOfMem = (CGSYM_HANDLE)parm;
            }
        }
        break;
    case MSG_PEEPHOLE_FLUSHED:
        if( !(GenSwitches & NO_OPTIMIZATION) ) {
            if( WngLevel >= 4 ) {
                if( CompFlags.low_on_memory_printed == 0 ) {
                    CInfoMsg( INFO_NOT_ENOUGH_MEMORY_TO_MAINTAIN_PEEPHOLE);
                    CompFlags.low_on_memory_printed = 1;
                }
            }
        }
        break;
    case MSG_BACK_END_ERROR:
        CErr2( ERR_BACK_END_ERROR, (int)parm );
        break;
    case MSG_BAD_SAVE:
        CErr2p( ERR_BAD_SAVE, FEName( (CGSYM_HANDLE)parm ) );
        break;
    case MSG_BAD_LINKAGE:
        CErr2p( ERR_BAD_LINKAGE, FEName( (CGSYM_HANDLE)parm ) );
        break;
    case MSG_NO_SEG_REGS:
        CErr2p( ERR_NO_SEG_REGS, FEName( (CGSYM_HANDLE)parm ) );
        break;
    case MSG_BAD_PEG_REG:
        CErr2p( ERR_BAD_PEG_REG, FEName( (CGSYM_HANDLE)parm ) );
        break;
    default:
        break;
    }
}


char *FEModuleName( void )
/************************/
{
    return( ModuleName );
}


int FETrue( void )
/****************/
{
    return( 1 );
}


segment_id FESegID( CGSYM_HANDLE cgsym_handle )
/*********************************************/
{
    SYM_HANDLE  sym_handle = cgsym_handle;
    segment_id  id;
    SYMPTR      sym;

    sym = SymGetPtr( sym_handle );
#if _CPU == 370
    {
        id = SymSegId( sym );
    }
#else
    {
        fe_attr     attr;

        attr = FESymAttr( sym );
        if( attr & FE_PROC ) {
            /* in large code models, should return different segment #
             * for every imported routine.  24-jun-88
             */
            id = SEG_CODE;
            if( sym->seginfo != NULL ) {
                id = sym->seginfo->segment_number;
            } else if( attr & FE_IMPORT ) {
                if( (sym->attrib & FLAG_FAR) || (TargetSwitches & BIG_CODE) ) {
                    if( sym->flags & SYM_ADDR_TAKEN ) {
                        id = SegImport;
                        --SegImport;
                    }
                }
            }
        } else if( sym->u.var.segment != 0 ) {
            id = sym->u.var.segment;
        } else if( attr & FE_GLOBAL ) {
            id = SEG_DATA;
        } else {
            id = SEG_CONST;
        }
    }
#endif
    return( id );
}


BACK_HANDLE FEBack( CGSYM_HANDLE cgsym_handle )
/*********************************************/
{
    SYM_HANDLE          sym_handle = cgsym_handle;
    BACK_HANDLE         bck;
    SYMPTR              symptr;
    SYM_ENTRY           sym;

    symptr = SymGetPtr( sym_handle );
    bck = symptr->info.backinfo;
    if( bck == NULL ) {
        bck = BENewBack( sym_handle );
        SymGet( &sym, sym_handle );
        sym.info.backinfo = bck;
        SymReplace( &sym, sym_handle );
    }
    return( bck );
}


int FELexLevel( CGSYM_HANDLE cgsym_handle )
/*****************************************/
{
    cgsym_handle = cgsym_handle;
    return( 0 );
}


#if _CPU == _AXP
int FEParmType( CGSYM_HANDLE func, CGSYM_HANDLE parm, int tipe )
/**************************************************************/
{
    func = func;
    parm = parm;
    switch( tipe ) {
    case T_INT_1:
    case T_INT_2:
    case T_INT_4:
    case T_UINT_4:
    case T_INTEGER:
    case TY_UNSIGNED:
    case T_POINTER:
    case T_CODE_PTR:
    case T_NEAR_POINTER:
    case T_NEAR_CODE_PTR:
        return( T_INT_8 );
    case T_UINT_1:
    case T_UINT_2:
        return( T_UINT_8 );
    case TY_DOUBLE:
    case T_SINGLE:
    case T_LONG_DOUBLE:
        return( TY_DOUBLE );
    default:
        return( tipe );
    }
}
#else
int FEParmType( CGSYM_HANDLE func, CGSYM_HANDLE parm, int tipe )
/**************************************************************/
{
#if _CPU == 386
    SYM_HANDLE  sym_handle = func;
    SYMPTR      sym;
#else
    func = func;
#endif

    parm = parm;
    switch( tipe ) {
#if _CPU == 386 || _CPU == 370 || _CPU == _PPC || _CPU == _MIPS
    case T_UINT_2:
    case T_INT_2:
#endif
    case T_INT_1:
    case T_UINT_1:
#if _CPU == 386
        if( sym_handle != 0 ) {                         /* 22-mar-94 */
            sym = SymGetPtr( sym_handle );
            if( sym->attrib & FLAG_FAR16 ) {
                return( T_INT_2 );
            }
        }
#endif
        tipe = T_INTEGER;
    }
    return( tipe );
}
#endif


int FEStackChk( CGSYM_HANDLE cgsym_handle )
/*****************************************/
{
    SYM_HANDLE  sym_handle = cgsym_handle;
    SYMPTR      sym;

    sym = SymGetPtr( sym_handle );
    return( (sym->flags & SYM_CHECK_STACK) != 0 );
}

void SegInit( void )
{
    int         seg;

    UserSegment = FIRST_USER_SEGMENT;
    for( seg = 0; seg < FIRST_PRIVATE_SEGMENT; seg++ ) {
        SegAlignment[seg] = TARGET_INT;
    }
}

void SetSegAlign( SYMPTR sym )                          /* 02-feb-92 */
{
    unsigned int        align;
    unsigned int        segment;

    segment = sym->u.var.segment;
    if( segment < FIRST_PRIVATE_SEGMENT  &&  OptSize == 0 ) {
        align = GetTypeAlignment( sym->sym_type );
        SegAlignment[segment] = max( align, SegAlignment[segment] );
    }
}