source: dev/BasicCompiler64/Register.cpp@ 3

#include "../BasicCompiler_Common/common.h"
#include "Opcode.h"


//エラー用
extern int cp;


////////////////////////////
// レジスタのブロッキング
////////////////////////////

CBlockReg *pobj_BlockReg;

CBlockReg::CBlockReg(){
    num=0;
}
void CBlockReg::lock(int reg){
    if(check(reg)){
        SetError(300,NULL,cp);
    }
    array_BlockReg[num++]=reg;
}
void CBlockReg::unlock(int reg){
    int i;
    for(i=0;i<num;i++){
        if(array_BlockReg[i]==reg) break;
    }
    if(i==num) return;

    num--;
    for(;i<num;i++){
        array_BlockReg[i]=array_BlockReg[i+1];
    }
}
BOOL CBlockReg::check(int reg){
    int i;
    for(i=0;i<num;i++){
        if(array_BlockReg[i]==reg) return 1;
    }
    return 0;
}
void CBlockReg::clear(void){
    num=0;
}
void CBlockReg::backup(){
    int i;

    for(i=num-1;i>=0;i--){
        if(IS_XMM_REG(array_BlockReg[i])){
            //movlpd qword ptr[rsp+offset],xmm_reg  ※スタックフレームを利用
            pobj_sf->push(array_BlockReg[i],sizeof(double));
        }
        else{
            //mov qword ptr[rsp+offset],reg     ※スタックフレームを利用
            pobj_sf->push(array_BlockReg[i]);
        }
    }
}
void CBlockReg::restore(){
    int i;

    for(i=0;i<num;i++){
        if(IS_XMM_REG(array_BlockReg[i])){
            //movlpd xmm_reg,qword ptr[rsp+offset]  ※スタックフレームを利用
            pobj_sf->pop(array_BlockReg[i],sizeof(double));
        }
        else{
            //mov reg,qword ptr[rsp+offset]     ※スタックフレームを利用
            pobj_sf->pop(array_BlockReg[i]);
        }
    }
}


///////////////////
// レジスタ管理
///////////////////

const int CalculationRegister[]={
    REG_RAX,
    REG_RCX,
    REG_RDX,
    REG_RBX,
    REG_RSI,
    REG_RDI,
    REG_R8,
    REG_R9,
    REG_R10
};

const int CalculationXmmRegister[]={
    REG_XMM0,
    REG_XMM1,
    REG_XMM2,
    REG_XMM3,
    /*XMM4、XMM5は演算時に一時的に利用*/
/*  REG_XMM6,
    REG_XMM7,
    REG_XMM8,
    REG_XMM9,
    REG_XMM10,
    REG_XMM11,
    REG_XMM12,
    REG_XMM13,
    REG_XMM14,
    REG_XMM15       関数呼び出し時のレジスタ保持を未搭載のため、保留*/
};

CRegister *pobj_reg;

void CRegister::EnumRegister(int *pRegList,int nMaxList,int *array_reg,int *sp,int AnswerReg){
    int i,i2,sw=0;

    i2=nMaxList-1;
    for(i=0;i2>=0;i++,i2--){
        if(AnswerReg==pRegList[i2]){
            sw=1;
            i--;
            continue;
        }

        if(pobj_BlockReg->check(pRegList[i2])){
            //レジスタがブロッキングされているとき
            i--;
            continue;
        }

        array_reg[i]=pRegList[i2];
    }

    if(sw){
        array_reg[i++]=AnswerReg;

        //エラーチェック
        if(pobj_BlockReg->check(AnswerReg)) SetError(300,NULL,cp);
    }

    *sp=i-1;
}

CRegister::CRegister(int AnswerReg){
    /* 例： AnswerReg=REG_RCX ※REG_RCXをスタックの最後尾へセット
                                ※r15、r14は一時保存用として利用する
                                ※r13は同一関数内の単発処理用の一時保存レジスタとして利用する
                                ※r12、r11は配列計算用として利用する
    array_UseReg[0]=REG_R10
    array_UseReg[1]=REG_R9
    array_UseReg[2]=REG_R8
    array_UseReg[3]=REG_RBX
    array_UseReg[4]=REG_RDX
    array_UseReg[5]=REG_RAX
    array_UseReg[6]=REG_RCX */


    ///////////////////////////////////////////////////////////
    //array_UseRegに、計算に利用するレジスタリストを作成
    ///////////////////////////////////////////////////////////

    EnumRegister(
        (int *)CalculationRegister,
        sizeof(CalculationRegister)/sizeof(int),
        array_UseReg,
        &sp_UseReg,
        AnswerReg);



    ///////////////////////////////////////////////////////////
    //array_XmmRegに、計算に利用するレジスタリストを作成
    ///////////////////////////////////////////////////////////

    EnumRegister(
        (int *)CalculationXmmRegister,
        sizeof(CalculationXmmRegister)/sizeof(int),
        array_XmmReg,
        &sp_XmmReg,
        AnswerReg);


    init_sp_reg=sp_UseReg;
    init_sp_xmm_reg=sp_XmmReg;
}
void CRegister::bug_check(){
    if(init_sp_reg!=sp_UseReg||
        init_sp_xmm_reg!=sp_XmmReg) SetError(300,NULL,cp);
}
int CRegister::GetNextReg(){
    if(sp_UseReg<0) return REG_R14;
    return array_UseReg[sp_UseReg];
}
int CRegister::GetLockingReg(){
    UnlockReg();
    return LockReg();
}
int CRegister::LockReg(){
    int reg;
    reg=GetNextReg();

    sp_UseReg--;

    return reg;
}
int CRegister::UnlockReg(){
    sp_UseReg++;
    return GetNextReg();
}
int CRegister::GetNextXmmReg(){
    if(sp_XmmReg<0) return REG_XMM4;
    return array_XmmReg[sp_XmmReg];
}
int CRegister::GetLockingXmmReg(){
    UnlockXmmReg();
    return LockXmmReg();
}
int CRegister::LockXmmReg(){
    int xmm_reg;
    xmm_reg=GetNextXmmReg();

    sp_XmmReg--;

    return xmm_reg;
}
int CRegister::UnlockXmmReg(){
    sp_XmmReg++;
    return GetNextXmmReg();
}
void CRegister::backup(){
    int i;

    //汎用レジスタを退避
    for(i=init_sp_reg;i>sp_UseReg;i--){
        //mov qword ptr[rsp+offset],reg     ※スタックフレームを利用
        pobj_sf->push(array_UseReg[i]);
    }

    //XMMレジスタを退避
    for(i=init_sp_xmm_reg;i>sp_XmmReg;i--){
        //mov qword ptr[rsp+offset],reg     ※スタックフレームを利用
        pobj_sf->push(array_XmmReg[i],sizeof(_int64));
    }
}
void CRegister::restore(){
    int i;

    //XMMレジスタを復元
    if(sp_XmmReg<0) i=0;
    else i=sp_XmmReg+1;
    for(;i<=init_sp_xmm_reg;i++){
        //mov reg,qword ptr[rsp+offset]     ※スタックフレームを利用
        pobj_sf->pop(array_XmmReg[i],sizeof(_int64));
    }

    //汎用レジスタを復元
    if(sp_UseReg<0) i=0;
    else i=sp_UseReg+1;
    for(;i<=init_sp_reg;i++){
        //mov reg,qword ptr[rsp+offset]     ※スタックフレームを利用
        pobj_sf->pop(array_UseReg[i]);
    }
}



////////////////////////
// その他
////////////////////////

BOOL IsGeneralReg(int reg){
    if(REG_RAX<=reg&&reg<=REG_R15) return 1;
    return 0;
}
BOOL IsXmmReg(int reg){
    if(REG_XMM0<=reg&&reg<=REG_XMM15) return 1;
    return 0;
}
BOOL IsVolatileReg(int reg){
    if(reg==REG_RAX||
        reg==REG_RCX||
        reg==REG_RDX||
        REG_R8<=reg&&reg<=REG_R11||
        REG_XMM0<=reg&&reg<=REG_XMM5){
        //値を保持する必要なし
        return 1;
    }
    else{
        //値を保持する必要あり
        return 0;
    }
}