cinfo.c

Open Watcom 的 C 编译器源代码

static struct spc_info InitFiniSegs[INITFINI_SIZE] = {
    { TS_SEG_TIB, "DATA",           SEGTYPE_INITFINI },
    { TS_SEG_TI,  "DATA",           SEGTYPE_INITFINI },
    { TS_SEG_TIE, "DATA",           SEGTYPE_INITFINI },
    { TS_SEG_XIB, "DATA",           SEGTYPE_INITFINI },
    { TS_SEG_XI,  "DATA",           SEGTYPE_INITFINI },
    { TS_SEG_XIE, "DATA",           SEGTYPE_INITFINI },
    { TS_SEG_YIB, "DATA",           SEGTYPE_INITFINI },
    { TS_SEG_YI,  "DATA",           SEGTYPE_INITFINI },
    { TS_SEG_YIE, "DATA",           SEGTYPE_INITFINI },
    { TS_SEG_TLSB, TS_SEG_TLS_CLASS,SEGTYPE_INITFINITR },
    { TS_SEG_TLS,  TS_SEG_TLS_CLASS,SEGTYPE_INITFINITR },
    { TS_SEG_TLSE, TS_SEG_TLS_CLASS,SEGTYPE_INITFINITR },
};

static struct spc_info *InitFiniLookup( char *name ){
    int i;

    for( i = 0; i < INITFINI_SIZE; ++i ){
        if( strcmp( InitFiniSegs[i].name, name ) == 0 ){
            i = (i/3)*3;
            return( &InitFiniSegs[i] );
        }
    }
    return( NULL );
}

static int AddSeg( char *segname, char *class_name, int segtype )
{
    struct seg_name     *seg;
    struct user_seg     *useg, **lnk;
    hw_reg_set          reg;
    char                *p;

    for( seg = &Predefined_Segs[0]; seg->name; seg++ ) {
        if( strcmp( segname, seg->name ) == 0 ){
            return( seg->segment );
        }
    }
    HW_CAsgn( reg, HW_EMPTY );
    p = segname;
    for( ;; ) {
        if( *p == '\0' ) break;
        if( *p == ':' ) {
            *p = '\0';
            reg = PragRegName( segname );
            *p = ':';
            segname = p + 1;
            break;
        }
        ++p;
    }
    lnk = &UserSegments;
    while( (useg = *lnk) != NULL ){
        if( strcmp( segname, useg->name ) == 0 ) {
            return( useg->segment ); /* 11-mar-93 - was return( segment ) */
        }
        lnk = &useg->next;
    }
    useg = AllocUserSeg( segname, class_name, segtype );
    useg->next = *lnk;
    useg->pegged_register = reg;
    *lnk = useg;
    return( useg->segment );
}

int AddSegName( char *segname, char *class_name, int segtype ){
    struct spc_info  *initfini;
    int segid;

    initfini = InitFiniLookup( segname );
    if( initfini != NULL ){
        AddSeg( initfini[0].name, initfini[0].class_name, initfini[0].segtype );
        AddSeg( initfini[1].name, initfini[1].class_name, initfini[1].segtype );
        AddSeg( initfini[2].name, initfini[2].class_name, initfini[2].segtype );
    }
    segid = AddSeg( segname, class_name, segtype );
    return( segid );
}

int DefThreadSeg( void ){
    int segid;

    segid = AddSegName( TS_SEG_TLS, "DATA", SEGTYPE_INITFINI );
    return( segid );
}

void SetFuncSegment( SYMPTR sym, int segment )
{
    struct user_seg     *useg;

    for( useg = UserSegments; useg; useg = useg->next ) {
        if( useg->segment == segment ) {
            sym->seginfo = LkSegName( useg->name, "CODE" );
            break;
        }
    }
}

char *SegClassName( unsigned requested_seg )
{
    struct user_seg     *useg;
    struct textsegment  *tseg;
    char                *classname;
    int                 len;

    if( requested_seg == SEG_CODE )  return( CodeClassName );/* 01-mar-90*/
    for( useg = UserSegments; useg; useg = useg->next ) {
        if( useg->segment == requested_seg  &&  useg->class_name != NULL ) {
            classname = useg->class_name;
            if( classname[0] == '\0' ) {                /* 07-jun-94 */
                len = strlen( useg->name );
                if( len >= 4 ) {
                    if( stricmp( useg->name + len - 4, "DATA" ) == 0 ) {
                        classname = "FAR_DATA";
                    } else if( stricmp( useg->name + len - 4, "TEXT" ) == 0 ){
                        classname = "CODE";
                    }
                }
            }
            return( classname );
        }
    }
    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 );
}

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

    if( segment == SEG_CODE )  return( Sym_CS );
    if( segment == SEG_STACK ) return( Sym_SS );        /* 13-dec-92 */
    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 );
            }
            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()
/******************************************/
{
    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:
            BEDefSeg( seg, INIT | GLOBAL, 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()                                    /* 15-mar-92 */
{
    int                 seg;
    struct user_seg     *useg;
    BACK_HANDLE         bck;
    auto 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;
    auto 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;
    auto 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( msg_class class, void *parm )
/*******************************************/
{
    char  msgtxt[80];
    char  msgbuf[MAX_MSG_LEN];

    switch( class ) {
    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: