ppcrgtbl.c

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

extern  hw_reg_set      ReturnReg( type_class_def class )
/*******************************************************/
{
    switch( class ) {
    case FS:
    case FD:
    case FL:
        return( HW_F1 );
    case XX:
        return( HW_EMPTY );
    case U4:
    case I4:
        return( HW_D3 );
    case U8:
    case I8:
        return( HW_Q3 );
    default:
        return( HW_D3 );
    }
}

extern  hw_reg_set      *ParmRegs( void )
/***************************************/
{
    return( &AllParmRegs[0] );
}


extern  type_class_def  RegClass( hw_reg_set regs )
/*************************************************/
{
    hw_reg_set          test;
    hw_reg_set          *possible;

    if( HW_COvlap( regs, HW_FPR ) )
        return( FD );
    HW_CAsgn( test, HW_BREGS );
    if( HW_Subset( test, regs ) )
        return( U1 );
    HW_CAsgn( test, HW_WREGS );
    if( HW_Subset( test, regs ) )
        return( U2 );
    // 64-bit registers are really pairs of registers; we must explicitly
    // check to see if we match a valid pair
    possible = QWordRegs;
    while( !HW_CEqual( *possible, HW_EMPTY ) ) {
        if( HW_Equal( *possible, regs ) )
            return( U8 );
        ++possible;
    }
    return( U4 );
}


extern  reg_set_index   SegIndex( void )
/**************************************/
{
    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( RL_DWORD );
}


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

    is_temp_index = is_temp_index;
    class = class;
    dregs = &DWordRegs[0];
    while( !HW_CEqual( *dregs, HW_EMPTY ) ) {
        if( HW_Equal( *dregs, reg ) )
            return( TRUE );
        ++dregs;
    }
    return( FALSE );
}


extern  bool    IndexRegOk( hw_reg_set reg, bool is_temp_index )
/**************************************************************/
{
    is_temp_index = is_temp_index;
    reg = reg;
    return( FALSE );
}


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


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

    return( HW_EMPTY );
}


extern  hw_reg_set      High16Reg( hw_reg_set regs )
/**************************************************/
{
    return( HW_EMPTY );
}


extern  hw_reg_set      Low32Reg( hw_reg_set regs )
/*************************************************/
{
    return( HW_EMPTY );
}


extern  hw_reg_set      High32Reg( hw_reg_set regs )
/**************************************************/
{
    return( HW_EMPTY );
}


extern  hw_reg_set      High48Reg( hw_reg_set regs )
/**************************************************/
{
    return( HW_EMPTY );
}


extern  hw_reg_set      Low48Reg( hw_reg_set regs )
/*************************************************/
{
    return( HW_EMPTY );
}


extern  hw_reg_set      Low64Reg( hw_reg_set regs )
/**************************************************
 * return the low order part of 64 bit register "regs"
 */
{
    hw_reg_set  low;
    hw_reg_set  *order;

    if( HW_CEqual( regs, HW_EMPTY ) )
        return( HW_EMPTY );
    order = Reg64Order;
    for( ;; ) {
        if( HW_Ovlap( *order, regs ) )
            break;
        ++order;
    }
    low = regs;
    HW_OnlyOn( low, *order );
    if( HW_Equal( low, regs ) ) {
        low = HW_EMPTY;
    }
    return( low );
}


extern  hw_reg_set      High64Reg( hw_reg_set regs )
/***************************************************
 * return the high order part of 64 bit register "regs"
 */
 {
    hw_reg_set  high;

    high = Low64Reg( regs );
    if( !HW_CEqual( high, HW_EMPTY ) ) {
        HW_TurnOff( regs, high );
        return( regs );
    }
    return( high );
}


extern  hw_reg_set      HighReg( hw_reg_set regs )
/************************************************/
{
    switch( RegClass( regs ) ) {
    case FD:
    case U8:
    case I8:
        return( High64Reg( regs ) );
    default:
        return( HW_EMPTY );
    }
}


extern  hw_reg_set      LowReg( hw_reg_set regs )
/***********************************************/
{
    switch( RegClass( regs ) ) {
    case U8:
    case I8:
    case FD:
        return( Low64Reg( regs ) );
    default:
        return( HW_EMPTY );
    }
}


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


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 ) )
            return( TRUE );
        ++list;
    }
    return( FALSE );
}


extern  reg_set_index   UsualPossible( type_class_def class )
/***********************************************************/
{
    return( IsSets[ class ] );
}


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

extern  hw_reg_set      FixedRegs( void )
/***************************************/
/* MJC do you really want to fix them */
{
    hw_reg_set          fixed;

    HW_CAsgn( fixed, HW_R0 );
    HW_CTurnOn( fixed, HW_R1 );         // stack
    HW_CTurnOn( fixed, HW_R2 );         // toc
    HW_CTurnOn( fixed, HW_R13 );        // must not be used (unlucky)
    HW_CTurnOn( fixed, HW_R31 );        // frame reg
    return( fixed );
}

extern  hw_reg_set      VarargsHomePtr( void )
/********************************************/
{
    return( HW_D14 );
}

extern  hw_reg_set      StackReg( void )
/**************************************/
/* MJC should be up to linkage conventions */
{
    return( HW_D1 );
}

extern  hw_reg_set      FrameReg( void )
/**************************************/
/* MJC should be up to linkage conventions */
{
    if( CurrProc->targ.base_is_fp ) {
        return( HW_D31 );
    }
    return( HW_D1 );
}

extern  hw_reg_set      TocReg( void )
/************************************/
{
    return( HW_D2 );
}

extern  hw_reg_set      FrameBaseReg( void )
/******************************************/
{
    return( HW_D31 );
}

extern  hw_reg_set      ScratchReg( void )
/****************************************/
{
    return( HW_D12 );
}

extern  hw_reg_set      ReturnAddrReg( void )
/*******************************************/
/* BBB Like MJC said ^ */
{
    return( HW_EMPTY );
}


extern  hw_reg_set      DisplayReg( void )
/****************************************/
{
    return( HW_EMPTY );
}


extern  int     SizeDisplayReg( void )
/************************************/
{
    return( 0 );
}


extern  hw_reg_set      AllCacheRegs( void )
/******************************************/
{
    return( HW_EMPTY );
}

extern  hw_reg_set      *GPRegs( void )
/*************************************/
{
    return( DWordRegs );
}

extern  hw_reg_set      *FPRegs( void )
/*************************************/
{
    return( FloatRegs );
}

extern  hw_reg_set      *IdxRegs( void )
/**************************************/
{
    return( DWordRegs );
}

extern  void            InitRegTbl( void )
/****************************************/
{
}

extern  uint_8          RegTrans( hw_reg_set reg )
/************************************************/
{
    int                 i;

    for( i = 0; i < sizeof( DWordRegs ) / sizeof( DWordRegs[0] ); i++ ) {
        if( HW_Subset( DWordRegs[i], reg ) ) return( i );
    }
    for( i = 0; i < sizeof( FloatRegs ) / sizeof( FloatRegs[0] ); i++ ) {
        if( HW_Equal( reg, FloatRegs[i] ) ) return( i );
    }
    return( 0 );
}

extern  ppc_regn PpcRegN( name *reg_name )
/****************************************/
/** Translate reg name to enum name***/
{
    hw_reg_set reg;
    int       i;

    reg = reg_name->r.reg;

    for( i = 0; i < sizeof( DWordRegs ) / sizeof( DWordRegs[0] ); i++ ) {
        if( HW_Subset( DWordRegs[i], reg ) )
            return( i + PPC_REGN_r0 );
    }
    for( i = 0; i < sizeof( FloatRegs ) / sizeof( FloatRegs[0] ); i++ ) {
        if( HW_Equal( reg, FloatRegs[i] ) )
            return( i + PPC_REGN_f0 );
    }
    _Zoiks( ZOIKS_031 );
    return( PPC_REGN_END );
}

extern hw_reg_set ParmRegConflicts( hw_reg_set r )
/************************************************/
{
    return( r );
}