mipsrgtbl.c

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

    case U8:
    case I8:
        return( HW_Q2 );
    default:
        return( HW_R2 );
    }
}


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


extern  hw_reg_set ParmRegConflicts( hw_reg_set regs )
/****************************************************/
{
    hw_reg_set          conflicts;

    conflicts = regs;
    if( HW_COvlap( regs, HW_R4 ) ) {
        HW_CTurnOn( conflicts, HW_F4 );
        HW_CTurnOn( conflicts, HW_R4 );
    }
    if( HW_COvlap( regs, HW_R5 ) ) {
        HW_CTurnOn( conflicts, HW_F5 );
        HW_CTurnOn( conflicts, HW_R5 );
    }
    if( HW_COvlap( regs, HW_R6 ) ) {
        HW_CTurnOn( conflicts, HW_F6 );
        HW_CTurnOn( conflicts, HW_R6 );
    }
    if( HW_COvlap( regs, HW_R7 ) ) {
        HW_CTurnOn( conflicts, HW_F7 );
        HW_CTurnOn( conflicts, HW_R7 );
    }
    if( HW_COvlap( regs, HW_F12 ) ) {
        HW_CTurnOn( conflicts, HW_R12 );
        HW_CTurnOn( conflicts, HW_F12 );
    }
    if( HW_COvlap( regs, HW_F14 ) ) {
        HW_CTurnOn( conflicts, HW_R14 );
        HW_CTurnOn( conflicts, HW_F14 );
    }
    return( conflicts );
}


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 )
/*********************************************************/
{
    curr = curr;
    class = class;
    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 )
/**************************************/
{
    regs = regs;
    return( FALSE );
}


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 );   // would be different for MIPS64
}


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


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


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


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


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


extern  hw_reg_set Low48Reg( hw_reg_set regs )
/********************************************/
{
    regs = 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 )
/*******************************************/
{
    regs = 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 );       // $zero
    HW_CTurnOn( fixed, HW_R1 );     // $at (needed as scratch register)
    HW_CTurnOn( fixed, HW_R28 );    // $gp
    HW_CTurnOn( fixed, HW_R29 );    // $sp
    // We should be able to use $fp as $s8 in theory, but that isn't working
    // when alloca() is used for some reason (alloca() will force us to use
    // a frame pointer separate from $sp). So just make $fp always fixed.
//    if( CurrProc->targ.base_is_fp )
        HW_CTurnOn( fixed, HW_R30 );// $fp
    HW_CTurnOn( fixed, HW_F30 );    // TODO: Used to generate problematic converts (I8->FD and such)
    return( fixed );
}


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


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


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


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


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


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


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( GeneralRegs );
}


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;

    /*
     * This should be cached in the reg name and used instead of a stupid lookup
     */
    for( i = 0; i < sizeof( GeneralRegs ) / sizeof( GeneralRegs[0] ); i++ ) {
        if( HW_Subset( GeneralRegs[i], reg ) ) return( i );
    }
    for( i = 0; i < sizeof( QWordRegs ) / sizeof( QWordRegs[0] ); i++ ) {
        if( HW_Subset( QWordRegs[i], reg ) ) return( i * 2 + 2 );
    }
    for( i = 0; i < sizeof( FloatRegs ) / sizeof( FloatRegs[0] ); i++ ) {
        if( HW_Equal( reg, FloatRegs[i] ) ) return( i );
    }
    return( 0 );
}


extern  mips_regn MIPSRegN( 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( GeneralRegs ) / sizeof( GeneralRegs[0] ); i++ ) {
        if( HW_Subset( GeneralRegs[i], reg ) ) return( i + MIPS_REGN_r0 );
    }
    for( i = 0; i < sizeof( FloatRegs ) / sizeof( FloatRegs[0] ); i++ ) {
        if( HW_Equal( reg, FloatRegs[i] ) ) return( i + MIPS_REGN_f0 );
    }
    _Zoiks( ZOIKS_031 );
    return( MIPS_REGN_END );
}