source: dev/trunk/abdev/BasicCompiler64/OperatorProc.cpp@ 316

#include "stdafx.h"

#include <jenga/include/smoothie/LexicalAnalysis.h>

#include <Compiler.h>

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

void FreeTempObject(int reg,const CClass *pobj_c){
    if(!IsSafeReg(reg)) SetError(300,NULL,cp);

    ////////////////////////////////////////////////
    // 演算過程で利用した一時オブジェクトを破棄
    // Thisポインタをr14レジスタを介して渡す
    ////////////////////////////////////////////////

    const CMethod *method = pobj_c->GetDestructorMethod();
    if( method ){
        //mov rcx,reg
        compiler.codeGenerator.op_mov_RR(REG_RCX,reg);

        //call DestructorProcAddr
        compiler.codeGenerator.op_call( &method->GetUserProc() );
    }

    //mov rcx,reg
    compiler.codeGenerator.op_mov_RR(REG_RCX,reg);

    //call free
    extern const UserProc *pSub_free;
    compiler.codeGenerator.op_call(pSub_free);
}

int CallOperatorProc(BYTE idCalc, const Type &baseType, int *type_stack,LONG_PTR *index_stack,BOOL *bUseHeap,int &sp){
    //オーバーロードされたオペレータ関数を呼び出す
    CClass *pobj_c;
    pobj_c=(CClass *)index_stack[sp-2];

    std::vector<const UserProc *> subs;
    pobj_c->GetMethods().Enum( idCalc, subs );
    if( subs.size() == 0 ){
        return 0;
    }


    //項の数
    BOOL bTwoTerm=1;
    if(idCalc==CALC_AS) bTwoTerm=0;


    /////////////////////////////////////////////
    // オーバーロード解決用のパラメータを設定
    /////////////////////////////////////////////

    Parameters params;

    if(bTwoTerm){
        params.push_back( new Parameter( "", Type( type_stack[sp-1], index_stack[sp-1] ) ) );
    }

    //オーバーロードを解決
    char temporary[255];
    if(idCalc==CALC_EQUAL) lstrcpy(temporary,"==");
    else GetCalcName(idCalc,temporary);
    const UserProc *pUserProc = OverloadSolution( temporary, subs, params, baseType );

    if(!pUserProc){
        if(bTwoTerm){
            delete params[0];
        }
        return -1;
    }
    else{
        //オーバーロードされていないが、パラメータ個数が一致しないとき
        if(params.size()!=pUserProc->Params().size()){
            if(bTwoTerm){
                delete params[0];
            }
            return -1;
        }
    }

    for(int i=0;i<(int)params.size();i++){
        CheckDifferentType(
            *pUserProc->Params()[i],
            *params[i],
            "",
            i);
    }

    if(bTwoTerm){
        delete params[0];
    }

    int right_side_size = Type(type_stack[sp-1],index_stack[sp-1]).GetSize();

    if(bTwoTerm){
        if( pUserProc->RealParams()[1]->IsStruct() &&pUserProc->RealParams()[1]->IsRef() == false ){
            //一時オブジェクトはメソッド内で破棄される
            bUseHeap[sp-1]=0;
        }
    }


    if( pUserProc->ReturnType().IsStruct() ){
        //////////////////////////////////////////////////////
        // 戻り値に構造体インスタンスを持つ場合
        // ※ByRef _System_ReturnValue パラメータ用領域を取得
        //////////////////////////////////////////////////////


        //////////////////////////////////////////////////////
        /////    レジスタ資源のバックアップ
        {   BACKUP_REGISTER_RESOURCE
        //////////////////////////////////////////////////////

            int object_size = pUserProc->ReturnType().GetClass().GetSize();

            //mov rcx,object_size
            compiler.codeGenerator.op_mov_RV(sizeof(_int64),REG_RCX,object_size);

            //call calloc
            extern const UserProc *pSub_calloc;
            compiler.codeGenerator.op_call(pSub_calloc);

            //mov r13,rax
            compiler.codeGenerator.op_mov_RR(REG_R13,REG_RAX);

        /////////////////////////////////////////////
        //////   レジスタ資源を復元
            RESTORE_REGISTER_RESOURCE
        }////////////////////////////////////////////
    }

    int reg1,reg2;
    if(bTwoTerm){
        //右の項（実数の場合が未完成）
        SetOneTermToReg_Whole64Calc(type_stack[sp-1],&reg2);
        pobj_reg->UnlockReg();
        if( !pUserProc->RealParams()[1]->IsRef() == false ){
            //一時参照を作成
            pobj_sf->push( reg2 );
            pobj_sf->mov_sp( reg2 );
        }
    }

    //左の項
    SetOneTermToReg_Whole64Calc(DEF_INT64,&reg1);
    pobj_reg->UnlockReg();

    //ヒープ解放用に退避
    if(bUseHeap[sp-1]){
        //mov qword ptr[rsp+offset],reg2     ※スタックフレームを利用
        pobj_sf->push(reg2);
    }
    if(bUseHeap[sp-2]){
        //mov qword ptr[rsp+offset],reg1     ※スタックフレームを利用
        pobj_sf->push(reg1);
    }



    //////////////////////////////////////////////////////
    /////    レジスタ資源のバックアップ
    {   BACKUP_REGISTER_RESOURCE
    //////////////////////////////////////////////////////

        if(reg1==REG_RDX||reg1==REG_R8){
            //mov r14,reg1
            compiler.codeGenerator.op_mov_RR(REG_R14,reg1);
            reg1=REG_R14;
        }


        if(bTwoTerm){
            if( pUserProc->ReturnType().IsStruct() ){
                //mov r8,reg2
                compiler.codeGenerator.op_mov_RR(REG_R8,reg2);
            }
            else{
                //mov rdx,reg2
                compiler.codeGenerator.op_mov_RR(REG_RDX,reg2);
            }
        }

        if( pUserProc->ReturnType().IsStruct() ){
            //mov rdx,r13
            compiler.codeGenerator.op_mov_RR(REG_RDX,REG_R13);
        }

        //mov rcx,reg1
        compiler.codeGenerator.op_mov_RR(REG_RCX,reg1);

        //call operator_proc
        compiler.codeGenerator.op_call(pUserProc);

        if( !pUserProc->ReturnType().IsNull() ){
            //戻り値を一時的に退避

            //mov r13,rax
            compiler.codeGenerator.op_mov_RR(REG_R13,REG_RAX);
        }


    /////////////////////////////////////////////
    //////   レジスタ資源を復元
        RESTORE_REGISTER_RESOURCE
    }////////////////////////////////////////////



    if(bUseHeap[sp-2]||bUseHeap[sp-1]){

        //////////////////////////////////////////////////////
        /////    レジスタ資源のバックアップ
        {   BACKUP_REGISTER_RESOURCE
        //////////////////////////////////////////////////////

            if(bUseHeap[sp-2]){
                //mov r14,qword ptr[rsp+offset]     ※スタックフレームを利用
                pobj_sf->pop(REG_R14);

                FreeTempObject(REG_R14,(CClass *)index_stack[sp-2]);
            }
            if(bUseHeap[sp-1]){
                //mov r14,qword ptr[rsp+offset]     ※スタックフレームを利用
                pobj_sf->pop(REG_R14);

                FreeTempObject(REG_R14,(CClass *)index_stack[sp-1]);
            }

        /////////////////////////////////////////////
        //////   レジスタ資源を復元
            RESTORE_REGISTER_RESOURCE
        }////////////////////////////////////////////
    }

    if(bTwoTerm){
        if( !pUserProc->RealParams()[1]->IsRef() == false ){
            //一時参照を破棄
            pobj_sf->pop();
        }
    }

    if( !pUserProc->ReturnType().IsNull() ){
        //戻り値をreg1にセット
        reg1=pobj_reg->LockReg();

        //mov reg1,r13
        compiler.codeGenerator.op_mov_RR(reg1,REG_R13);
    }

    sp--;
    type_stack[sp-1]=pUserProc->ReturnType().GetBasicType();
    index_stack[sp-1]=pUserProc->ReturnType().GetIndex();

    if( pUserProc->ReturnType().IsStruct() ){
        //構造体が戻ったときはヒープ領域にインスタンスが格納されている
        //※後にfreeする必要あり
        bUseHeap[sp-1]=1;
    }
    else bUseHeap[sp-1]=0;

    return 1;
}

void CallCastOperatorProc(int reg,Type &calcType,BOOL bCalcUseHeap,const Type &toType){
    int type_stack[10];
    LONG_PTR index_stack[10];
    BOOL array_bUseHeap[10];
    int sp=2;
    int iRet;


    //////////////////////////////////////////////////////
    /////    レジスタ資源のバックアップ
    {   BACKUP_REGISTER_RESOURCE
    //////////////////////////////////////////////////////

        //regを第一項目としてロック
        pobj_reg=new CRegister(reg);
        pobj_reg->LockReg();

        if(bCalcUseHeap){
            //未解放のインスタンスが存在する旨を示す警告
            SetError(-105,NULL,cp);
        }

        //左辺
        type_stack[0]=calcType.GetBasicType();
        index_stack[0]=calcType.GetIndex();
        array_bUseHeap[0]=0;
        type_stack[1]=toType.GetBasicType();
        index_stack[1]=toType.GetIndex();
        array_bUseHeap[1]=0;

        iRet=CallOperatorProc(CALC_AS,toType,type_stack,index_stack,array_bUseHeap,sp);

        pobj_reg->UnlockReg();

    /////////////////////////////////////////////
    //////   レジスタ資源を復元
        RESTORE_REGISTER_RESOURCE
    }////////////////////////////////////////////


    if(iRet==1){
        //成功したとき
        calcType.SetType( type_stack[0], index_stack[0] );
        return;
    }
    else if(iRet==-1){
        //エラーが発行されたとき
        return;
    }

    //エラーを発行
    SetError(-1,"キャスト演算子がオーバーロードされていません。",cp);
}

//インデクサ（getter）を呼び出す
void CallIndexerGetterProc(int reg, const Type &classType, char *ObjectName,char *Parameter,Type &resultType ){

    std::vector<const UserProc *> subs;
    classType.GetClass().GetMethods().Enum( CALC_ARRAY_GET, subs );
    if( subs.size() == 0 ){
        return;
    }

    const UserProc *pUserProc = subs[0];

    //////////////////////////////////////////////////////
    /////    レジスタ資源のバックアップ
    {   BACKUP_REGISTER_RESOURCE
    //////////////////////////////////////////////////////

        Opcode_CallProc(Parameter,pUserProc,0,ObjectName);
        resultType = pUserProc->ReturnType();

        //mov reg,rax
        compiler.codeGenerator.op_mov_RR(reg,REG_RAX);

    /////////////////////////////////////////////
    //////   レジスタ資源を復元
        RESTORE_REGISTER_RESOURCE
    }////////////////////////////////////////////


    // 型パラメータを解決
    ResolveFormalGenericTypeParameter( resultType, classType, pUserProc );
}