i86rgtbl.c

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

/* AX   CX     DX     WD     2B     IX     SG     TI     WS*/
RL_AX, RL_,   RL_,   RL_AX, RL_AX, RL_,   RL_,   RL_,   RL_AX,  /* AX*/
RL_,   RL_CX, RL_,   RL_CX, RL_CX, RL_,   RL_,   RL_,   RL_CX,  /* CX*/
RL_,   RL_,   RL_DX, RL_DX, RL_DX, RL_,   RL_,   RL_,   RL_DX,  /* DX*/
RL_AX, RL_CX, RL_DX, RL_WD, RL_2B, RL_IX, RL_,   RL_TI, RL_WD,  /* WD*/
RL_AX, RL_CX, RL_CX, RL_2B, RL_2B, RL_,   RL_,   RL_,   RL_2B,  /* 2B*/
RL_,   RL_,   RL_,   RL_IX, RL_,   RL_IX, RL_,   RL_TI, RL_IX,  /* IX*/
RL_,   RL_,   RL_,   RL_,   RL_,   RL_,   RL_SG, RL_,   RL_SG,  /* SG*/
RL_,   RL_,   RL_,   RL_TI, RL_,   RL_TI, RL_,   RL_TI, RL_TI,  /* TI*/
RL_AX, RL_CX, RL_DX, RL_WD, RL_2B, RL_IX, RL_SG, RL_TI, RL_WS,  /* WS*/
RL_ };

static  reg_set_index   FourByteInter[] = {
/* DX_AX     ES_BX       CX_BX       LONG_INDEX  DOUBLE      DBL_OR_PTR*/
RL_DX_AX,   RL_,        RL_,        RL_,        RL_DX_AX,   RL_DX_AX,   /*DX_AX*/
RL_,        RL_ES_BX,   RL_,        RL_ES_BX,   RL_,        RL_ES_BX,   /*ES_BX*/
RL_,        RL_,        RL_CX_BX,   RL_,        RL_CX_BX,   RL_CX_BX,   /*CX_BX*/
RL_,        RL_ES_BX,   RL_,      RL_LONG_INDEX,RL_,      RL_LONG_INDEX,/*LINDEX*/
RL_DX_AX,   RL_,        RL_CX_BX,   RL_,        RL_DOUBLE,  RL_DOUBLE,  /*DOUBLE*/
RL_DX_AX,   RL_ES_BX,   RL_CX_BX, RL_LONG_INDEX,RL_DOUBLE,RL_DBL_OR_PTR /*DBLPTR*/
};


static  reg_set_index   EightByteInter[] = {
/*       RL_8*/
        RL_8 }; /* RL_8*/

static  reg_set_index   FloatingInter[] = {
/*       RL_ST0  RL_STI*/
        RL_ST0, RL_,      /*  RL_ST0*/
        RL_,    RL_STI }; /*  RL_STI*/

static  reg_set_index   OtherInter[] = {
        RL_ };

static  reg_set_index   *InterTable[] = {
        OneByteInter,          /* ONE_BYTE*/
        TwoByteInter,          /* TWO_BYTE*/
        FourByteInter,         /* FOUR_BYTE*/
        EightByteInter,        /* EIGHT_BYTE*/
        FloatingInter,         /* FLOATING*/
        OtherInter };          /* others*/

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

    if( _FPULevel( FPU_87 ) ) {
        HW_CAsgn( STParmReg[ Max87Stk ], HW_EMPTY );
    }
}


extern  reg_set_index   RegIntersect( reg_set_index s1, reg_set_index s2 ) {
/**************************************************************************/


    reg_class           *set1;
    reg_class           *set2;
    intersect_class     class;
    reg_set_index       result;

    set1 = & IntersectInfo[ s1 ];
    set2 = & IntersectInfo[ s2 ];
    class = set1->class;
    if( class == set2->class ) {
        result = InterTable[ class ]
                        [  set1->index * Width[ class ] + set2->index  ];
    } else if( s1 == RL_NUMBER_OF_SETS ) {
        result = s2;
    } else if( s2 == RL_NUMBER_OF_SETS ) {
        result = s1;
    } else {
        result = RL_;
    }
    return( result );
}


extern  hw_reg_set        *ParmChoices( type_class_def class ) {
/************************************************************/

    hw_reg_set  *list;

    if( _FPULevel( FPU_87 ) ) {
        list = ParmSets8087[  class  ];
    } else {
        list = ParmSets[  class  ];
    }
    return( list );
}


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

    if( HW_COvlap( regs, HW_FLTS ) ) {
        HW_CAsgn( regs, HW_EMPTY );
        if( HW_COvlap( used, HW_ST4 ) ) {
            /*regs = EMPTY;*/
        } else if( HW_COvlap( used, HW_ST3 ) ) {
            HW_CTurnOn( regs, HW_ST4 );
        } else if( HW_COvlap( used, HW_ST2 ) ) {
            HW_CTurnOn( regs, HW_ST3 );
        } else if( HW_COvlap( used, HW_ST1 ) ) {
            HW_CTurnOn( regs, HW_ST2 );
        } else {
            HW_CTurnOn( regs, HW_ST1 );
        }
    }
    return( regs );
}


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

    return( HW_SI );
}


extern  hw_reg_set      ReturnReg( type_class_def class, bool use_87 ) {
/**********************************************************************/

    hw_reg_set          *list;

    if( _FPULevel( FPU_87 ) && use_87 ) {
        list = RegSets[  Return8087[  class  ]  ];
    } else {
        list = RegSets[  ReturnSets[  class  ]  ];
    }
    return( *list );
}


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

    return( RL_SEG );
}


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

    if( idx == RL_ANYWORD ) {
        idx = RL_WORD;
    }
    return( idx );
}


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

    if( is_temp_index ) {
        curr = RegIntersect( curr, RL_TEMP_INDEX );
    } else {
        curr = RegIntersect( curr, IndexSets[  class  ] );
    }
    return( curr );
}


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


    hw_reg_set  *list;

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


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

    hw_reg_set          *possible;
    type_class_def      class;

    if( HW_COvlap( regs, HW_FLTS ) ) {
        if( HW_CEqual( regs, HW_ST0 ) ) return( FD );
        possible = STIReg;
        while( !HW_CEqual( *possible, HW_EMPTY ) ) {
            if( HW_Equal( regs, *possible ) ) return( FD );
            ++possible;
        }
        return( XX );
    } 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    IndexRegOk( hw_reg_set reg, bool is_temp_index ) {
/****************************************************************/

    hw_reg_set  *list;

    if( RegClass( reg ) != U2 ) {
        list = RegSets[  RL_LONG_INDEX  ];
    } else if( is_temp_index ) {
        list = RegSets[  RL_TEMP_INDEX  ];
    } else {
        list = RegSets[  RL_INDEX  ];
    }
    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 ) {
/*******************************************/

    hw_reg_set  tmp;

    tmp = regs;
    HW_COnlyOn( tmp, HW_SEGS );
    return( HW_Equal( tmp, regs ) );
}


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

    HW_COnlyOn( regs, HW_AL_BL_CL_DL );
    return( regs );
}


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

    HW_COnlyOn( regs, HW_AH_BH_CH_DH );
    return( regs );
}


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

    hw_reg_set  low;
    hw_reg_set  *order;

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


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

    hw_reg_set  high;

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


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

    hw_reg_set  high;

    if( HW_CEqual( regs, HW_ABCD ) ) {
        HW_CAsgn( high, HW_EMPTY );
    } else {
        high = High32Reg( regs );
        if( HW_CEqual( high, HW_EMPTY ) ) {
            high = High16Reg( regs );
            if( HW_Equal( high, regs ) ) {
                HW_CAsgn( high, HW_EMPTY );
            }
        }
    }
    return( high );
}


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

    return( HighReg( regs ) );
}

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

    return( HighReg( regs ) );
}

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

    hw_reg_set  low;

    if( HW_CEqual( regs, HW_ABCD ) ) {
        HW_CAsgn( low, HW_EMPTY );
    } else {
        low = Low32Reg( regs );
        if( HW_CEqual( low, HW_EMPTY ) ) {
            low = Low16Reg( regs );
            if( HW_Equal( low, regs ) ) {
                HW_CAsgn( low, HW_EMPTY );
            }
        }
    }
    return( low );
}

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

    return( LowReg( regs ) );
}

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

    return( LowReg( regs ) );
}

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

    if( HW_COvlap( regs, HW_AX ) ) {
        HW_CTurnOn( regs, HW_AX );
    }
    if( HW_COvlap( regs, HW_BX ) ) {
        HW_CTurnOn( regs, HW_BX );
    }
    if( HW_COvlap( regs, HW_CX ) ) {
        HW_CTurnOn( regs, HW_CX );
    }
    if( HW_COvlap( regs, HW_DX ) ) {
        HW_CTurnOn( regs, HW_DX );
    }
    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 ) ) break;
        ++ list;
    }
    return( !HW_CEqual( *list, HW_EMPTY ) );
}


extern  hw_reg_set      ActualParmReg( hw_reg_set reg ) {
/*******************************************************/

    if( HW_COvlap( reg, HW_FLTS ) ) {
        HW_CAsgn( reg, HW_ST0 );
    }
    return( reg );
}


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

    hw_reg_set  tmp;

    HW_CAsgn( tmp, HW_SP );
    HW_CTurnOn( tmp, HW_BP );
    HW_CTurnOn( tmp, HW_SS );
    HW_CTurnOn( tmp, HW_CS );
    if( _IsntTargetModel( FLOATING_DS ) ) HW_CTurnOn( tmp, HW_DS );
    if( _IsntTargetModel( FLOATING_ES ) ) HW_CTurnOn( tmp, HW_ES );
    if( _IsntTargetModel( FLOATING_FS ) ) HW_CTurnOn( tmp, HW_FS );
    if( _IsntTargetModel( FLOATING_GS ) ) HW_CTurnOn( tmp, HW_GS );
    return( tmp );
}


extern  bool    IsStackReg( name *sp ) {
/**************************************/

    if( sp == NULL ) return( FALSE );
    if( sp->n.class != N_REGISTER ) return( FALSE );
    if( !HW_CEqual( sp->r.reg, HW_SP ) ) return( FALSE );
    return( TRUE );
}


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

    return( HW_SP );
}


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

    return( HW_BP );
}


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

    return( WORD_SIZE );
}


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

    hw_reg_set  tmp;

    HW_CAsgn( tmp, HW_FLTS );
    HW_CTurnOn( tmp, HW_ABCD );
    HW_CTurnOn( tmp, HW_SI );
    HW_CTurnOn( tmp, HW_DI );
    if( _IsTargetModel( FLOATING_DS ) ) HW_CTurnOn( tmp, HW_DS );
    if( _IsTargetModel( FLOATING_ES ) ) HW_CTurnOn( tmp, HW_ES );
    if( _IsTargetModel( FLOATING_FS ) ) HW_CTurnOn( tmp, HW_FS );
    if( _IsTargetModel( FLOATING_GS ) ) HW_CTurnOn( tmp, HW_GS );
    return( tmp );
}

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

    return( IndexRegs );
}