s37rgtbl.c

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

/************************************************************/
    class=class;
    return( RegSets[ RL_WORD ] );
}


extern  hw_reg_set      InLineParm( hw_reg_set regs, hw_reg_set used ) {
/**********************************************************************/

    regs = regs; used = used;
    return( HW_EMPTY );
}


extern  hw_reg_set      StructReg() {
/***********************************/

    return( HW_EMPTY );
}


extern  hw_reg_set      ReturnReg( type_class_def class,
                                   call_attributes attr ) {
/*********************************************************/

    hw_reg_set          *list;

    if( attr & ROUTINE_OS ) {
        list = RegSets[  OSReturnSets[  class  ]  ];
    } else {
        list = RegSets[  ReturnSets[  class  ]  ];
    }
    return( *list );
}


extern  reg_set_index   SegIndex() {
/**********************************/

    return( RL_  );
}


extern  reg_set_index   NoSegments( reg_set_index idx ) {
/*******************************************************/

    return( idx );
}


extern  reg_set_index   IndexIntersect( reg_set_index curr,
                                       type_class_def class,
                                       bool is_temp_index ) {
/***********************************************************/

    is_temp_index = is_temp_index;
    return( RegIntersect( curr, IndexSets[  class  ] ) );
}


extern  bool    IsIndexReg( hw_reg_set reg, type_class_def class,
                            bool is_temp_index ) {
/************************************************/

    hw_reg_set  *list;

    is_temp_index = is_temp_index;
    list = RegSets[  IndexSets[  class  ]  ];
    while( !HW_CEqual( *list, HW_EMPTY ) ) {
        if( HW_Equal( *list, reg ) ) break;
        ++ list;
    }
    return( HW_Equal( *list, reg ) );
}


extern  bool    IndexRegOk( hw_reg_set reg, bool is_temp_index ) {
/****************************************************************/

    hw_reg_set  *list;

    is_temp_index = is_temp_index;
    if( RegClass( reg ) == U4 ) {
        list = RegSets[  RL_INDEX  ];
    } else {
        list = RegSets[  RL_ ];
    }
    while( !HW_CEqual( *list, HW_EMPTY ) ) {
        if( HW_Equal( *list, reg ) ) break;
        ++ list;
    }
    return( HW_Equal( *list, reg ) );
}


extern  bool    IsSegReg( hw_reg_set regs ) {
/*******************************************/
    regs = regs;
    return( FALSE );
}


extern  hw_reg_set      LowTreePart( hw_reg_set regs ) {
/*******************************************************/

    return( LowOffsetReg( regs ) );
}


extern  hw_reg_set      LowOffsetReg( hw_reg_set regs ) {
/*******************************************************/

    return( HighReg( regs ) );
}


extern  hw_reg_set      High64Reg( hw_reg_set regs ) {
/*****************************************************/

    return( HighReg( regs ) );
}


extern  hw_reg_set      HighReg( hw_reg_set regs ) {
/**************************************************/

    switch( RegClass( regs ) ) {
    case XX:
        HW_COnlyOn( regs, HW_EVEN );
        return( regs );
    case FD:
        HW_COnlyOn( regs, HW_SNGL );
        return( regs );
    }
    return( HW_EMPTY );
}


extern  hw_reg_set      HighTreePart( hw_reg_set regs ) {
/********************************************************/

    return( HighOffsetReg( regs ) );
}


extern  hw_reg_set      HighOffsetReg( hw_reg_set regs ) {
/********************************************************/

    return( LowReg( regs ) );
}


extern  hw_reg_set      Low64Reg( hw_reg_set regs ) {
/***************************************************/

    return( LowReg( regs ) );
}


extern  hw_reg_set      LowReg( hw_reg_set regs ) {
/*************************************************/

    switch( RegClass( regs ) ) {
    case XX:
        HW_COnlyOn( regs, HW_ODD );
        return( regs );
    }
    return( HW_EMPTY );
}

extern  hw_reg_set      FullReg( hw_reg_set regs ) {
/**************************************************/
    return( regs );
}


extern  type_class_def  RegClass( hw_reg_set regs ) {
/***************************************************/

    hw_reg_set          *possible;
    type_class_def      class;

    if( HW_COvlap( regs, HW_FLTS ) ) {
        class = FS;
    } else {
        class = U1;
    }
    for(;;) {
        possible = RegSets[  ClassSets[  class  ]  ];
        while( !HW_CEqual( *possible, HW_EMPTY ) ) {
            if( HW_Equal( *possible, regs ) ) return( class );
            ++ possible;
        }
        ++ class;
        if( class == XX ) break;
    }
    return( class );
}


extern  bool    IsRegClass( hw_reg_set regs, type_class_def class ) {
/*******************************************************************/

    hw_reg_set  *list;

    list = RegSets[  IsSets[  class  ]  ];
    while( !HW_CEqual( *list, HW_EMPTY ) ) {
        if( HW_Equal( *list, regs ) ) break;
        ++ list;
    }
    return( !HW_CEqual( *list, HW_EMPTY ) );
}


extern  hw_reg_set      ActualParmReg( hw_reg_set reg ) {
/*******************************************************/
    return( reg );
}


extern  hw_reg_set      FixedRegs() {
/***********************************/

    hw_reg_set  fixed;

    fixed = WordRegs[ CurrProc->state.regs.GP ];
    HW_TurnOn( fixed, WordRegs[ CurrProc->state.regs.SP ] );
    HW_TurnOn( fixed, WordRegs[ CurrProc->state.regs.RA ] );
    HW_TurnOn( fixed, WordRegs[ CurrProc->state.regs.BR ] );
    HW_TurnOn( fixed, WordRegs[ CurrProc->state.regs.AR ] );
    HW_TurnOn( fixed, WordRegs[ CurrProc->state.regs.PA ] );
    if( CurrProc->state.attr & ROUTINE_OS ) {
        HW_TurnOn( fixed, WordRegs[ CurrProc->state.regs.SA ] );
    }
    return( fixed );
}


extern  hw_reg_set      LNReg() {
/**********************************/

    return( WordRegs[ CurrProc->state.regs.LN ] );
}


extern  hw_reg_set      RAReg() {
/**********************************/

    return( WordRegs[ CurrProc->state.regs.RA ] );
}


extern  bool            IsStackReg( name *sp ) {
/**********************************************/
    sp = sp;
    return( FALSE );
}


extern  hw_reg_set      StackReg() {
/**********************************/

    return( WordRegs[ CurrProc->state.regs.SP ] );
}


extern  hw_reg_set      GblReg() {
/********************************/

    return( WordRegs[ CurrProc->state.regs.GP ] );
}


extern  hw_reg_set      DisplayReg() {
/************************************/

    return( WordRegs[ CurrProc->state.regs.AR ] );
}


static  hw_reg_set      FirstReg( hw_reg_set regs, hw_reg_set *table ) {
/***********************************************************************

*/
    while( !HW_CEqual( *table, HW_EMPTY ) ) {
        if( HW_Subset( regs, *table ) ) return( *table );
        ++table;
    }
    return( HW_EMPTY );
}


extern hw_reg_set       FirstWordReg( hw_reg_set regs )
/*****************************************************/
{
    return( FirstReg( regs, WordRegs ) );
}


extern hw_reg_set       FirstSingleReg( hw_reg_set regs )
/*****************************************************/
{
    return( FirstReg( regs, SingleRegs ) );
}


extern hw_reg_set       FirstDoubleReg( hw_reg_set regs )
/*****************************************************/
{
    return( FirstReg( regs, DoubleRegs ) );
}


extern  hw_reg_set      WordReg( int i ) {
/****************************************/

    return( WordRegs[ i ] );
}


extern  int     SizeDisplayReg() {
/********************************/

    return( WORD_SIZE );
}


extern  hw_reg_set      AllCacheRegs() {
/**************************************/

    return( HW_EMPTY );
}

extern  hw_reg_set      *IdxRegs() {
/**********************************/

    return( IndexRegs );
}

extern  bool            IsRegPair( hw_reg_set reg ) {
/***************************************************/

    hw_reg_set  *curr;

    for( curr = PairRegs; !HW_CEqual( *curr, HW_EMPTY ); ++curr ) {
        if( HW_Equal( *curr, reg ) ) return( TRUE );
    }
    return( FALSE );
}