Changeset 64 in dev for BasicCompiler64/Compile_Var.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_Var.cpp

    r63 r64  
    4141
    4242    if(PTR_LEVEL(*pType)){
    43         *pType=MAKE_PTR_TYPE(NATURAL_TYPE(*pType),PTR_LEVEL(*pType)-1);
    44         if((*pType)==DEF_OBJECT){
    45             CClass *pClass = (CClass *)lpIndex;
    46             //imul reg,objsize
    47             op_imul_value( sizeof(_int64), reg, pClass->GetSize() );
    48         }
    49         else{
    50             i2=GetTypeSize(*pType,-1);
    51             if(i2>=2){
    52                 //imul reg,i2
    53                 op_imul_value(sizeof(_int64),reg,i2);
    54             }
     43        *pType = PTR_LEVEL_DOWN( *pType );
     44
     45        i2=GetTypeSize(*pType,-1);
     46        if(i2>=2){
     47            //imul reg,i2
     48            op_imul_RV(sizeof(_int64),reg,i2);
    5549        }
    5650    }
    … …  
    7165    //add r11,reg
    7266    op_add64_reg(REG_R11,reg);
     67}
     68void SetRelativeOffset( RELATIVE_VAR &relativeVar ){
     69    if(relativeVar.dwKind==VAR_DIRECTMEM){
     70        //mov r11,qword ptr[r11]
     71        op_mov_RM(sizeof(_int64),REG_R11,REG_R11,0,MOD_BASE);
     72    }
     73    else{
     74        //直接参照に切り替え
     75        SetVarPtrToReg(REG_R12,&relativeVar);
     76        relativeVar.dwKind=VAR_DIRECTMEM;
     77
     78        //mov r11,qword ptr[r12]
     79        op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
     80    }
    7381}
    7482BOOL GetArrayOffset(int *SubScripts,char *array,int type,LONG_PTR lpIndex){
    … …  
    153161
    154162        //imul reg,i4
    155         op_imul_value(sizeof(_int64),reg,i4);
     163        op_imul_RV(sizeof(_int64),reg,i4);
    156164
    157165        //add r12,reg
    … …  
    192200    char lpPtrOffset[VN_SIZE];  //第2次配列
    193201    char NestMember[VN_SIZE];   //入れ子メンバ
    194     int RefType;                //"."参照のときは0、"->"参照のときは1
     202    CClass::RefType refType;
    195203    lstrcpy(VarName,member);
    196     if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,&RefType)) return 0;
     204    if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,refType)) return 0;
    197205
    198206
    … …  
    279287        //入れ子構造の場合
    280288
    281         if(*pType==DEF_OBJECT && pMember->IsRef() == false){
    282             if(RefType!=DEF_OBJECT){
     289        if(*pType==DEF_OBJECT || *pType==DEF_STRUCT){
     290            if( refType != CClass::Dot ){
    283291                if(isErrorEnabled) SetError(104,member,cp);
    284292                return 0;
    285293            }
    286         }
    287         else if(*pType==DEF_PTR_OBJECT || ( *pType==DEF_OBJECT && pMember->IsRef() )){
     294
     295            if( *pType==DEF_OBJECT ){
     296                // 参照内容へのポインタを抽出
     297                SetRelativeOffset( *pRelativeVar );
     298            }
     299        }
     300        else if(*pType==DEF_PTR_OBJECT||*pType==DEF_PTR_STRUCT){
    288301            //構造体ポインタ型メンバ変数
    289302
    290303            if(lpPtrOffset[0]){
    291304                //pObj[n].member
    292                 if(*pType==DEF_PTR_OBJECT&&RefType!=DEF_OBJECT){
     305                if( ( *pType==DEF_PTR_OBJECT||*pType==DEF_PTR_STRUCT )&& refType != CClass::Dot ){
    293306                    if(isErrorEnabled) SetError(104,member,cp);
    294307                    return 0;
    … …  
    303316            else{
    304317                //pObj->member
    305                 if(*pType==DEF_PTR_OBJECT&&RefType!=DEF_PTR_OBJECT){
     318                if( ( *pType==DEF_PTR_OBJECT||*pType==DEF_PTR_STRUCT )&& refType != CClass::Pointer ){
    306319                    if(isErrorEnabled) SetError(104,member,cp);
    307320                    return 0;
    308321                }
    309322
    310                 if(pRelativeVar->dwKind==VAR_DIRECTMEM){
    311                     //mov r11,qword ptr[r11]
    312                     op_mov_RM(sizeof(_int64),REG_R11,REG_R11,0,MOD_BASE);
    313                 }
    314                 else{
    315                     //直接参照に切り替え
    316                     SetVarPtrToReg(REG_R12,pRelativeVar);
    317                     pRelativeVar->dwKind=VAR_DIRECTMEM;
    318 
    319                     //mov r11,qword ptr[r12]
    320                     op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
    321                 }
    322             }
    323         }
    324         else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2)){
     323                SetRelativeOffset( *pRelativeVar );
     324            }
     325        }
     326        else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2) || *pType==MAKE_PTR_TYPE(DEF_STRUCT,2)){
    325327            //構造体ポインタのポインタ型メンバ変数
    326328
    327329            if(lpPtrOffset[0]){
    328330                //ppObj[n]->member
    329                 if(RefType!=DEF_PTR_OBJECT){
     331                if( refType != CClass::Pointer ){
    330332                    if(isErrorEnabled) SetError(104,member,cp);
    331333                    return 0;
    … …  
    388390BOOL GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss){
    389391    extern BOOL bCompilingGlobal;
    390     int i,RefType;
     392    int i;
    391393    LONG_PTR lpIndex;
    392394    char variable[VN_SIZE],member[VN_SIZE],VarName[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
    … …  
    398400    else lstrcpy(variable,NameBuffer);
    399401
    400     if( FormatUseProcReturnObject( variable, VarName, array, RefType, member ) ){
     402    CClass::RefType refType;
     403    if( FormatUseProcReturnObject( variable, VarName, array, refType, member ) ){
    401404        // 戻り値オブジェクトのメンバを直接参照しているとき
    402405        //例: func().member
    … …  
    442445
    443446    lstrcpy(VarName,variable);
    444     GetVarFormatString(VarName,array,lpPtrOffset,member,&RefType);
     447    GetVarFormatString(VarName,array,lpPtrOffset,member,refType);
    445448
    446449    int *pSubScripts;
    … …  
    581584        char tempMember[VN_SIZE];
    582585        char tempArray[VN_SIZE];
    583         GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember,&i);
     586        {
     587            CClass::RefType refType;
     588            GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember, refType );
     589        }
    584590
    585591        char temp2[VN_SIZE];
    … …  
    697703    }
    698704    if(member[0]){
    699         if(*pType==DEF_OBJECT){
     705        if(*pType==DEF_OBJECT || *pType==DEF_STRUCT){
    700706            //実態オブジェクトのメンバを参照（obj.member）
    701             if(RefType!=DEF_OBJECT){
     707            if( refType != CClass::Dot ){
    702708                SetError(104,VarName,cp);
    703709                pRelativeVar->dwKind=NON_VAR;
    704710                return 0;
    705711            }
    706         }
    707         else if(*pType==DEF_PTR_OBJECT){
     712
     713            if( *pType==DEF_OBJECT ){
     714                // 参照内容へのポインタを抽出
     715                SetRelativeOffset( *pRelativeVar );
     716            }
     717        }
     718        else if(*pType==DEF_PTR_OBJECT || *pType==DEF_PTR_STRUCT){
    708719            //ポインタオブジェクトが示すメンバを参照
    709720            if(lpPtrOffset[0]){
    710721                //pObj[n].member
    711                 if(RefType!=DEF_OBJECT){
     722                if( refType != CClass::Dot ){
    712723                    SetError(104,VarName,cp);
    713724                    pRelativeVar->dwKind=NON_VAR;
    … …  
    719730            else{
    720731                //pObj->member
    721                 if(RefType!=DEF_PTR_OBJECT){
     732                if( refType != CClass::Pointer ){
    722733                    SetError(104,VarName,cp);
    723734                    pRelativeVar->dwKind=NON_VAR;
    … …  
    732743            }
    733744        }
    734         else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2)){
     745        else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2) || *pType==MAKE_PTR_TYPE(DEF_STRUCT,2)){
    735746            //ポインタオブジェクトが示すメンバを参照
    736747            if(lpPtrOffset[0]){
    737748                //ppObj[n]->member
    738                 if(RefType!=DEF_PTR_OBJECT){
     749                if( refType != CClass::Pointer ){
    739750                    SetError(104,VarName,cp);
    740751                    pRelativeVar->dwKind=NON_VAR;
    … …  
    815826        }
    816827
    817         if(type==DEF_OBJECT){
     828        if(type==DEF_STRUCT){
    818829            CClass *pobj_c;
    819830            pobj_c=(CClass *)lpIndex;
    … …  
    848859    ///////////////////////////////////////
    849860
    850     if( type == DEF_OBJECT){
    851         //オブジェクトの場合はありえない
     861    if( type == DEF_OBJECT || type == DEF_STRUCT ){
     862        //オブジェクトまたは構造体の場合はありえない
    852863        SetError(300,NULL,cp);
    853864        return 0;
    … …  
    888899            *(float *)(initGlobalBuf+offset)=(float)dbl;
    889900    else if(type==DEF_INT64||type==DEF_QWORD||IsPtrType(type)){
    890         if(type==DEF_PTR_BYTE&&lpCalcIndex==LITERAL_STRING){
     901        if(type==DEF_PTR_CHAR&&lpCalcIndex==LITERAL_STRING){
    891902            //文字列定数のとき
    892903
    … …  
    953964        }
    954965
    955         if(type==DEF_OBJECT){
     966        if(type==DEF_STRUCT){
    956967            CClass *pobj_c;
    957968            pobj_c=(CClass *)lpIndex;
    … …  
    10371048    }
    10381049    else if(type==DEF_INT64||type==DEF_QWORD||IsPtrType(type)){
    1039         if(type==DEF_PTR_BYTE&&lpCalcIndex==LITERAL_STRING){
     1050        if(type==DEF_PTR_CHAR&&lpCalcIndex==LITERAL_STRING){
    10401051            //文字列定数のとき
    10411052
    … …  
    11011112}
    11021113
    1103 
     1114void dim(bool isRef, char *VarName,int *SubScripts,TYPEINFO &TypeInfo,int TypeSize,char *InitBuf,char *ConstractParameter,DWORD dwFlags){
     1115    extern BOOL bCompilingGlobal;
     1116    if(bCompilingGlobal){
     1117        /////////////////////////
     1118        // グローバル変数
     1119        /////////////////////////
     1120
     1121        AddGlobalVariable(isRef,VarName,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags);
     1122    }
     1123    else{
     1124        /////////////////
     1125        // ローカル変数
     1126        /////////////////
     1127
     1128        int i2,i3;
     1129
     1130        for(i2=0;i2<MaxLocalVarNum;i2++){
     1131            if(LocalVar[i2].bLiving&&obj_LexScopes.GetNowLevel()==LocalVar[i2].ScopeLevel){
     1132                if(lstrcmp(LocalVar[i2].name,VarName)==0){
     1133                    //２重定義のエラー
     1134                    SetError(15,VarName,cp);
     1135                    return;
     1136                }
     1137            }
     1138        }
     1139
     1140        LocalVar=(VARIABLE *)HeapReAlloc(hHeap,0,LocalVar,(MaxLocalVarNum+1)*sizeof(VARIABLE));
     1141        VARIABLE *pVar = &LocalVar[MaxLocalVarNum];
     1142        MaxLocalVarNum++;
     1143
     1144        if( isRef ){
     1145            //参照型
     1146            pVar->fRef = REF_VARIABLE;
     1147            TypeSize = PTR_SIZE;
     1148        }
     1149        else pVar->fRef=0;
     1150
     1151        for(i2=1,i3=0;i3<255;i3++){
     1152            //配列要素数
     1153            pVar->SubScripts[i3]=SubScripts[i3];
     1154
     1155            if(SubScripts[i3]==-1) break;
     1156            i2*=SubScripts[i3]+1;
     1157        }
     1158        int VarSize=TypeSize*i2;
     1159        if(VarSize%8) VarSize+=8-(VarSize%8);
     1160
     1161        //変数データを追加
     1162        lstrcpy(pVar->name,VarName);
     1163        if(dwFlags & DIMFLAG_CONST) pVar->bConst = true;
     1164        else pVar->bConst = false;
     1165        if(SubScripts[0]==-1) pVar->bArray=0;
     1166        else pVar->bArray=1;
     1167        pVar->type=TypeInfo.type;
     1168        pVar->u.index=TypeInfo.u.lpIndex;
     1169
     1170        //アラインメントを考慮
     1171        if( pVar->type==DEF_STRUCT ){
     1172            int alignment = pVar->u.pobj_c->iAlign;
     1173            if( alignment ){
     1174                if( AllLocalVarSize % alignment ){
     1175                    AllLocalVarSize += alignment - (AllLocalVarSize % alignment);
     1176                }
     1177            }
     1178        }
     1179
     1180        AllLocalVarSize+=VarSize;
     1181        pVar->offset=AllLocalVarSize;
     1182
     1183        //レキシカルスコープ
     1184        pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
     1185        pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
     1186        pVar->bLiving=TRUE;
     1187
     1188        if(InitBuf[0]){
     1189            //初期代入時のみ、書き込みアクセスを許可する
     1190            bool bConstBack = pVar->bConst;
     1191            pVar->bConst = false;
     1192
     1193            int result = 0;
     1194            if( pVar->type != DEF_OBJECT ){
     1195                result = InitLocalVar(-pVar->offset,
     1196                    pVar->type,
     1197                    pVar->u.index,
     1198                    pVar->SubScripts,
     1199                    InitBuf);
     1200            }
     1201
     1202            if(!result){
     1203                //動的な式だった場合は代入演算を行う
     1204                char temporary[8192];
     1205                sprintf(temporary,"%s=%s",VarName,InitBuf);
     1206                OpcodeCalc(temporary);
     1207            }
     1208
     1209            pVar->bConst = bConstBack;
     1210        }
     1211        else{
     1212            //0初期化
     1213
     1214            //mov r8, 0
     1215            op_zero_reg( REG_R8 );
     1216
     1217            //mov rdx, VarSize
     1218            op_mov_RV( sizeof(_int64), REG_RDX, VarSize );
     1219
     1220            //mov rcx, rsp
     1221            op_mov_RR( REG_RCX, REG_RSP );
     1222
     1223            //add rcx, offset
     1224            op_add_RV( REG_RCX, -pVar->offset );
     1225            obp-=sizeof(long);
     1226            AddLocalVarAddrSchedule();
     1227            obp+=sizeof(long);
     1228
     1229            //call FillMemory
     1230            DECLAREINFO *pdi;
     1231            pdi=GetDeclareHash("FillMemory");
     1232            op_call( pdi );
     1233        }
     1234    }
     1235
     1236    //コンストラクタ呼び出し
     1237    if(TypeInfo.type==DEF_OBJECT&&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0&&InitBuf[0]=='\0'){
     1238        char objectSize[255];
     1239        if( SubScripts[0] == -1 ){
     1240            objectSize[0] = 0;
     1241        }
     1242        else{
     1243            if( SubScripts[1] != -1 ){
     1244                SetError(300,NULL,cp);
     1245            }
     1246            sprintf( objectSize, "%d", SubScripts[0] );
     1247        }
     1248        Operator_New( *TypeInfo.u.pobj_Class, objectSize, ConstractParameter, TypeInfo );
     1249
     1250        int type;
     1251        LONG_PTR lpIndex;
     1252        RELATIVE_VAR RelativeVar;
     1253        GetVarOffset( true, false, VarName, &type, &RelativeVar, &lpIndex );
     1254        if( RelativeVar.dwKind == VAR_DIRECTMEM ){
     1255            SetError();
     1256        }
     1257        SetVariableFromRax( DEF_OBJECT, DEF_OBJECT, &RelativeVar );
     1258    }
     1259
     1260    if(TypeInfo.type==DEF_OBJECT){
     1261        if(TypeInfo.u.pobj_Class->IsAbstract()){
     1262            //抽象クラスだったとき
     1263            SetError(125,TypeInfo.u.pobj_Class->name,cp);
     1264        }
     1265    }
     1266}
    11041267void dim(char *Parameter,DWORD dwFlags){
    11051268    extern BOOL bCompilingGlobal;
    11061269    extern HANDLE hHeap;
    1107     int i2,i3,VarSize;
     1270    int i2;
    11081271    char VarName[VN_SIZE];
    11091272
    … …  
    11721335    TypeSize=GetTypeSize(TypeInfo.type,TypeInfo.u.lpIndex);
    11731336
     1337    extern BOOL bCompilingGlobal;
    11741338    if(dwFlags&DIMFLAG_STATIC){
    11751339        if(bCompilingGlobal){
    … …  
    11861350        GetNowStaticVarFullName(VarName,temporary);
    11871351
    1188         AddGlobalVariable(isRef,temporary,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags);
     1352        dim( isRef,temporary,SubScripts,TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags );
    11891353
    11901354        /*
    … …  
    11941358    }
    11951359    else{
    1196         if(bCompilingGlobal){
    1197             /////////////////////////
    1198             // グローバル変数
    1199             /////////////////////////
    1200 
    1201             AddGlobalVariable(isRef,VarName,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags);
    1202         }
    1203         else{
    1204             /////////////////
    1205             // ローカル変数
    1206             /////////////////
    1207 
    1208             for(i2=0;i2<MaxLocalVarNum;i2++){
    1209                 if(LocalVar[i2].bLiving&&obj_LexScopes.GetNowLevel()==LocalVar[i2].ScopeLevel){
    1210                     if(lstrcmp(LocalVar[i2].name,VarName)==0){
    1211                         //２重定義のエラー
    1212                         SetError(15,VarName,cp);
    1213                         return;
    1214                     }
    1215                 }
    1216             }
    1217 
    1218             LocalVar=(VARIABLE *)HeapReAlloc(hHeap,0,LocalVar,(MaxLocalVarNum+1)*sizeof(VARIABLE));
    1219             VARIABLE *pVar = &LocalVar[MaxLocalVarNum];
    1220             MaxLocalVarNum++;
    1221 
    1222             if( isRef ){
    1223                 //参照型
    1224                 pVar->fRef = REF_VARIABLE;
    1225                 TypeSize = PTR_SIZE;
    1226             }
    1227             else pVar->fRef=0;
    1228 
    1229             for(i2=1,i3=0;i3<255;i3++){
    1230                 //配列要素数
    1231                 pVar->SubScripts[i3]=SubScripts[i3];
    1232 
    1233                 if(SubScripts[i3]==-1) break;
    1234                 i2*=SubScripts[i3]+1;
    1235             }
    1236             VarSize=TypeSize*i2;
    1237             if(VarSize%8) VarSize+=8-(VarSize%8);
    1238 
    1239             //変数データを追加
    1240             lstrcpy(pVar->name,VarName);
    1241             if(dwFlags & DIMFLAG_CONST) pVar->bConst = true;
    1242             else pVar->bConst = false;
    1243             if(SubScripts[0]==-1) pVar->bArray=0;
    1244             else pVar->bArray=1;
    1245             pVar->type=TypeInfo.type;
    1246             pVar->u.index=TypeInfo.u.lpIndex;
    1247             AllLocalVarSize+=VarSize;
    1248             pVar->offset=AllLocalVarSize;
    1249 
    1250             //レキシカルスコープ
    1251             pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
    1252             pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
    1253             pVar->bLiving=TRUE;
    1254 
    1255             if(InitBuf[0]){
    1256                 //初期代入時のみ、書き込みアクセスを許可する
    1257                 bool bConstBack = pVar->bConst;
    1258                 pVar->bConst = false;
    1259 
    1260                 int result = InitLocalVar(-pVar->offset,
    1261                     pVar->type,
    1262                     pVar->u.index,
    1263                     pVar->SubScripts,
    1264                     InitBuf);
    1265 
    1266                 if(!result){
    1267                     //動的な式だった場合は代入演算を行う
    1268                     if( isRef ){
    1269                         SetRefVariable( VarName, InitBuf );
    1270                     }
    1271                     else{
    1272                         char temporary[8192];
    1273                         sprintf(temporary,"%s=%s",VarName,InitBuf);
    1274                         OpcodeCalc(temporary);
    1275                     }
    1276                 }
    1277 
    1278                 pVar->bConst = bConstBack;
    1279             }
    1280             else{
    1281                 //0初期化
    1282 
    1283                 //mov r8, 0
    1284                 op_zero_reg( REG_R8 );
    1285 
    1286                 //mov rdx, VarSize
    1287                 op_mov_RV( sizeof(_int64), REG_RDX, VarSize );
    1288 
    1289                 //mov rcx, rsp
    1290                 op_mov_RR( REG_RCX, REG_RSP );
    1291 
    1292                 //add rcx, offset
    1293                 op_add64_value( REG_RCX, -pVar->offset );
    1294                 obp-=sizeof(long);
    1295                 AddLocalVarAddrSchedule();
    1296                 obp+=sizeof(long);
    1297 
    1298                 //call FillMemory
    1299                 DECLAREINFO *pdi;
    1300                 pdi=GetDeclareHash("FillMemory");
    1301                 op_call( pdi );
    1302             }
    1303         }
    1304 
    1305         //コンストラクタ呼び出し
    1306         if(TypeInfo.type==DEF_OBJECT&&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0&& isRef == false ){
    1307             CallConstructor(VarName,SubScripts,TypeInfo,ConstractParameter);
    1308         }
    1309     }
    1310 
    1311     if(TypeInfo.type==DEF_OBJECT){
    1312         if(TypeInfo.u.pobj_Class->IsAbstract()){
    1313             //抽象クラスだったとき
    1314             SetError(125,TypeInfo.u.pobj_Class->name,cp);
    1315         }
     1360        dim( isRef,VarName,SubScripts,TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags );
    13161361    }
    13171362}
    … …  
    13621407
    13631408            //mov reg,r11
    1364             op_mov64_ToReg_FromReg(reg,REG_R11);
     1409            op_mov_RR(reg,REG_R11);
    13651410        }
    13661411        else{
    … …  
    14041449
    14051450            //mov reg,r11
    1406             op_mov64_ToReg_FromReg(reg,REG_R11);
     1451            op_mov_RR(reg,REG_R11);
    14071452        }
    14081453        else{
    14091454            //mov reg,rsp
    1410             op_mov64_ToReg_FromReg(reg,REG_RSP);
     1455            op_mov_RR(reg,REG_RSP);
    14111456
    14121457            //add reg,offset
    1413             op_add64_value(reg,(int)pRelativeVar->offset);
     1458            op_add_RV(reg,(int)pRelativeVar->offset);
    14141459            obp-=sizeof(long);
    14151460            AddLocalVarAddrSchedule();
    … …  
    14411486directmem:
    14421487        //mov reg,r11
    1443         op_mov64_ToReg_FromReg(reg,REG_R11);
     1488        op_mov_RR(reg,REG_R11);
    14441489    }
    14451490}
Note: See TracChangeset for help on using the changeset viewer.