cgbksvar.c

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

    SE* ending,                 // - ending entry
    STAB_CTL* sctl )            // - state table definition
{
    SE* se;                     // - current entry
    SE* prev;                   // - previous entry
    SE** hdr;                   // - addr[ state table ]
    boolean done;               // - terminator

    hdr = &sctl->defn->state_table;
    se = *hdr;
    if( se == NULL ) {
        DbgVerify( ending == NULL, "StabCtlPrune: ending != 0 when empty" );
    } else {
        done = FALSE;
        for( ; ; se = prev ) {
            prev = se->base.prev;
            if( ending == 0  ) {
                if( prev == *hdr ) {
                    done = TRUE;
                }
            } else {
                if( se == ending ) break;
            }
            if( ! se->base.gen ) {
                pruneSE( hdr, se );
            } else {
                switch( se->base.se_type ) {
                  case DTC_SET_SV :
                    if( *hdr != se ) {
                        pruneFixUp( &se->set_sv.se );
                    }
                    break;
                  case DTC_TEST_FLAG :
                    pruneFixUp( &se->test_flag.se_true );
                    pruneFixUp( &se->test_flag.se_false );
                    break;
                  default :
                    break;
                }
            }
            if( done ) break;
        }
    }
}


void StabCtlRemove(             // REMOVE LAST STATE ENTRY
    STAB_CTL* sctl )            // - state-table information
{
    stabDefnRemove( sctl->defn );
}


SE* StabCtlPosnGened(           // GET GENERATED POSITION IF REQUIRED
    STAB_CTL* sctl,             // - control info
    SE* src,                    // - source entry
    SE* tgt )                   // - target entry
{
    sctl = sctl;
    if( tgt != NULL && src->base.gen && ! tgt->base.gen ) {
        STATE_VAR sv = tgt->base.state_var;
        if( 0 == sv ) {
            tgt = NULL;
        } else {
            for( ; ; tgt = tgt->base.prev ) {
                if( tgt->base.gen && tgt->base.state_var == sv ) break;
            }
        }
    }
    return tgt;
}


#ifndef NDEBUG


void DbgDumpTypeSigEnt(         // DUMP TYPE_SIG_ENT entries
    TYPE_SIG_ENT* hdr )         // - first entry
{
    TYPE_SIG_ENT* sig;          // - current entry

    RingIterBeg( hdr, sig ) {
        printf( "         TYPE_SIG_ENT[%x]: next[%x] type-sig[%x]\n"
              , sig
              , sig->next
              , sig->sig );
    } RingIterEnd( sig )
}


char const * DbgSeName          // DUMP DTC_... name
    ( unsigned se_type )        // - type of state entry
{
    static char* dtc_names[] = {// - names
        #define DTC_DEF( a ) # a
        #define DTC_MRK( a )
        #define DTC_VAL( a, b ) DTC_DEF(a)
        DTC_DEFS
        #undef  DTC_DEF
        #undef  DTC_MRK
        #undef  DTC_VAL
    };
    char const * sv_name;       // - name to be returned
    if( se_type >= MAX_DTC_DEF ) {
        sv_name = "*** UNKNOWN ***";
    } else {
        sv_name = dtc_names[ se_type ];
    }
    return sv_name;
}


void DbgDumpStateEntry(         // DUMP STATE ENTRY
    void* arg )                 // - state entry
{
    SE* se;                     // - state entry
    char const* sv_name;        // - name of entry

    se = arg;
    sv_name = DbgSeName( se->base.se_type );
    printf( "State Entry[%x]: gen(%d) next(%x) prev(%x) var(%d) %s"
          , se
          , se->base.gen
          , se->base.next
          , se->base.prev
          , se->base.state_var
          , sv_name );
    switch( se->base.se_type ) {
      case DTC_CTOR_TEST :
        printf( "\n    flag(%d)\n"
              , se->ctor_test.flag_no );
        break;
      case DTC_SYM_AUTO :
        printf( "\n    sym(%s) dtor(%s) offset(%x)\n"
              , DbgSymNameFull( se->sym_auto.sym )
              , DbgSymNameFull( se->sym_auto.dtor )
              , se->sym_auto.offset );
        break;
      case DTC_SYM_STATIC :
        printf( "\n    sym(%s) dtor(%s)\n"
              , DbgSymNameFull( se->sym_static.sym )
              , DbgSymNameFull( se->sym_static.dtor ) );
        break;
      case DTC_SET_SV :
        printf( "\n    se(%x = %d)\n"
              , se->set_sv.se
              , SeStateVar( se->set_sv.se ) );
        break;
      case DTC_ACTUAL_VBASE :
      case DTC_ACTUAL_DBASE :
      case DTC_COMP_VBASE :
      case DTC_COMP_DBASE :
      case DTC_COMP_MEMB :
        printf( "\n    reg(%x) offset(%x) dtor(%s)\n"
              , se->component.obj
              , se->component.offset
              , DbgSymNameFull( se->component.dtor ) );
        break;
      case DTC_TEST_FLAG :
        printf( "\n    index(%d) true(%x = %d) false(%x = %d)\n"
              , se->test_flag.index
              , se->test_flag.se_true
              , SeStateVar( se->test_flag.se_true )
              , se->test_flag.se_false
              , SeStateVar( se->test_flag.se_false ) );
        break;
      case DTC_TRY :
        printf( "\n    impl(%x) sigs(%x) sym(%s)\n"
              , se->try_blk.try_impl
              , se->try_blk.sigs
              , DbgSymNameFull( se->try_blk.sym ) );
        DbgDumpTypeSigEnt( se->try_blk.sigs );
        break;
      case DTC_CATCH :
        printf( "\n    try(%x) sig(%x)\n"
              , se->catch_blk.try_blk
              , se->catch_blk.sig );
        break;
      case DTC_FN_EXC :
        printf( "\n    sigs(%x)\n"
              , se->fn_exc.sigs );
        DbgDumpTypeSigEnt( se->fn_exc.sigs );
        break;
      case DTC_ARRAY :
        printf( "\n    offset(%x) sig(%x) count(%x)\n"
              , se->array.offset
              , se->array.sig
              , se->array.count );
        break;
      case DTC_SUBOBJ :
        printf( "\n    offset(%x) original(%x) kind(%s) dtor(%s)\n"
              , se->subobj.offset
              , se->subobj.original
              , DbgSeName( se->subobj.kind )
              , DbgSymNameFull( se->subobj.dtor ) );
        break;
      case DTC_ARRAY_INIT :
        printf( "\n    reg(%x)\n"
              , se->array_init.reg );
        break;
      case DTC_DLT_1 :
      case DTC_DLT_1_ARRAY :
        printf( "\n    op_del(%s) offset(%x)\n"
              , DbgSymNameFull( se->del_1.op_del )
              , se->del_1.offset );
        break;
      case DTC_DLT_2 :
      case DTC_DLT_2_ARRAY :
        printf( "\n    op_del(%s) offset(%x) size(%x)\n"
              , DbgSymNameFull( se->del_2.op_del )
              , se->del_2.offset
              , se->del_2.size );
        break;
    }
}


void DbgDumpStateTableDefn(     // DUMP STATE TABLE DEFINITION
    void* arg )                 // - control info
{
    STAB_DEFN* defn;            // - definition
    SE* se;                     // - current state entry:

    defn = arg;
    if( defn != NULL ) {
        printf( "State Table Definition[%x] R/O(%s) kind(%x)\n"
              , defn
              , DbgSymNameFull( defn->ro ) );
        if( defn->state_table != NULL ) {
            for( se = defn->state_table; ; se = se->base.prev ) {
                DbgDumpStateEntry( se );
                if( se == defn->state_table->base.next ) break;
            }
        }
        fflush( stdout );
    }
}


void DbgDumpStateTable(         // DUMP STATE TABLE INSTANCE
    void* arg )                 // - control info
{
    STAB_CTL* sctl;             // - control info: instance
    STAB_DEFN* defn;            // - control info: definition

    sctl = arg;
    defn = sctl->defn;
    printf( "State Table Instance[%x] definition(%x) R/W(%s)\n"
          , sctl
          , defn
          , DbgSymNameFull( sctl->rw ) );
    DbgDumpStateTableDefn( defn );
    fflush( stdout );
}

#endif



//**********************************************************************
// SE (state entries) Support
//**********************************************************************



SE* StateTableAdd(              // ADD TO STATE TABLE
    SE* se,                     // - state entry
    STAB_CTL* sctl )            // - state table information
{
    return stateTableAddSe( se, &sctl->defn->state_table );
}


SE* SeAlloc(                    // ALLOCATE AN SE ENTRY
    uint_8 se_type )            // - code for entry
{
    SE* se;                     // - new entry

    se = CarveAlloc( seCarver( se_type ) );
    se->base.se_type = se_type;
    se->base.gen = BlkPosnUseStab();;
    return se;
}


SE* SeSetSvPosition(            // LOCATE STATE ENTRY PAST OPTIONAL SET_SV'S
    SE* se )                    // - starting position
{
    for( ; se != NULL; ) {
        switch( se->base.se_type ) {
          case DTC_SET_SV :
            se = se->set_sv.se;
            continue;
          case DTC_CTOR_TEST :
            se = se->base.prev;
            continue;
          default :
            break;
        }
        break;
    }
    return se;
}


STATE_VAR SeStateVar(           // GET STATE VARIABLE AT CURRENT POSITION
    SE* se )                    // - state entry
{
    STATE_VAR state_var;        // - state variable

    if( se == NULL ) {
        state_var = 0;
    } else {
        state_var = se->base.state_var;
    }
    return state_var;
}


STATE_VAR SeStateOptimal(       // GET STATE VALUE FOR POSITION (OPTIMAL)
    SE* se )                    // - state entry
{
    return SeStateVar( SeSetSvPosition( se ) );
}



//**********************************************************************
// Initialization and Completion
//**********************************************************************

static void stabInit(           // INITIALIZATION
    INITFINI* defn )            // - definition
{
    defn = defn;
    carveSE_SYM_STATIC  = CarveCreate( sizeof( SE_SYM_STATIC ),     32 );
    carveSE_SYM_AUTO    = CarveCreate( sizeof( SE_SYM_AUTO ),       32 );
    carveSE_SUBOBJ      = CarveCreate( sizeof( SE_SUBOBJ ),         16 );
    carveSE_TRY         = CarveCreate( sizeof( SE_TRY ),            4  );
    carveSE_CATCH       = CarveCreate( sizeof( SE_CATCH ),          8  );
    carveSE_FN_EXC      = CarveCreate( sizeof( SE_FN_EXC ),         4  );
    carveSE_SET_SV      = CarveCreate( sizeof( SE_SET_SV ),         8  );
    carveSE_TEST_FLAG   = CarveCreate( sizeof( SE_TEST_FLAG ),      16 );
    carveSE_COMPONENT   = CarveCreate( sizeof( SE_COMPONENT ),      16 );
    carveSE_ARRAY_INIT  = CarveCreate( sizeof( SE_ARRAY_INIT ),     4  );
    carveSE_DLT_1       = CarveCreate( sizeof( SE_DLT_1 ),          4  );
    carveSE_DLT_2       = CarveCreate( sizeof( SE_DLT_2 ),          4  );
    carveSE_DLT_1_ARRAY = CarveCreate( sizeof( SE_DLT_1_ARRAY ),    4  );
    carveSE_DLT_2_ARRAY = CarveCreate( sizeof( SE_DLT_2_ARRAY ),    4  );
    carveSE_CTOR_TEST   = CarveCreate( sizeof( SE_CTOR_TEST ),      4  );
    carveSTAB_DEFN      = CarveCreate( sizeof( STAB_DEFN ),         8  );
    carveSTAB_CTL       = CarveCreate( sizeof( STAB_CTL ),          8  );
}


static void stabFini(           // COMPLETION
    INITFINI* defn )            // - definition
{
    defn = defn;
    CarveDestroy( carveSE_SYM_AUTO );
    CarveDestroy( carveSE_SYM_STATIC );
    CarveDestroy( carveSE_SUBOBJ );
    CarveDestroy( carveSE_TRY );
    CarveDestroy( carveSE_CATCH );
    CarveDestroy( carveSE_FN_EXC );
    CarveDestroy( carveSE_SET_SV );
    CarveDestroy( carveSE_TEST_FLAG );
    CarveDestroy( carveSE_COMPONENT );
    CarveDestroy( carveSE_ARRAY_INIT );
    CarveDestroy( carveSE_DLT_1 );
    CarveDestroy( carveSE_DLT_2 );
    CarveDestroy( carveSE_DLT_1_ARRAY );
    CarveDestroy( carveSE_DLT_2_ARRAY );
    CarveDestroy( carveSE_CTOR_TEST );
    CarveDestroy( carveSTAB_DEFN );
    CarveDestroy( carveSTAB_CTL );
}


INITDEFN( state_table, stabInit, stabFini )