Changeset 75 in dev for BasicCompiler64/CParameter.cpp


Ignore:
Timestamp:
Mar 20, 2007, 4:36:16 AM (18 years ago)
Author:
dai_9181
Message:

TYPEINFO→Typeへのリファクタリングを実施。64bitはほぼ完了。32bitが全般的に未完成。

File:
1 edited

Legend:

Unmodified
Added
Removed

  • BasicCompiler64/CParameter.cpp

    r73 r75  
    22#include "opcode.h"
    33
    4 int ParamImpl::NewTempParameters( const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum ){
     4int ParamImpl::NewTempParameters( const string &procName, const Parameters &params, int SecondParmNum ){
     5    if( SecondParmNum == -1 ) SecondParmNum = (int)params.size();
     6
    57    ///////////////////////////////////////////////////////
    68    // 一時オブジェクトをあらかじめスタックに積んでおく
    … …  
    1214
    1315    BOOL bEllipse;
    14     if(pi_num){
    15         if(ppi[pi_num-1].type==DEF_ELLIPSE) bEllipse=1;
     16    if(params.size()){
     17        if(params[params.size()-1]->GetBasicType()==DEF_ELLIPSE) bEllipse=1;
    1618        else bEllipse=0;
    1719    }
    … …  
    2123        useTempParameters[i2] = false;
    2224
    23         if(bEllipse&&i2<=pi_num-2) bEllipse=0;
    24 
    25         if(i2==0&&ppi[i2].name){
    26             if(lstrcmp(ppi[i2].name,"_System_LocalThis")==0){
     25        if(bEllipse&&i2<=(int)params.size()-2) bEllipse=0;
     26
     27        if(i2==0){
     28            if( params[i2]->GetVarName() == "_System_LocalThis" ){
    2729                //オブジェクトメンバの第一パラメータのThisポインタ
    2830                continue;
    2931            }
    3032        }
    31         if((i2==0||i2==1)&&ppi[i2].name){
    32             if(lstrcmp(ppi[i2].name,FuncName)==0){
     33        if( i2==0||i2==1 ){
     34            if( params[i2]->GetVarName() == procName ){
    3335                //オブジェクトメンバの第一または第二パラメータの戻り値用オブジェクト
    3436                continue;
    … …  
    3638        }
    3739
    38         TYPEINFO DummyTypeInfo;
     40        Type dummyType;
    3941        BOOL bByVal;
    4042        if(bEllipse){
    41             DummyTypeInfo.type=NumOpe_GetType(Parms[i2],NULL,&DummyTypeInfo.u.lpIndex);
     43            NumOpe_GetType( Parms[i2], Type(), dummyType );
    4244            bByVal=1;
    4345        }
    4446        else{
    45             DummyTypeInfo.type=ppi[i2].type;
    46             DummyTypeInfo.u.lpIndex=ppi[i2].u.index;
    47             bByVal=ppi[i2].bByVal;
     47            dummyType = *params[i2];
     48            bByVal = ( params[i2]->IsRef() == false ) ? TRUE:FALSE;
    4849        }
    4950
    … …  
    5657            }
    5758
    58             LONG_PTR lpVarIndex;
    59             if( GetVarType( Parms[i2], &lpVarIndex, FALSE ) == -1 ){
     59            if( !GetVarType( Parms[i2], Type(), FALSE ) ){
    6060                //変数ではないとき
    6161                int reg = REG_RAX;
    62                 int type = NumOpe( &reg, Parms[i2], DummyTypeInfo.type, DummyTypeInfo.u.lpIndex, &lpVarIndex );
    63 
    64                 if( type != DEF_STRUCT ){
     62                Type calcType;
     63                NumOpe( &reg, Parms[i2], dummyType, calcType );
     64
     65                if( !calcType.IsStruct() ){
    6566                    //一時参照を作成
    6667                    pobj_sf->push( reg );
    … …  
    7677
    7778                bool result = CheckDifferentType(
    78                     DummyTypeInfo.type,
    79                     DummyTypeInfo.u.lpIndex,
    80                     type,
    81                     lpVarIndex,
    82                     FuncName,
     79                    dummyType,
     80                    calcType,
     81                    procName.c_str(),
    8382                    i2);
    8483
    … …  
    8786                    useTempObject = true;
    8887
    89                     types[i2].type = type;
    90                     types[i2].u.lpIndex = lpVarIndex;
     88                    types[i2] = calcType;
    9189                }
    9290            }
    … …  
    104102    for(int i2=ParmsNum-1;i2>=0;i2--){
    105103        if( useTempParameters[i2] ){
    106             if( types[i2].type == DEF_STRUCT ){
     104            if( types[i2].IsStruct() ){
    107105                // 構造体の一時メモリ
    108106
    … …  
    112110
    113111                //call free
    114                 extern SubInfo *pSub_free;
     112                extern UserProc *pSub_free;
    115113                op_call(pSub_free);
    116114            }
    … …  
    123121}
    124122
    125 void ParamImpl::SetStructParameter(int reg,CClass *pobj_Class,LPSTR Parameter){
     123void ParamImpl::SetStructParameter( int reg, const Type &baseType, const char *expression ){
    126124    //////////////////////////////////////////////////////
    127125    /////    レジスタ資源のバックアップ
    … …  
    129127    //////////////////////////////////////////////////////
    130128
    131         int object_size = pobj_Class->GetSize();
     129        int object_size = baseType.GetClass().GetSize();
    132130
    133131        //mov rcx,object_size
    … …  
    135133
    136134        //call calloc
    137         extern SubInfo *pSub_calloc;
     135        extern UserProc *pSub_calloc;
    138136        op_call(pSub_calloc);
    139137
    … …  
    144142        pobj_sf->push(REG_R11);
    145143
    146         TYPEINFO BaseType={DEF_STRUCT,(LONG_PTR)pobj_Class};
    147         TYPEINFO CalcType;
    148         CalcType.type=NumOpe_GetType(Parameter,&BaseType,&CalcType.u.lpIndex);
    149 
    150         /*
    151         TODO: 消す
    152         if( pobj_Class->GetCopyConstructorMethod()
    153             && CalcType.type==DEF_OBJECT&&CalcType.u.pobj_Class==pobj_Class){
    154             ////////////////////////////////////
    155             // コピーコンストラクタを呼び出す
    156             ////////////////////////////////////
    157 
    158             BOOL bUseHeap;
    159             int temp_reg=REG_RDX;
    160             CalcType.type=NumOpe(&temp_reg,Parameter,DEF_OBJECT,(LONG_PTR)pobj_Class,&CalcType.u.lpIndex,&bUseHeap);
    161 
    162             if(bUseHeap){
    163                 //mov r14,rdx
    164                 op_mov_RR(REG_R14,REG_RDX);
    165             }
    166 
    167             //mov r11,qword ptr[rsp+offset]     ※スタックフレームを利用
    168             pobj_sf->ref(REG_R11);
    169 
    170             //mov rcx,this
    171             op_mov_RR(REG_RCX,REG_R11);
    172 
    173             //call constructor
    174             op_call(pobj_Class->GetCopyConstructorMethod()->psi);
    175 
    176 
    177             if(bUseHeap){
    178                 FreeTempObject(REG_R14,pobj_Class);
    179             }
    180         }
    181         else{
    182             if( pobj_Class->GetConstructorMethod() ){
    183                 ////////////////////////////////
    184                 // コンストラクタを呼び出す
    185                 ////////////////////////////////
    186 
    187                 //mov rcx,this
    188                 op_mov_RR(REG_RCX,REG_R11);
    189 
    190                 //call constructor
    191                 op_call(pobj_Class->GetConstructorMethod()->psi);
    192             }
    193             */
    194 
    195 
    196             BOOL bUseHeap;
    197             int temp_reg=REG_RAX;
    198             CalcType.type=NumOpe(&temp_reg,Parameter,DEF_STRUCT,(LONG_PTR)pobj_Class,&CalcType.u.lpIndex,&bUseHeap);
    199 
    200 
    201             //mov r11,qword ptr[rsp+offset]     ※スタックフレームを利用
    202             pobj_sf->ref(REG_R11);
    203 
    204 
    205             RELATIVE_VAR RelativeVar;
    206             RelativeVar.bOffsetOffset=0;
    207             RelativeVar.offset=0;
    208             RelativeVar.dwKind=VAR_DIRECTMEM;
    209 
    210             SetStructVariableFromRax((LONG_PTR)pobj_Class,CalcType.type,CalcType.u.lpIndex,&RelativeVar,bUseHeap);
    211 
    212         //}
     144
     145        Type calcType;
     146        BOOL bUseHeap;
     147        int temp_reg=REG_RAX;
     148        NumOpe( &temp_reg,
     149            expression,
     150            baseType,
     151            calcType,
     152            &bUseHeap );
     153
     154
     155        //mov r11,qword ptr[rsp+offset]     ※スタックフレームを利用
     156        pobj_sf->ref(REG_R11);
     157
     158
     159        RELATIVE_VAR RelativeVar;
     160        RelativeVar.bOffsetOffset=0;
     161        RelativeVar.offset=0;
     162        RelativeVar.dwKind=VAR_DIRECTMEM;
     163
     164        SetStructVariableFromRax(
     165            baseType,
     166            calcType,
     167            &RelativeVar,bUseHeap);
     168
    213169
    214170        //mov r11,qword ptr[rsp+offset]     ※スタックフレームを利用
    … …  
    225181
    226182
    227 void ParamImpl::SetParameter(const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum){
     183void ParamImpl::SetParameter( const string &procName, const Parameters &params, int SecondParmNum ){
     184    if( SecondParmNum == -1 ) SecondParmNum = (int)params.size();
     185
    228186    ///////////////////////////////////////////////////////////
    229187    // パラメータをレジスタ及びスタックフレームにセット
    … …  
    232190
    233191    BOOL bEllipse;
    234     if(pi_num){
    235         if(ppi[pi_num-1].type==DEF_ELLIPSE) bEllipse=1;
     192    if( params.size() ){
     193        if(params[params.size()-1]->GetBasicType()==DEF_ELLIPSE) bEllipse=1;
    236194        else bEllipse=0;
    237195    }
    … …  
    240198    BOOL bHas_System_LocalThis=0;
    241199    if(ParmsNum>=1){
    242         if(lstrcmp(ppi[0].name,"_System_LocalThis")==0)
     200        if( params[0]->GetVarName() == "_System_LocalThis" ){
    243201            bHas_System_LocalThis=1;
     202        }
    244203    }
    245204
    246205    //戻り値用の変数名を取得
    247     const char *lpszVarNameToReturn = (FuncName[0]==1&&FuncName[1]==ESC_OPERATOR)?"_System_ReturnValue":FuncName;
     206    const char *lpszVarNameToReturn = (procName[0]==1&&procName[1]==ESC_OPERATOR)?"_System_ReturnValue":procName.c_str();
    248207
    249208    //パラメータをレジスタとスタックに格納
    250     int CalcType;
    251     LONG_PTR lpCalcIndex;
    252     BOOL bCalcUseHeap;
    253209    int ParmSize=0;
    254210    int reg,temp_reg;
    255211    RELATIVE_VAR RelativeVar;
    256212    for(i2=ParmsNum-1;i2>=0;i2--){
    257         if(bEllipse&&i2<=pi_num-2) bEllipse=0;
    258 
    259         if(i2==0&&ppi[i2].name){
    260             if(lstrcmp(ppi[i2].name,"_System_LocalThis")==0){
     213        if(bEllipse&&i2<=(int)params.size()-2) bEllipse=0;
     214
     215        if(i2==0){
     216            if( params[i2]->GetVarName() == "_System_LocalThis" ){
    261217                //オブジェクトメンバの第一パラメータのThisポインタ
    262218                continue;
    263219            }
    264220        }
    265         if((i2==0||i2==1)&&ppi[i2].name){
    266             if(lstrcmp(ppi[i2].name,lpszVarNameToReturn)==0){
     221        if(i2==0||i2==1){
     222            if( params[i2]->GetVarName() == lpszVarNameToReturn ){
    267223                //オブジェクトメンバの第一または第二パラメータの戻り値用オブジェクト
    268224                continue;
    … …  
    270226        }
    271227
    272         TYPEINFO DummyTypeInfo;
     228        Type dummyType;
    273229        BOOL bByVal;
    274230        if(bEllipse){
    275             DummyTypeInfo.type=NumOpe_GetType(Parms[i2],NULL,&DummyTypeInfo.u.lpIndex);
     231            NumOpe_GetType( Parms[i2], Type(), dummyType );
    276232            bByVal=1;
    277233        }
    278234        else{
    279             DummyTypeInfo.type=ppi[i2].type;
    280             DummyTypeInfo.u.lpIndex=ppi[i2].u.index;
    281             bByVal=ppi[i2].bByVal;
     235            dummyType = *params[i2];
     236            bByVal = ( params[i2]->IsRef() == false ) ? TRUE:FALSE;
    282237        }
    283238
    284239        int xmm_temp_sw=0;
    285         if(IsRealNumberType(DummyTypeInfo.type)&&bByVal){
     240        if(dummyType.IsReal()&&bByVal){
    286241            //実数型
    287242            if(i2==0) reg=REG_XMM0;
    … …  
    308263            if(Parms[i2][0]==1&&Parms[i2][1]==ESC_BYVAL){
    309264                char temp2[255];
    310                 sprintf(temp2,"%s関数の第%dパラメータ",FuncName,i2+1);
     265                sprintf(temp2,"%s関数の第%dパラメータ",procName,i2+1);
    311266                SetError(19,temp2,cp);
    312267                continue;
    313268            }
    314269
    315             if(DummyTypeInfo.type==DEF_STRUCT){
    316                 SetStructParameter(reg,DummyTypeInfo.u.pobj_Class,Parms[i2]);
     270            if( dummyType.IsStruct() ){
     271                SetStructParameter( reg, dummyType, Parms[i2] );
    317272                goto next;
    318273            }
    … …  
    321276
    322277            extern LONG_PTR ProcPtr_BaseIndex;
    323             LONG_PTR back_ProcPtr_BaseIndex;
    324             back_ProcPtr_BaseIndex=ProcPtr_BaseIndex;
    325             if(DummyTypeInfo.type==DEF_PTR_PROC) ProcPtr_BaseIndex=DummyTypeInfo.u.lpIndex;
    326             else ProcPtr_BaseIndex=-1;
    327 
    328             CalcType=NumOpe(&temp_reg,Parms[i2],DummyTypeInfo.type,DummyTypeInfo.u.lpIndex,&lpCalcIndex,&bCalcUseHeap);
     278            LONG_PTR back_ProcPtr_BaseIndex = ProcPtr_BaseIndex;
     279            if( dummyType.IsProcPtr() ){
     280                ProcPtr_BaseIndex = dummyType.GetIndex();
     281            }
     282            else{
     283                ProcPtr_BaseIndex=-1;
     284            }
     285
     286            BOOL bCalcUseHeap;
     287            Type calcType;
     288            if( !NumOpe( &temp_reg, Parms[i2], dummyType, calcType, &bCalcUseHeap ) ){
     289                break;
     290            }
    329291
    330292            ProcPtr_BaseIndex=back_ProcPtr_BaseIndex;
    331293
    332             if(CalcType==-1) break;
    333 
    334             if(CalcType==DEF_OBJECT){
    335                 if( DummyTypeInfo.type != DEF_OBJECT
     294            if( calcType.IsObject() ){
     295                if( !dummyType.IsObject()
    336296                    ||
    337                     DummyTypeInfo.type == DEF_OBJECT &&
    338                     !DummyTypeInfo.u.pobj_Class->IsEqualsOrSubClass( (CClass *)lpCalcIndex ) ){
     297                    dummyType.IsObject() &&
     298                    !dummyType.GetClass().IsEqualsOrSubClass( &calcType.GetClass() ) ){
    339299                        //キャスト演算子のオーバーロードに対応する
    340                         CallCastOperatorProc(reg,CalcType,lpCalcIndex,bCalcUseHeap,DummyTypeInfo.type,DummyTypeInfo.u.lpIndex);
     300                        CallCastOperatorProc( reg, calcType, bCalcUseHeap,dummyType );
    341301                }
    342302            }
    … …  
    344304
    345305            if(bEllipse){
    346                 if(IsRealNumberType(CalcType)){
     306                if( calcType.IsReal() ){
    347307                    //整数レジスタへコピー
    348308                    //※cdeclの拡張パラメータは実数の場合も汎用レジスタで引渡し
    … …  
    358318                    }
    359319                }
    360                 else if(IsWholeNumberType(CalcType)){
     320                else if( calcType.IsWhole() ){
    361321                    //整数型の場合は、64ビットへ拡張する
    362                     ExtendTypeTo64(CalcType,temp_reg);
     322                    ExtendTypeTo64( calcType.GetBasicType(), temp_reg );
    363323                }
    364324            }
    … …  
    369329                else i3=i2;
    370330                CheckDifferentType(
    371                     DummyTypeInfo.type,
    372                     DummyTypeInfo.u.lpIndex,
    373                     CalcType,
    374                     lpCalcIndex,
    375                     FuncName,
     331                    dummyType,
     332                    calcType,
     333                    procName.c_str(),
    376334                    i3);
    377335
    378 
    379                 if(DummyTypeInfo.type==DEF_DOUBLE){
     336                if( dummyType.IsDouble() ){
    380337                    //Double型へ変換
    381                     ChangeTypeToXmm_Double(CalcType,reg,temp_reg);
    382                 }
    383                 else if(DummyTypeInfo.type==DEF_SINGLE){
     338                    ChangeTypeToXmm_Double(calcType.GetBasicType(),reg,temp_reg);
     339                }
     340                else if( dummyType.IsSingle() ){
    384341                    //Single型へ変換
    385                     ChangeTypeToXmm_Single(CalcType,reg,temp_reg);
    386                 }
    387                 else if(IsWholeNumberType(DummyTypeInfo.type)){
     342                    ChangeTypeToXmm_Single(calcType.GetBasicType(),reg,temp_reg);
     343                }
     344                else if( dummyType.IsWhole() ){
    388345                    //実数型 → 整数型
    389                     ChangeTypeToWhole(CalcType,DummyTypeInfo.type,reg,temp_reg);
     346                    ChangeTypeToWhole(calcType.GetBasicType(),dummyType.GetBasicType(),reg,temp_reg);
    390347                }
    391348            }
    … …  
    397354
    398355                temp_reg=reg;
    399                 CalcType=NumOpe(&temp_reg,Parms[i2]+2,0,0,&lpCalcIndex);
    400                 if(CalcType==-1) break;
    401 
    402                 int ptr_type;
    403                 ptr_type=GetPtrType(DummyTypeInfo.type,DummyTypeInfo.u.lpIndex);
     356                Type calcType;
     357                if( !NumOpe(&temp_reg, Parms[i2]+2, dummyType, calcType) ){
     358                    break;
     359                }
     360
     361                dummyType.PtrLevelUp();
    404362
    405363                //型チェック
    … …  
    407365                else i3=i2;
    408366                CheckDifferentType(
    409                     ptr_type,
    410                     DummyTypeInfo.u.lpIndex,
    411                     CalcType,
    412                     lpCalcIndex,
    413                     FuncName,
     367                    dummyType,
     368                    calcType,
     369                    procName.c_str(),
    414370                    i3);
    415371
    416                 if(IsRealNumberType(CalcType)){
     372                if( calcType.IsReal() ){
    417373                    //実数型 → 整数型
    418                     ChangeTypeToWhole(CalcType,DEF_QWORD,reg,temp_reg);
     374                    ChangeTypeToWhole( calcType.GetBasicType(), DEF_QWORD,reg,temp_reg);
    419375                }
    420376            }
    … …  
    428384                else{
    429385                    //変数のアドレスを取得
    430                     int VarType;
    431                     LONG_PTR lpVarIndex;
     386                    Type varType;
    432387                    if(GetVarOffset(
    433388                        false,
    434389                        false,
    435390                        Parms[i2],
    436                         &VarType,
    437391                        &RelativeVar,
    438                         &lpVarIndex)){
    439 
    440                             if(DummyTypeInfo.type!=DEF_ANY){
     392                        varType)){
     393
     394                            if( !dummyType.IsAny() ){
    441395                                //型チェックを行う
    442                                 if(DummyTypeInfo.type==VarType){
    443                                     if(DummyTypeInfo.type==DEF_OBJECT){
    444                                         if( !DummyTypeInfo.u.pobj_Class->IsEqualsOrSubClass( (CClass *)lpVarIndex ) ){
     396                                if( dummyType.GetBasicType() == varType.GetBasicType() ){
     397                                    if( dummyType.IsObject() ){
     398                                        if( !dummyType.GetClass().IsEqualsOrSubClass( &varType.GetClass() ) ){
    445399                                            SetError(11,Parms[i2],cp);
    446400                                        }
    447401                                    }
    448                                     else if(DummyTypeInfo.type==DEF_STRUCT){
    449                                         if( !DummyTypeInfo.u.pobj_Class->IsEquals( (CClass *)lpVarIndex ) ){
     402                                    else if( dummyType.IsStruct() ){
     403                                        if( !dummyType.GetClass().IsEquals( &varType.GetClass() ) ){
    450404                                            SetError(11,Parms[i2],cp);
    451405                                        }
    452406                                    }
    453407                                }
    454                                 else if((VarType&FLAG_PTR)&&((VarType^FLAG_PTR)==DummyTypeInfo.type)){
     408                                else if( (varType.GetBasicType()&FLAG_PTR)
     409                                    &&((varType.GetBasicType()^FLAG_PTR)==dummyType.GetBasicType())){
    455410                                    //仮引数がポインタ参照で、実引数が配列の先頭ポインタのとき
    456411                                }
    … …  
    494449
    495450    //パラメータが収まるだけのスタックフレームを確保
    496     pobj_sf->parameter_allocate(pi_num*sizeof(_int64)+   sizeof(_int64)/*ret用*/  );
     451    pobj_sf->parameter_allocate((int)params.size()*sizeof(_int64)+   sizeof(_int64)/*ret用*/  );
    497452}
    498453void ParamImpl::BackupParameter(int pi_num){
Note: See TracChangeset for help on using the changeset viewer.