Changeset 64 in dev for BasicCompiler64/Compile_Object.cpp


Ignore:
Timestamp:
Mar 8, 2007, 2:49:34 AM (18 years ago)
Author:
dai_9181
Message:

すべてのオブジェクトを参照型に切り替えた。

File:
1 edited

Legend:

Unmodified
Added
Removed

  • BasicCompiler64/Compile_Object.cpp

    r51 r64  
    22#include "opcode.h"
    33
    4 void _call_constructor(CClass *pobj_c,char *CreateParameter,int ObjectSize,BOOL bSomeObjects){
     4void _call_constructor(CClass *pobj_c,const char *CreateParameter,int ObjectSize,BOOL bSomeObjects){
    55    ////////////////////////////
    66    // コンストラクタの呼び出し
    … …  
    7373    }
    7474}
    75 int Operator_New(const char *Parameter,LONG_PTR *plpIndex){
    76     char TypeName[VN_SIZE],CreateParameter[VN_SIZE],ObjectSize[VN_SIZE];
     75void Operator_New( CClass &classObj, const char *objectSizeStr, const char *parameter, const TYPEINFO &baseTypeInfo ){
     76    int typeSize = classObj.GetSize();
     77
     78    if(classObj.IsAbstract()){
     79        //抽象クラスだったとき
     80        SetError(125,classObj.name,cp);
     81    }
     82
     83    BOOL bSomeObjects=0;
     84    if(objectSizeStr[0]){
     85        bSomeObjects=1;
     86
     87        int reg=REG_RAX;
     88        int type = NumOpe(&reg,objectSizeStr,0,0,0);
     89        if(!IsWholeNumberType(type)) SetError(49,NULL,cp);
     90
     91        //※添え字上限値であることを考慮
     92        //add rax,1
     93        op_add_RV(REG_RAX,1);
     94
     95        //オブジェクトの個数をrbxに一時保持
     96        //※rbxは関数が呼ばれても不変
     97        //mov rbx,rax
     98        op_mov_RR(REG_RBX,REG_RAX);
     99
     100        //imul rax,size
     101        op_imul_RV(sizeof(_int64),REG_RAX,typeSize);
     102
     103        //add rax,PTR_SIZE*3
     104        op_add_RV(REG_RAX,PTR_SIZE*3);
     105
     106        //mov rcx,rax
     107        op_mov_RR(REG_RCX,REG_RAX);
     108    }
     109    else{
     110        //オブジェクトの個数をrbxに一時保持
     111        //※rbxは関数が呼ばれても不変
     112        //mov rbx,1
     113        op_mov_RV(sizeof(_int64),REG_RBX,1);
     114
     115        //mov rcx,typeSize+PTR_SIZE*3
     116        op_mov_RV(sizeof(_int64),REG_RCX,typeSize+PTR_SIZE*3);
     117    }
     118
     119    if( baseTypeInfo.type == DEF_OBJECT ){
     120        //DeleteはGCで処理
     121
     122        //call _System_GC_malloc_ForObject
     123        extern SUBINFO *pSub_System_GC_malloc_ForObject;
     124        op_call(pSub_System_GC_malloc_ForObject);
     125    }
     126    else{
     127        //明示的なDeleteが必要
     128
     129        //call _System_GC_malloc_ForObjectPtr
     130        extern SUBINFO *pSub_System_GC_malloc_ForObjectPtr;
     131        op_call(pSub_System_GC_malloc_ForObjectPtr);
     132    }
     133
     134
     135    /*
     136    確保されたヒープ領域のポインタ（callocの戻り値eax）をpPtrとすると、
     137    pPtr-=sizeof(DWORD)*3
     138    pPtr[0]=オブジェクトの個数
     139    pPtr[1]=オブジェクトのサイズ
     140    pPtr[2]=デストラクタの関数ポインタ
     141    */
     142
     143
     144    //mov qword ptr[rax],rbx（オブジェクトの個数）
     145    op_mov_MR(sizeof(_int64),REG_RBX,REG_RAX,0,MOD_BASE);
     146
     147    //add rax,PTR_SIZE
     148    op_add_RV(REG_RAX,PTR_SIZE);
     149
     150
     151    //mov qword ptr[rax],typeSize（オブジェクトのサイズ）
     152    op_mov_MV(sizeof(_int64),REG_RAX,0,NON_OFFSET,typeSize);
     153
     154    //add rax,PTR_SIZE
     155    op_add_RV(REG_RAX,PTR_SIZE);
     156
     157
     158    CMethod *method = classObj.GetDestructorMethod();
     159    if( method == NULL ) return;
     160
     161    //mov rcx,DestructorProcAddr
     162    op_mov_RV(sizeof(_int64),REG_RCX,0);
     163    obp-=sizeof(long);
     164    pobj_SubAddrSchedule->add(method->psi,0);
     165    method->psi->bUse=1;
     166    obp+=sizeof(long);
     167
     168    //mov qword ptr[rax],rcx
     169    op_mov_MR(sizeof(_int64),REG_RCX,REG_RAX,0,MOD_BASE);
     170
     171    //add rax,PTR_SIZE
     172    op_add_RV(REG_RAX,PTR_SIZE);
     173
     174
     175    // ※ここでプッシュされた値はNew演算子の戻り値となる
     176    //mov qword ptr[rsp+offset],rax     ※スタックフレームを利用
     177    pobj_sf->push(REG_RAX);
     178
     179
     180    /////////////////////////////////////////////////////////////////////
     181
     182    ////////////////////////////
     183    // コンストラクタの呼び出し
     184    ////////////////////////////
     185
     186    _call_constructor(&classObj,parameter,typeSize,bSomeObjects);
     187
     188
     189    //mov rax,qword ptr[rsp+offset]     ※スタックフレームを利用
     190    pobj_sf->pop(REG_RAX);
     191}
     192int Operator_New(const char *Parameter,LONG_PTR *plpIndex,const TYPEINFO &baseTypeInfo ){
     193    char TypeName[VN_SIZE],CreateParameter[VN_SIZE],objectSizeStr[VN_SIZE];
    77194    int i,i2;
    78     int reg;
    79195
    80196    i=0;
    81197
    82198    if(Parameter[0]=='['){
    83         i=GetStringInBracket(ObjectSize,Parameter);
    84 
    85         SlideString(ObjectSize+1,-1);
    86         ObjectSize[i-2]=0;
    87     }
    88     else ObjectSize[0]=0;
     199        i=GetStringInBracket(objectSizeStr,Parameter);
     200
     201        SlideString(objectSizeStr+1,-1);
     202        objectSizeStr[i-2]=0;
     203    }
     204    else objectSizeStr[0]=0;
    89205
    90206    for(i2=0;;i++,i2++){
    … …  
    109225    }
    110226
    111     int type,TypeSize;
     227    int type;
    112228    type=GetTypeFixed(TypeName,plpIndex);
    113229    if(type==-1){
    … …  
    115231        return 0;
    116232    }
    117     TypeSize=GetTypeSize(type,*plpIndex);
    118233
    119234    if(type!=DEF_OBJECT){
    … …  
    129244    pobj_c=(CClass *)*plpIndex;
    130245
    131     if(pobj_c->IsAbstract()){
    132         //抽象クラスだったとき
    133         SetError(125,pobj_c->name,cp);
    134     }
    135 
    136     BOOL bSomeObjects=0;
    137     if(ObjectSize[0]){
    138         bSomeObjects=1;
    139 
    140         reg=REG_RAX;
    141         i2=NumOpe(&reg,ObjectSize,0,0,0);
    142         if(!IsWholeNumberType(i2)) SetError(49,NULL,cp);
    143 
    144         //※添え字上限値であることを考慮
    145         //add rax,1
    146         op_add64_value(REG_RAX,1);
    147 
    148         //オブジェクトの個数をrbxに一時保持
    149         //※rbxは関数が呼ばれても不変
    150         //mov rbx,rax
    151         op_mov64_ToReg_FromReg(REG_RBX,REG_RAX);
    152 
    153         //imul rax,size
    154         op_imul_value(sizeof(_int64),REG_RAX,TypeSize);
    155 
    156         //add rax,PTR_SIZE*3
    157         op_add64_value(REG_RAX,PTR_SIZE*3);
    158 
    159         //mov rcx,rax
    160         op_mov64_ToReg_FromReg(REG_RCX,REG_RAX);
    161     }
    162     else{
    163         //オブジェクトの個数をrbxに一時保持
    164         //※rbxは関数が呼ばれても不変
    165         //mov rbx,1
    166         op_mov_RV(sizeof(_int64),REG_RBX,1);
    167 
    168         //mov rcx,TypeSize+PTR_SIZE*3
    169         op_mov_RV(sizeof(_int64),REG_RCX,TypeSize+PTR_SIZE*3);
    170     }
    171 
    172     //call calloc
    173     extern SUBINFO *pSub_calloc;
    174     op_call(pSub_calloc);
    175 
    176 
    177     /*
    178     確保されたヒープ領域のポインタ（callocの戻り値eax）をpPtrとすると、
    179     pPtr-=sizeof(DWORD)*3
    180     pPtr[0]=オブジェクトの個数
    181     pPtr[1]=オブジェクトのサイズ
    182     pPtr[2]=デストラクタの関数ポインタ
    183     */
    184 
    185 
    186     //mov qword ptr[rax],rbx（オブジェクトの個数）
    187     op_mov_MR(sizeof(_int64),REG_RBX,REG_RAX,0,MOD_BASE);
    188 
    189     //add rax,PTR_SIZE
    190     op_add64_value(REG_RAX,PTR_SIZE);
    191 
    192 
    193     //mov qword ptr[rax],TypeSize（オブジェクトのサイズ）
    194     op_mov_MV(sizeof(_int64),REG_RAX,0,NON_OFFSET,TypeSize);
    195 
    196     //add rax,PTR_SIZE
    197     op_add64_value(REG_RAX,PTR_SIZE);
    198 
    199 
    200     CMethod *method = pobj_c->GetDestructorMethod();
    201     if( method == NULL ) return 0;
    202 
    203     //mov rcx,DestructorProcAddr
    204     op_mov_RV(sizeof(_int64),REG_RCX,0);
    205     obp-=sizeof(long);
    206     pobj_SubAddrSchedule->add(method->psi,0);
    207     method->psi->bUse=1;
    208     obp+=sizeof(long);
    209 
    210     //mov qword ptr[rax],rcx
    211     op_mov_MR(sizeof(_int64),REG_RCX,REG_RAX,0,MOD_BASE);
    212 
    213     //add rax,PTR_SIZE
    214     op_add64_value(REG_RAX,PTR_SIZE);
    215 
    216 
    217     // ※ここでプッシュされた値はNew演算子の戻り値となる
    218     //mov qword ptr[rsp+offset],rax     ※スタックフレームを利用
    219     pobj_sf->push(REG_RAX);
    220 
    221 
    222     /////////////////////////////////////////////////////////////////////
    223 
    224     ////////////////////////////
    225     // コンストラクタの呼び出し
    226     ////////////////////////////
    227 
    228     _call_constructor(pobj_c,CreateParameter,TypeSize,bSomeObjects);
    229 
    230 
    231     //mov rax,qword ptr[rsp+offset]     ※スタックフレームを利用
    232     pobj_sf->pop(REG_RAX);
    233 
     246    Operator_New( *pobj_c, objectSizeStr, CreateParameter, baseTypeInfo );
     247
     248    if( baseTypeInfo.type == DEF_OBJECT ){
     249        return DEF_OBJECT;
     250    }
    234251    return DEF_PTR_OBJECT;
    235252}
    236253
    237 void OpcodeDelete(const char *Parameter){
     254void OpcodeDelete(const char *Parameter, bool isSweeping){
    238255    int type;
    239256
    … …  
    254271
    255272    //add rax,PTR_SIZE
    256     op_add64_value(REG_RAX,PTR_SIZE);
     273    op_add_RV(REG_RAX,PTR_SIZE);
    257274
    258275
    … …  
    261278
    262279    //add rax,PTR_SIZE
    263     op_add64_value(REG_RAX,PTR_SIZE);
     280    op_add_RV(REG_RAX,PTR_SIZE);
    264281
    265282
    … …  
    268285
    269286    //add rax,PTR_SIZE
    270     op_add64_value(REG_RAX,PTR_SIZE);
     287    op_add_RV(REG_RAX,PTR_SIZE);
    271288
    272289
    273290    //mov rcx,rax
    274     op_mov64_ToReg_FromReg(REG_RCX,REG_RAX);
     291    op_mov_RR(REG_RCX,REG_RAX);
    275292
    276293
    … …  
    279296    jnz_back=obp;
    280297
    281     //mov qword ptr[rsp+offset],rax     ※スタックフレームを利用
    282     pobj_sf->push(REG_RAX);
     298    //mov qword ptr[rsp+offset],rcx     ※スタックフレームを利用
     299    pobj_sf->push(REG_RCX);
    283300
    284301    //call rdi
    … …  
    309326    pobj_sf->pop(REG_RCX);
    310327
    311     //call free
    312     extern SUBINFO *pSub_free;
    313     op_call(pSub_free);
     328    if( isSweeping ){
     329        //call _System_GC_free_for_SweepingDelete
     330        extern SUBINFO *pSub_System_GC_free_for_SweepingDelete;
     331        op_call(pSub_System_GC_free_for_SweepingDelete);
     332    }
     333    else{
     334        //call free
     335        extern SUBINFO *pSub_free;
     336        op_call(pSub_free);
     337    }
    314338}
Note: See TracChangeset for help on using the changeset viewer.