source: dev/BasicCompiler64/Compile_Object.cpp@ 31

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

void CallConstructor(CClass *pobj_c,char *CreateParameter,int ObjectSize,BOOL bSomeObjects){
    ////////////////////////////
    // コンストラクタの呼び出し
    ////////////////////////////
    
    //この関数を使用する場合は、
    //・ebxにオブジェクトの個数（複数個の場合のみ）
    //・スタックフレームの先頭参照位置に先頭Thisポインタ
    //をセットしておかなければならない

    int jnz_back;


    //jnzの番地
    jnz_back=obp;

    if(bSomeObjects){
        //mov qword ptr[rsp+offset],rbx     ※スタックフレームを利用
        pobj_sf->push(REG_RBX);

        // ※ここでプッシュされた値はコンストラクタのthisポインタとなる
        //mov qword ptr[rsp+offset],rax     ※スタックフレームを利用
        pobj_sf->push(REG_RAX);
    }


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

    SUBINFO **ppsi;
    SUBINFO *psi;
    int num;
    ppsi=GetOverloadObjectSubHash(pobj_c->name,pobj_c,&num);
    if(num){
        //オーバーロードを解決
        psi=OverloadSolutionWithStrParam(pobj_c->name,
            ppsi,num,CreateParameter,"",NULL);
        HeapDefaultFree(ppsi);

        if(!psi) return;
    }

    //コンストラクタを呼び出す
    Opcode_CallProc(CreateParameter,
        psi,
        PROCFLAG_NEW,"",0);

    if(bSomeObjects){
        //mov rax,qword ptr[rsp+offset]     ※スタックフレームを利用
        pobj_sf->pop(REG_RAX);

        //mov rbx,qword ptr[rsp+offset]     ※スタックフレームを利用
        pobj_sf->pop(REG_RBX);

        //add eax,TypeSize
        OpBuffer[obp++]=(char)0x05;
        *((long *)(OpBuffer+obp))=ObjectSize;
        obp+=sizeof(long);

        //sub ebx,1
        OpBuffer[obp++]=(char)0x83;
        OpBuffer[obp++]=(char)0xEB;
        OpBuffer[obp++]=(char)0x01;

        //jnz ↑
        OpBuffer[obp++]=(char)0x0F;
        OpBuffer[obp++]=(char)0x85;
        *((long *)(OpBuffer+obp))=jnz_back-(obp+sizeof(long));
        obp+=sizeof(long);
    }
}
int Operator_New(const char *Parameter,LONG_PTR *plpIndex){
    char TypeName[VN_SIZE],CreateParameter[VN_SIZE],ObjectSize[VN_SIZE];
    int i,i2;
    int reg;

    i=0;

    if(Parameter[0]=='['){
        i=GetStringInBracket(ObjectSize,Parameter);

        SlideString(ObjectSize+1,-1);
        ObjectSize[i-2]=0;
    }
    else ObjectSize[0]=0;

    for(i2=0;;i++,i2++){
        if(Parameter[i]=='('){
            TypeName[i2]=0;

            //コンストラクタに渡すパラメータを取得
            i2=GetStringInPare(CreateParameter,Parameter+i);
            RemoveStringPare(CreateParameter);
            i+=i2;
            if(Parameter[i]!='\0'){
                SetError(42,NULL,cp);
                return 0;
            }
            break;
        }
        TypeName[i2]=Parameter[i];
        if(Parameter[i]=='\0'){
            CreateParameter[0]=0;
            break;
        }
    }

    int type,TypeSize;
    type=GetTypeFixed(TypeName,plpIndex);
    if(type==-1){
        SetError(3,TypeName,cp);
        return 0;
    }
    TypeSize=GetTypeSize(type,*plpIndex);

    if(type!=DEF_OBJECT){
        ////////////////////////
        // 通常のデータ型の場合
        ////////////////////////

        SetError(121,NULL,cp);
        return 0;
    }

    CClass *pobj_c;
    pobj_c=(CClass *)*plpIndex;

    if(pobj_c->IsAbstract()){
        //抽象クラスだったとき
        SetError(125,pobj_c->name,cp);
    }

    BOOL bSomeObjects=0;
    if(ObjectSize[0]){
        bSomeObjects=1;

        reg=REG_RAX;
        i2=NumOpe(&reg,ObjectSize,0,0,0);
        if(!IsWholeNumberType(i2)) SetError(49,NULL,cp);

        //※添え字上限値であることを考慮
        //add rax,1
        op_add64_value(REG_RAX,1);

        //オブジェクトの個数をrbxに一時保持
        //※rbxは関数が呼ばれても不変
        //mov rbx,rax
        op_mov64_ToReg_FromReg(REG_RBX,REG_RAX);

        //imul rax,size
        op_imul_value(sizeof(_int64),REG_RAX,TypeSize);

        //add rax,PTR_SIZE*3
        op_add64_value(REG_RAX,PTR_SIZE*3);

        //mov rcx,rax
        op_mov64_ToReg_FromReg(REG_RCX,REG_RAX);
    }
    else{
        //オブジェクトの個数をrbxに一時保持
        //※rbxは関数が呼ばれても不変
        //mov rbx,1
        op_mov_RV(sizeof(_int64),REG_RBX,1);

        //mov rcx,TypeSize+PTR_SIZE*3
        op_mov_RV(sizeof(_int64),REG_RCX,TypeSize+PTR_SIZE*3);
    }

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


    /*
    確保されたヒープ領域のポインタ（callocの戻り値eax）をpPtrとすると、
    pPtr-=sizeof(DWORD)*3
    pPtr[0]=オブジェクトの個数
    pPtr[1]=オブジェクトのサイズ
    pPtr[2]=デストラクタの関数ポインタ
    */


    //mov qword ptr[rax],rbx（オブジェクトの個数）
    op_mov_MR(sizeof(_int64),REG_RBX,REG_RAX,0,MOD_BASE);

    //add rax,PTR_SIZE
    op_add64_value(REG_RAX,PTR_SIZE);


    //mov qword ptr[rax],TypeSize（オブジェクトのサイズ）
    op_mov_MV(sizeof(_int64),REG_RAX,0,NON_OFFSET,TypeSize);

    //add rax,PTR_SIZE
    op_add64_value(REG_RAX,PTR_SIZE);


    i2=pobj_c->DestructorMemberSubIndex;
    if(i2==-1) return 0;

    //mov rcx,DestructorProcAddr
    op_mov_RV(sizeof(_int64),REG_RCX,0);
    obp-=sizeof(long);
    pobj_SubAddrSchedule->add(pobj_c->ppobj_Method[i2]->psi,0);
    pobj_c->ppobj_Method[i2]->psi->bUse=1;
    obp+=sizeof(long);

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

    //add rax,PTR_SIZE
    op_add64_value(REG_RAX,PTR_SIZE);


    // ※ここでプッシュされた値はNew演算子の戻り値となる
    //mov qword ptr[rsp+offset],rax     ※スタックフレームを利用
    pobj_sf->push(REG_RAX);


    /////////////////////////////////////////////////////////////////////

    ////////////////////////////
    // コンストラクタの呼び出し
    ////////////////////////////

    CallConstructor(pobj_c,CreateParameter,TypeSize,bSomeObjects);


    //mov rax,qword ptr[rsp+offset]     ※スタックフレームを利用
    pobj_sf->pop(REG_RAX);

    return DEF_PTR_OBJECT;
}

void OpcodeDelete(const char *Parameter){
    int type;

    int reg=REG_RAX;
    type=NumOpe(&reg,Parameter,0,0,0);
    if(type==-1) return;
    if(!(type==DEF_PTR_OBJECT||type==DEF_PTR_VOID)) SetError(122,NULL,cp);

    //sub rax,PTR_SIZE*3
    op_sub_RV(sizeof(_int64),REG_RAX,PTR_SIZE*3);

    //mov qword ptr[rsp+offset],rax     ※スタックフレームを利用
    pobj_sf->push(REG_RAX);


    //mov rbx,qword ptr[rax]（オブジェクトの個数）
    op_mov_RM(sizeof(_int64),REG_RBX,REG_RAX,0,MOD_BASE);

    //add rax,PTR_SIZE
    op_add64_value(REG_RAX,PTR_SIZE);


    //mov rsi,qword ptr[rax]（オブジェクトのサイズ）
    op_mov_RM(sizeof(_int64),REG_RSI,REG_RAX,0,MOD_BASE);

    //add rax,PTR_SIZE
    op_add64_value(REG_RAX,PTR_SIZE);


    //mov rdi,qword ptr[rax]（デストラクタの関数ポインタ）
    op_mov_RM(sizeof(_int64),REG_RDI,REG_RAX,0,MOD_BASE);

    //add rax,PTR_SIZE
    op_add64_value(REG_RAX,PTR_SIZE);


    //mov rcx,rax
    op_mov64_ToReg_FromReg(REG_RCX,REG_RAX);


    //jnzの番地
    int jnz_back;
    jnz_back=obp;

    //mov qword ptr[rsp+offset],rax     ※スタックフレームを利用
    pobj_sf->push(REG_RAX);

    //call rdi
    OpBuffer[obp++]=(char)0xFF;
    OpBuffer[obp++]=(char)0xD7;

    //mov rcx,qword ptr[rsp+offset]     ※スタックフレームを利用
    pobj_sf->pop(REG_RCX);

    //add rcx,rsi
    op_add64_reg(REG_RCX,REG_RSI);

    //sub rbx,1
    op_sub_RV(sizeof(_int64),REG_RBX,1);

    //jnz ↑
    OpBuffer[obp++]=(char)0x0F;
    OpBuffer[obp++]=(char)0x85;
    *((long *)(OpBuffer+obp))=jnz_back-(obp+sizeof(long));
    obp+=sizeof(long);


    //////////////////////////////////////////
    // オブジェクトメンバ変数用のメモリを解放
    //////////////////////////////////////////

    //mov rcx,qword ptr[rsp+offset]     ※スタックフレームを利用
    pobj_sf->pop(REG_RCX);

    //call free
    extern SUBINFO *pSub_free;
    op_call(pSub_free);
}