source: dev/BasicCompiler64/Compile_CallProc.cpp@ 19

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

//ローカル変数アドレススケジュール
DWORD *pLocalVarAddrSchedule;
int LocalVarAddrScheduleNum;

void Call_DebugSys_SaveContext(){
    //call _System_GetEip
    extern SUBINFO *pSub_System_GetEip;
    op_call(pSub_System_GetEip);

    //mov rdx,rax
    op_mov64_ToReg_FromReg(REG_RDX,REG_RAX);

    //mov rcx,rsp
    op_mov64_ToReg_FromReg(REG_RCX,REG_RSP);

    //call _DebugSys_SaveContext
    extern SUBINFO *pSub_DebugSys_SaveContext;
    op_call(pSub_DebugSys_SaveContext);
}

void AddLocalVarAddrSchedule(){
    extern HANDLE hHeap;

    //ローカル変数アドレススケジュールに追加する
    pLocalVarAddrSchedule=(DWORD *)HeapReAlloc(hHeap,0,pLocalVarAddrSchedule,(LocalVarAddrScheduleNum+1)*sizeof(DWORD));
    pLocalVarAddrSchedule[LocalVarAddrScheduleNum]=obp;
    LocalVarAddrScheduleNum++;
}

int CallProc(int idProc,void *pInfo,char *name,char *Parameter,LONG_PTR *plpRetIndex){
    int ret_type;

    if(idProc==PROC_DEFAULT){
        /////////////////////
        // ユーザー定義関数
        /////////////////////

        SUBINFO *psi;
        psi=(SUBINFO *)pInfo;

        //GetSubHash内でエラー提示が行われた場合
        if(psi==(SUBINFO *)-1) return -1;


        //オブジェクト名を取得
        char ObjectName[VN_SIZE];
        int RefType;
        GetObjectName(name,ObjectName,&RefType);


        ////////////////////////
        // オーバーロードを解決
        ////////////////////////

        SUBINFO **ppsi;
        int num;
        ppsi=GetOverloadSubHash(name,&num);
        if(num){
            //オーバーロードを解決
            psi=OverloadSolutionWithStrParam(name,ppsi,num,Parameter,ObjectName,NULL);
            HeapDefaultFree(ppsi);

            if(!psi) return 0;
        }


        ret_type=Opcode_CallProc(Parameter,psi,plpRetIndex,0,ObjectName,RefType);
    }
    else if(idProc==PROC_DLL){
        /////////////////////////
        // DLL関数
        /////////////////////////
        DECLAREINFO *pdi;
        pdi=(DECLAREINFO *)pInfo;

        ret_type=Opcode_CallDllProc(Parameter,pdi,plpRetIndex);
    }
    else if(idProc==PROC_BUILTIN){
        /////////////////////////
        // 組み込み関数
        /////////////////////////
        int FuncId;
        FuncId=(int)(_int64)pInfo;

        ret_type=Opcode_CallFunc(Parameter,FuncId);
    }
    else if(idProc==PROC_PTR){
        /////////////////
        // 関数ポインタ
        /////////////////

        LONG_PTR lpIndex;
        GetVarType(name,&lpIndex,0);

        extern PROCPTRINFO *pProcPtrInfo;
        ret_type=Opcode_CallProcPtr(name,Parameter,&pProcPtrInfo[lpIndex],plpRetIndex);
    }

    return ret_type;
}

BOOL CallPropertyMethod(char *variable,char *RightSide,TYPEINFO *pRetTypeInfo){
    //プロパティ用のメソッドを呼び出す

    //配列要素を取得
    char VarName[VN_SIZE],ArrayElements[VN_SIZE];
    GetArrayElement(variable,VarName,ArrayElements);

    //オブジェクト名を取得
    char ObjectName[VN_SIZE];
    int RefType;
    GetObjectName(VarName,ObjectName,&RefType);

    //オーバーロード用の関数リストを作成
    SUBINFO **ppsi;
    int num;
    ppsi=GetOverloadSubHash(VarName,&num);
    if(num==0){
        return 0;
    }

    //パラメータを整備
    char *Parameter;
    Parameter=(char *)HeapAlloc(hHeap,0,lstrlen(ArrayElements)+lstrlen(RightSide)+32);
    lstrcpy(Parameter,ArrayElements);
    if(RightSide){
        if(Parameter[0]&&RightSide[0]) lstrcat(Parameter,",");
        lstrcat(Parameter,RightSide);
    }

    //オーバーロードを解決
    SUBINFO *psi;
    psi=OverloadSolutionWithStrParam(VarName,ppsi,num,Parameter,ObjectName,NULL);
    HeapDefaultFree(ppsi);

    if(psi){
        //呼び出し
        int type;
        LONG_PTR lpIndex;
        type=Opcode_CallProc(Parameter,psi,&lpIndex,0,ObjectName,RefType);

        if(pRetTypeInfo){
            pRetTypeInfo->type=type;
            pRetTypeInfo->u.lpIndex=lpIndex;
        }
    }

    HeapDefaultFree(Parameter);

    return 1;
}


int Opcode_CallProcPtr(char *variable,char *Parameter,PROCPTRINFO *pi,LONG_PTR *plpIndex){
    extern HANDLE hHeap;
    int i;


    extern BOOL bDebugCompile;
    extern BOOL bDebugSupportProc;
    if(bDebugCompile&&bDebugSupportProc==0)
        Call_DebugSys_SaveContext();


    ////////////////////////
    // パラメータのセット
    ////////////////////////

    //パラメータオブジェクトを生成
    CParameter *pobj_parameter=0;
    pobj_parameter=new CParameter(Parameter);

    //エラーチェック
    pobj_parameter->ErrorCheck(variable,pi->pParmInfo,pi->ParmNum,pi->ParmNum);

    //スタックフレームに存在する既存のパラメータをバックアップ
    pobj_parameter->BackupParameter(pi->ParmNum);

    //レジスタ、スタックフレームにセット
    pobj_parameter->SetParameter(variable,pi->pParmInfo,pi->ParmNum,pi->ParmNum);



    RELATIVE_VAR RelativeVar;
    LONG_PTR lp;
    GetVarOffsetReadOnly(variable,&i,&RelativeVar,&lp);
    SetVarPtrToReg(REG_RAX,&RelativeVar);

    //mov rax,qword ptr[rax]
    op_mov_RM(sizeof(_int64),REG_RAX,REG_RAX,0,MOD_BASE);

    //call rax
    OpBuffer[obp++]=(char)0xFF;
    OpBuffer[obp++]=(char)0xD0;


    //レジスタのブロッキングを解除        ※パラメータセット時にロックされたレジスタ
    pobj_BlockReg->clear();

    //スタックフレームに存在する既存のパラメータを復元
    pobj_parameter->RestoreParameter(pi->ParmNum);

    //パラメータオブジェクトを破棄
    delete pobj_parameter;

    if(plpIndex) *plpIndex=pi->u.ReturnIndex;

    return pi->ReturnType;
}

int Opcode_CallProc(char *Parameter,SUBINFO *psi,LONG_PTR *plpIndex,DWORD dwFlags,char *ObjectName,int RefType){
    int i,i2;

    if(psi->dwType==SUBTYPE_MACRO){
        if(lstrcmpi(psi->name,"Print")==0){
            Opcode_Print(Parameter,0);
            return -1;
        }
        if(lstrcmpi(psi->name,"Input")==0){
            Opcode_Input(Parameter);
            return -1;
        }
        if(lstrcmpi(psi->name,"Write")==0){
            Opcode_Print(Parameter,1);
            return -1;
        }
    }

    psi->bUse=1;

    BOOL bStatic=0;
    CClass *pobj_c = NULL;
    CMethod *pMethod = NULL;
    if(psi->pobj_ParentClass){
        //クラスのメンバ関数を呼び出す場合はアクセスチェックを行う
        if(ObjectName[0]){
            if(lstrcmpi(ObjectName,"Super")==0){
                //クラスメンバ関数内からスーパークラスの呼び出し
                pobj_c=pobj_CompilingClass;
            }
            else{
                pobj_c=pobj_DBClass->check(ObjectName);
                if(pobj_c){
                    //静的メンバ
                    bStatic=1;
                }
                else{
                    //"->"によってオブジェクトを指定する通常のメンバ関数呼び出し
                    GetVarType(ObjectName,(LONG_PTR *)&pobj_c,1);
                }
            }
        }
        else{
            if(dwFlags&PROCFLAG_NEW){
                //New演算子によるコンストラクタ呼び出し
                pobj_c=psi->pobj_ParentClass;
            }
            else{
                //クラスメンバ関数内から同一クラスのメンバ関数の呼び出し
                pobj_c=pobj_CompilingClass;
            }
        }


        /////////////////////////////////
        // メソッド情報を取得
        /////////////////////////////////
        pMethod = pobj_c->GetMethodInfo( psi );
        if( !pMethod ){
            //動的メソッドが取得できなかったときは静的メソッドを当たる
            pMethod = pobj_c->GetStaticMethodInfo( psi );
            if( !pMethod ){
                SetError(300,NULL,cp);
                return -1;
            }
        }


        //////////////////////////////
        // アクセスエラーチェック
        //////////////////////////////
        DWORD dwAccess = pMethod->dwAccess;

        if(ObjectName[0]){
            //外部からの呼び出し
            if(pobj_c==pobj_CompilingClass){
                //同一クラスオブジェクトの場合はプライベートアクセスを容認する
                if(dwAccess==ACCESS_NON){
                    SetError(109,psi->name,cp);
                    return -1;
                }
            }
            else{
                if(dwAccess==ACCESS_PRIVATE||
                    dwAccess==ACCESS_NON){
                    SetError(109,psi->name,cp);
                    return -1;
                }
                if(dwAccess==ACCESS_PROTECTED){
                    SetError(110,psi->name,cp);
                    return -1;
                }
            }
        }
        else{
            //クラス内部からの呼び出し（継承によるACCESS_NONのみをエラーとする）
            if(dwAccess==ACCESS_NON){
                SetError(109,psi->name,cp);
                return -1;
            }
        }
    }


    ///////////////////////////////////////////////////////////////
    // _System_LocalThis、_System_ReturnObjectのダミーをセット
    ///////////////////////////////////////////////////////////////

    char temporary[VN_SIZE]={0};
    if(psi->pobj_ParentClass&&bStatic==0){
        //_System_LocalThis（第一パラメータ）のダミーを作成
        lstrcpy(temporary,"0,");
    }

    if(psi->ReturnType==DEF_OBJECT){
        //_System_ReturnObject（第一または第二パラメータのダミーを作成）
        sprintf(temporary+lstrlen(temporary),"%c%c0,",1,ESC_BYVAL);
    }

    if(Parameter[0]=='\0'&&temporary[0])
        temporary[lstrlen(temporary)-1]=0;
    else lstrcat(temporary,Parameter);


    ////////////////////////
    // パラメータをセット
    ////////////////////////

    //パラメータオブジェクトを生成
    CParameter *pobj_parameter=0;
    pobj_parameter=new CParameter(temporary);

    //エラーチェック
    pobj_parameter->ErrorCheck(psi->name,psi->pRealParmInfo,psi->RealParmNum,psi->SecondParmNum);

    if(psi->dwType==SUBTYPE_MACRO){
        //マクロ関数の場合は、パラメータ省略を考慮する
        pobj_parameter->MacroParameterSupport(psi->pRealParmInfo);
    }

    //スタックフレームに存在する既存のパラメータをバックアップ
    pobj_parameter->BackupParameter(psi->RealParmNum);

    //レジスタ、スタックフレームにセット
    pobj_parameter->SetParameter(psi->name,psi->pRealParmInfo,psi->RealParmNum,psi->RealSecondParmNum);


    if(psi->ReturnType==DEF_OBJECT){
        //////////////////////////////////////////////////////
        // 戻り値にオブジェクト インスタンスを持つ場合
        // ※ByRef _System_ReturnObject パラメータをセット
        //////////////////////////////////////////////////////


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

            int object_size;
            object_size=GetSizeOfClass(psi->u.Return_pobj_c);

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

            //call calloc
            extern SUBINFO *pSub_calloc;
            op_call(pSub_calloc);

            //mov r13,rax
            op_mov_RR(REG_R13,REG_RAX);

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

        if(psi->pobj_ParentClass&&bStatic==0){
            //mov rdx,r13
            op_mov_RR(REG_RDX,REG_R13);
        }
        else{
            //mov rcx,r13
            op_mov_RR(REG_RCX,REG_R13);
        }
    }


    if(psi->pobj_ParentClass&&bStatic==0){
        ///////////////////////////////
        // メンバ関数の場合
        // thisポインタをrcxで受け渡す
        ///////////////////////////////

        if(ObjectName[0]){
            if(lstrcmpi(ObjectName,"Super")==0) goto InClassMember;
            else{
                RELATIVE_VAR RelativeVar;
                if( pMethod->isConst ){
                    //Constアクセスが可能なメソッドの場合
                    if( !GetVarOffsetReadOnly( ObjectName, &i2, &RelativeVar, 0 ) ) return -1;
                }
                else{
                    //Constアクセスが不可能なメソッドの場合
                    if( !GetVarOffsetReadWrite( ObjectName, &i2, &RelativeVar, 0 ) ) return -1;
                }

                SetVarPtrToReg(REG_RCX,&RelativeVar);

                //参照タイプが整合しているかをチェック
                if(i2!=RefType) SetError(104,ObjectName,cp);

                if(i2==DEF_PTR_OBJECT){
                    //mov rcx,qword ptr[rcx]
                    op_mov_RM(sizeof(_int64),REG_RCX,REG_RCX,0,MOD_BASE);
                }
            }
        }
        else{
InClassMember:
            if(dwFlags&PROCFLAG_NEW){
                //New演算子によるコンストラクタ呼び出しの場合

                //mov rcx,qword ptr[rsp+offset]     ※スタックフレームを利用
                pobj_sf->ref(REG_RCX);
            }
            else{
                //自身のオブジェクトのThisポインタをrcxにコピー
                SetThisPtrToReg(REG_RCX);
            }
        }
    }

    if(psi->bVirtual){
        //仮想関数（オブジェクトメソッド）呼び出し
        //pObj->func_table->func1
        //                ->func2
        //                ->func3

        //mov r11,qword ptr[rcx]
        op_mov_RM(sizeof(_int64),REG_R11,REG_RCX,0,MOD_BASE);

        for(i=0,i2=0;i<pobj_c->iMethodNum;i++){
            if(pobj_c->ppobj_Method[i]->psi==psi) break;
            if(pobj_c->ppobj_Method[i]->psi->bVirtual) i2++;
        }

        //call qword ptr[r11+func_index]
        if(i2*PTR_SIZE<=0x7F){
            OpBuffer[obp++]=(char)0x41;
            OpBuffer[obp++]=(char)0xFF;
            OpBuffer[obp++]=(char)0x53;
            OpBuffer[obp++]=(char)(i2*PTR_SIZE);
        }
        else{
            OpBuffer[obp++]=(char)0x41;
            OpBuffer[obp++]=(char)0xFF;
            OpBuffer[obp++]=(char)0x93;
            *((long *)(OpBuffer+obp))=i2*PTR_SIZE;
            obp+=sizeof(long);
        }
    }
    else{
        //通常呼び出し

        //call ProcAddr
        op_call(psi);
    }

    /* 64コンパイラでは不要
    if(pdi->bCdecl){
        //add esp,ParmSize
    }*/


    //レジスタのブロッキングを解除        ※パラメータセット時にロックされたレジスタ
    pobj_BlockReg->clear();

    //スタックフレームに存在する既存のパラメータを復元
    pobj_parameter->RestoreParameter(psi->RealParmNum);

    //パラメータオブジェクトを破棄
    delete pobj_parameter;

    if(plpIndex) *plpIndex=psi->u.ReturnIndex;

    return psi->ReturnType;
}

int Opcode_CallDllProc(char *Parameter,DECLAREINFO *pdi,LONG_PTR *plpIndex){
    char *temporary;

    temporary=(char *)HeapAlloc(hHeap,0,lstrlen(Parameter)+1);

    extern BOOL bDebugCompile;
    extern BOOL bDebugSupportProc;
    if(bDebugCompile&&bDebugSupportProc==0&&lstrcmp(pdi->name,"DebugBreak")!=0)
        Call_DebugSys_SaveContext();



    ////////////////////////
    // パラメータのセット
    ////////////////////////

    //パラメータオブジェクトを生成
    CParameter *pobj_parameter=0;
    pobj_parameter=new CParameter(Parameter);

    //エラーチェック
    pobj_parameter->ErrorCheck(pdi->name,pdi->pParmInfo,pdi->ParmNum,pdi->ParmNum);

    //スタックフレームに存在する既存のパラメータをバックアップ
    pobj_parameter->BackupParameter(pdi->ParmNum);

    //レジスタ、スタックフレームにセット
    pobj_parameter->SetParameter(pdi->name,pdi->pParmInfo,pdi->ParmNum,pdi->ParmNum);


    //レジスタのブロッキングを解除        ※パラメータセット時にロックされたレジスタ
    pobj_BlockReg->clear();


    //動的リンクされたプロシージャの呼び出し

    //call dword ptr[ImportTable]
    op_call( pdi );

    /* 64コンパイラでは不要
    if(pdi->bCdecl){
        //add esp,ParmSize
    }*/

    //スタックフレームに存在する既存のパラメータを復元
    pobj_parameter->RestoreParameter(pdi->ParmNum);

    //パラメータオブジェクトを破棄
    delete pobj_parameter;

    if(plpIndex) *plpIndex=pdi->u.ReturnIndex;

    HeapDefaultFree(temporary);

    return pdi->ReturnType;
}