cinfo.c

Open Watcom 的 C 编译器源代码

        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:
#ifdef QNX_FLAKEY
        {
            extern unsigned long OrigModel;
            extern unsigned long Model;
            DumpString( "FE:about to issue msg: " );
            Dump8h( OrigModel );
            DumpString( " -> " );
            Dump8h( Model );
            DumpString( "\r\n" );
            if( !CompFlags.emit_dependencies ) {
                extern boom();
                #pragma aux boom = 0xf 0xff 0xff 0xff
                boom();
            }
        }
#endif
        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()
/******************/
{
    return( ModuleName );
}


int FETrue()
/**********/
{
    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;
    auto 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 _MACHINE == _ALPHA
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 == 601
    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 );
}

#endif

void SegInit()
{
    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] );
    }
}

// query routines called from the FAST code generator
#if    0

int FELocalSym( SYM_HANDLE sym_handle )
{
    SYMPTR      sym;

    sym = SymGetPtr( sym_handle );
    if( sym->stg_class == SC_AUTO || sym->stg_class == SC_REGISTER ) {
        return( 1 );
    }
    return( 0 );
}

int FEFuncReturnVar( SYM_HANDLE sym_handle )
{
    SYMPTR      sym;

    sym = SymGetPtr( sym_handle );
    if( sym->flags & SYM_FUNC_RETURN_VAR ) {
        return( 1 );
    }
    return( 0 );
}

int FEIsCSOverride( TREEPTR opnd )
{
    if( opnd->op.opr == OPR_PUSHSYM && opnd->op.sym_handle == Sym_CS ) {
        return( 1 );
    }
    return( 0 );
}

int FEIsSSOverride( TREEPTR opnd )
{
    if( opnd->op.opr == OPR_PUSHSYM && opnd->op.sym_handle == Sym_SS ) {
        return( 1 );
    }
    return( 0 );
}

signed_32 FEGetSymOffset( SYM_HANDLE sym_handle )
{
    return( SymGetPtr( sym_handle )->u.var.offset );
}

void FESetSymOffset( SYM_HANDLE sym_handle, signed_32 offset )
{
    SYM_ENTRY   sym;

    SymGet( &sym, sym_handle );
    sym.u.var.offset = offset;
    SymReplace( &sym, sym_handle );
}

// called at start of each function and scope to process local variables
static void FELocalDecls( SYM_HANDLE auto_handle,
                 int (*DoAutoDecl)(void *,char *,unsigned),
                 void *auto_info )
{
    int         size;
    SYM_ENTRY   sym;

    while( auto_handle != 0 ) {
        SymGet( &sym, auto_handle );
        if( !(sym.flags & SYM_FUNC_RETURN_VAR) ) {
            if( sym.stg_class == SC_STATIC ) {
                EmitSym( &sym, auto_handle );
            } else if( sym.stg_class != SC_EXTERN ) {
                size = SizeOfArg( sym.sym_type );
                sym.u.var.offset = (*DoAutoDecl)( auto_info, sym.name, size );
                SymReplace( &sym, auto_handle );
                if( GenSwitches & DBG_LOCALS ) {
                    if( !(sym.flags & SYM_TEMP) ) {
                        DBLocalSym( auto_handle, CGenType( sym.sym_type ) );
                        DBSetSymLoc( auto_handle, sym.u.var.offset );
                    }
                }
            }
        }
        auto_handle = sym.handle;
    }
}

// called at start of each function to process local variables
void FEAutoDecls( SYM_HANDLE func_handle,
                 int (*DoAutoDecl)(void *,char *,unsigned),
                 void *auto_info )
{
    FELocalDecls( SymGetPtr(func_handle)->u.func.locals,
                        DoAutoDecl, auto_info );
}

// called at start of each scope to process local variables
void FEScopeDecls( TREEPTR newblock,
                 int (*DoAutoDecl)(void *,char *,unsigned),
                 void *auto_info )
{
    FELocalDecls( newblock->op.sym_handle, DoAutoDecl, auto_info );
}

// called at start of each function
void FEDumpParmSyms( TREEPTR parm )
{
    SYM_HANDLE  parm_handle;

    while( parm != NULL ) {
        parm_handle = parm->sym.sym_handle;
        DBLocalSym( parm_handle, CGenType( parm->expr_type ) );
        parm = parm->right;
    }
}
#endif