Changeset 66 in dev


Ignore:
Timestamp:
Mar 9, 2007, 4:59:13 AM (17 years ago)
Author:
dai_9181
Message:

参照型の整数型パラメータに実数を代入すると「内部エラー」になってしまうバグを修正。
参照型の整数型にリテラル値を直接指定すると「内部エラー」になってしまうバグを修正。
バージョンをβ15にした。

Files:
15 edited

Legend:

Unmodified
Added
Removed

  • BasicCompiler32/CParameter.cpp

    r64 r66  
    6666                nCountOfTempObjects++;
    6767
    68                 if( type == DEF_OBJECT ){
     68                if( type != DEF_STRUCT ){
    6969                    //一時参照を作成
    7070
    … …  
    114114                op_call(pSub_free);
    115115            }
    116             else if( types[i2].type == DEF_OBJECT ){
    117                 op_pop( REG_NON );
    118                 op_pop( REG_NON );
    119             }
    120116            else{
    121                 SetError(300,NULL,cp);
    122             }
    123 
     117                if( Is64Type( types[i2].type ) ){
     118                    //pop ... 参照を消す
     119                    //pop ... 上位32ビット
     120                    //pop ... 下位32ビット
     121                    op_add_esp( PTR_SIZE * 3 );
     122                }
     123                else{
     124                    //pop ... 参照を消す
     125                    //pop ... 値を消す
     126                    op_add_esp( PTR_SIZE * 2 );
     127                }
     128            }
    124129        }
    125130    }
    … …  
    363368                    //一時オブジェクトをコピー
    364369
    365                     if( types[i2].type == DEF_OBJECT ){
     370                    if( types[i2].type != DEF_STRUCT ){
    366371                        // 一時参照のための領域を考慮する
    367372                        nCountOfNowTempObjects++;

  • BasicCompiler32/Compile_Calc.cpp

    r64 r66  
    223223
    224224        //fistp qword ptr[esp]
    225         fpu_cast();
    226         OpBuffer[obp++]=(char)0xDF;
    227         OpBuffer[obp++]=(char)0x3C;
    228         OpBuffer[obp++]=(char)0x24;
    229         fpu_cast_end();
     225        op_fistp_ptr_esp( sizeof(_int64) );
    230226    }
    231227    else if(OldType==DEF_SINGLE){
    … …  
    237233
    238234        //fistp qword ptr[esp]
    239         fpu_cast();
    240         OpBuffer[obp++]=(char)0xDF;
    241         OpBuffer[obp++]=(char)0x3C;
    242         OpBuffer[obp++]=(char)0x24;
    243         fpu_cast_end();
     235        op_fistp_ptr_esp( sizeof(_int64) );
    244236    }
    245237    else if(IsWholeNumberType(OldType)){
    … …  
    288280
    289281        //fistp dword ptr[esp]
    290         fpu_cast();
    291         OpBuffer[obp++]=(char)0xDB;
    292         OpBuffer[obp++]=(char)0x1C;
    293         OpBuffer[obp++]=(char)0x24;
    294         fpu_cast_end();
     282        op_fistp_ptr_esp( sizeof(long) );
    295283    }
    296284    else if(OldType==DEF_SINGLE){
    … …  
    299287
    300288        //fistp dword ptr[esp]
    301         fpu_cast();
    302         OpBuffer[obp++]=(char)0xDB;
    303         OpBuffer[obp++]=(char)0x1C;
    304         OpBuffer[obp++]=(char)0x24;
    305         fpu_cast_end();
     289        op_fistp_ptr_esp( sizeof(long) );
    306290    }
    307291    else if(OldType==DEF_INT64||OldType==DEF_QWORD){

  • BasicCompiler32/Compile_Calc_PushVar.cpp

    r62 r66  
    6666}
    6767void SetReg_WholeVariable(int type,RELATIVE_VAR *pRelativeVar,int reg){
    68     int var_size;
    69 
    70     var_size=GetTypeSize(type,-1);
    71 
    72     if(var_size==sizeof(_int64)){
     68    int varSize;
     69
     70    varSize=GetTypeSize(type,-1);
     71
     72    if(varSize==sizeof(_int64)){
    7373        //64ビットの場合はedx:eaxにロード
    7474        if(reg!=REG_EAX){
    … …  
    9191        if(pRelativeVar->bOffsetOffset){
    9292            //mov reg, ptr[ecx+offset]
    93             op_mov_RM(var_size,reg,REG_ECX,(int)pRelativeVar->offset,MOD_BASE_DISP32);
     93            op_mov_RM(varSize,reg,REG_ECX,(int)pRelativeVar->offset,MOD_BASE_DISP32);
    9494        }
    9595        else{
    9696            //mov reg, ptr[offset]
    97             op_mov_RM(var_size,reg,0,(int)pRelativeVar->offset,MOD_DISP32);
     97            op_mov_RM(varSize,reg,0,(int)pRelativeVar->offset,MOD_DISP32);
    9898        }
    9999        obp-=sizeof(long);
    … …  
    104104        if(pRelativeVar->bOffsetOffset){
    105105            //add ecx,qword ptr[offset]
    106             op_add_RM(var_size,REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);
     106            op_add_RM(varSize,REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);
    107107        }
    108108        else{
    109109            //mov ecx,qword ptr[offset]
    110             op_mov_RM(var_size,REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);
     110            op_mov_RM(varSize,REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);
    111111        }
    112112        obp-=sizeof(long);
    … …  
    119119        if(pRelativeVar->bOffsetOffset){
    120120            //mov reg, ptr[ebp+ecx+offset]
    121             op_mov_RM_ex(var_size,reg,REG_EBP,REG_ECX,(int)pRelativeVar->offset,USE_OFFSET);
     121            op_mov_RM_ex(varSize,reg,REG_EBP,REG_ECX,(int)pRelativeVar->offset,USE_OFFSET);
    122122        }
    123123        else{
    124124            //mov reg, ptr[ebp+offset]
    125             op_mov_RM(var_size,reg,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
     125            op_mov_RM(varSize,reg,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
    126126        }
    127127        obp-=sizeof(long);
    … …  
    132132        if(pRelativeVar->bOffsetOffset){
    133133            //add ecx,qword ptr[ebp+offset]
    134             op_add_RM(var_size,REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
     134            op_add_RM(varSize,REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
    135135        }
    136136        else{
    137137            //mov ecx,qword ptr[ebp+offset]
    138             op_mov_RM(var_size,REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
     138            op_mov_RM(varSize,REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
    139139        }
    140140        obp-=sizeof(long);
    … …  
    147147directmem:
    148148        //mov reg, ptr[ecx]
    149         op_mov_RM(var_size,reg,REG_ECX,0,MOD_BASE);
     149        op_mov_RM(varSize,reg,REG_ECX,0,MOD_BASE);
    150150    }
    151151}

  • BasicCompiler32/Compile_Set_Var.cpp

    r64 r66  
    274274}
    275275
    276 void SetWholeVariable(int var_size,int type,RELATIVE_VAR *pRelative){
    277     if(type==DEF_DOUBLE){
    278         //Double型
    279         // st(0)の内容をedx:eaxに変換
    280 
    281         //TODO: 実装
    282         SetError();
    283     }
    284     else if(type==DEF_SINGLE){
    285         //Single型
    286         // st(0)の内容をeaxに変換
    287 
    288         //TODO: 実装
    289         SetError();
     276void SetWholeVariable(int varSize,int calcType,RELATIVE_VAR *pRelative){
     277    if( IsRealNumberType( calcType ) ){
     278        // 実数型から整数型へ変換する
     279
     280        if( varSize == sizeof(_int64) ){
     281            // 64bitへ
     282            // st(0) -> edx:eax
     283            breakpoint;
     284
     285            //push
     286            //push
     287            op_sub_esp( PTR_SIZE * 2 );
     288
     289            //fistp qword ptr[esp]
     290            op_fistp_ptr_esp( sizeof(_int64) );
     291
     292            //pop eax
     293            op_pop( REG_EAX );
     294
     295            //pop edx
     296            op_pop( REG_EDX );
     297        }
     298        else{
     299            // 32bit
     300            // st(0) -> eax
     301
     302            //push
     303            op_push( REG_NON );
     304
     305            //fistp dword ptr[esp]
     306            op_fistp_ptr_esp( sizeof(long) );
     307
     308            //pop eax
     309            op_pop( REG_EAX );
     310        }
    290311    }
    291312    else{
    292313        //その他の整数
    293314
    294         if(var_size==sizeof(_int64)){
     315        if(varSize==sizeof(_int64)){
    295316            //eaxの値を64ビット（edx:eax）に拡張する
    296             ExtendTypeTo64(type);
    297         }
    298         else if(var_size==sizeof(long)){
     317            ExtendTypeTo64(calcType);
     318        }
     319        else if(varSize==sizeof(long)){
    299320            //レジスタの値を32ビット（eax）に拡張する
    300             ExtendTypeTo32(type,REG_EAX);
    301         }
    302         else if(var_size==sizeof(short)){
     321            ExtendTypeTo32(calcType,REG_EAX);
     322        }
     323        else if(varSize==sizeof(short)){
    303324            //レジスタの値を16ビット（ax）に拡張する
    304             ExtendTypeTo16(type,REG_EAX);
     325            ExtendTypeTo16(calcType,REG_EAX);
    305326        }
    306327        //8ビットは拡張なし
    307328    }
    308329
    309     if(var_size==sizeof(_int64)){
     330    if(varSize==sizeof(_int64)){
    310331        //下位32ビット
    311332        SetWholeVariable(sizeof(long),DEF_LONG,pRelative);
    312333
     334        //上位32ビット
     335
     336        //直接参照に切り替え
     337        SetVarPtrToEax(pRelative);
     338        pRelative->dwKind=VAR_DIRECTMEM;
     339
     340        //mov ecx,eax
     341        op_mov_RR( REG_ECX, REG_EAX );
     342
     343        //add ecx,sizeof(long)
     344        op_add_RV8( REG_ECX, sizeof(long) );
     345
    313346        //mov eax,edx
    314347        op_mov_RR( REG_EAX, REG_EDX );
    315348
    316         //上位32ビット
    317         if( pRelative->dwKind == VAR_DIRECTMEM ){
    318             //add ecx,sizeof(long)
    319             op_add_RV8( REG_ECX, sizeof(long) );
    320         }
    321         pRelative->offset+=sizeof(long);
    322349        SetWholeVariable(sizeof(long),DEF_LONG,pRelative);
    323         pRelative->offset-=sizeof(long);
    324350
    325351        return;
    … …  
    329355        if(pRelative->bOffsetOffset){
    330356            //mov ptr[ecx+offset],eax/ax/al
    331             op_mov_MR(var_size,REG_EAX,REG_ECX,(int)pRelative->offset,MOD_BASE_DISP32);
     357            op_mov_MR(varSize,REG_EAX,REG_ECX,(int)pRelative->offset,MOD_BASE_DISP32);
    332358        }
    333359        else{
    334360            //mov ptr[offset],eax/ax/al
    335             op_mov_MR(var_size,REG_EAX,0,(int)pRelative->offset,MOD_DISP32);
     361            op_mov_MR(varSize,REG_EAX,0,(int)pRelative->offset,MOD_DISP32);
    336362        }
    337363        obp-=sizeof(long);
    … …  
    342368        if(pRelative->bOffsetOffset){
    343369            //add ecx,qword ptr[offset]
    344             op_add_RM(var_size,REG_ECX,REG_NON,(int)pRelative->offset,MOD_DISP32);
     370            op_add_RM(varSize,REG_ECX,REG_NON,(int)pRelative->offset,MOD_DISP32);
    345371        }
    346372        else{
    347373            //mov ecx,qword ptr[offset]
    348             op_mov_RM(var_size,REG_ECX,REG_NON,(int)pRelative->offset,MOD_DISP32);
     374            op_mov_RM(varSize,REG_ECX,REG_NON,(int)pRelative->offset,MOD_DISP32);
    349375        }
    350376        obp-=sizeof(long);
    … …  
    357383        if(pRelative->bOffsetOffset){
    358384            //mov ptr[ebp+ecx+offset],eax/ax/al
    359             op_mov_MR_ex(var_size,REG_EAX,REG_EBP,REG_ECX,(int)pRelative->offset,USE_OFFSET);
     385            op_mov_MR_ex(varSize,REG_EAX,REG_EBP,REG_ECX,(int)pRelative->offset,USE_OFFSET);
    360386        }
    361387        else{
    362388            //mov ptr[ebp+offset],eax/ax/al
    363             op_mov_MR(var_size,REG_EAX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32);
     389            op_mov_MR(varSize,REG_EAX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32);
    364390        }
    365391        obp-=sizeof(long);
    … …  
    370396        if(pRelative->bOffsetOffset){
    371397            //add ecx,qword ptr[ebp+offset]
    372             op_add_RM(var_size,REG_ECX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32);
     398            op_add_RM(varSize,REG_ECX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32);
    373399        }
    374400        else{
    375401            //mov ecx,qword ptr[ebp+offset]
    376             op_mov_RM(var_size,REG_ECX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32);
     402            op_mov_RM(varSize,REG_ECX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32);
    377403        }
    378404        obp-=sizeof(long);
    … …  
    386412
    387413        //mov ptr[ecx],eax/ax/al
    388         op_mov_MR(var_size,REG_EAX,REG_ECX,0,MOD_BASE);
     414        op_mov_MR(varSize,REG_EAX,REG_ECX,0,MOD_BASE);
    389415    }
    390416}

  • BasicCompiler32/NumOpe_Arithmetic.cpp

    r3 r66  
    1111
    1212        //fistp qword ptr[esp]
    13         fpu_cast();
    14         OpBuffer[obp++]=(char)0xDF;
    15         OpBuffer[obp++]=(char)0x3C;
    16         OpBuffer[obp++]=(char)0x24;
    17         fpu_cast_end();
     13        op_fistp_ptr_esp( sizeof(_int64) );
    1814
    1915        //pop ebx
    … …  
    3127
    3228        //fistp qword ptr[esp]
    33         fpu_cast();
    34         OpBuffer[obp++]=(char)0xDF;
    35         OpBuffer[obp++]=(char)0x3C;
    36         OpBuffer[obp++]=(char)0x24;
    37         fpu_cast_end();
     29        op_fistp_ptr_esp( sizeof(_int64) );
    3830
    3931        //pop ebx
    … …  
    8476
    8577        //fistp qword ptr[esp]
    86         fpu_cast();
    87         OpBuffer[obp++]=(char)0xDF;
    88         OpBuffer[obp++]=(char)0x3C;
    89         OpBuffer[obp++]=(char)0x24;
    90         fpu_cast_end();
     78        op_fistp_ptr_esp( sizeof(_int64) );
    9179
    9280        //pop eax
    … …  
    10492
    10593        //fistp qword ptr[esp]
    106         fpu_cast();
    107         OpBuffer[obp++]=(char)0xDF;
    108         OpBuffer[obp++]=(char)0x3C;
    109         OpBuffer[obp++]=(char)0x24;
    110         fpu_cast_end();
     94        op_fistp_ptr_esp( sizeof(_int64) );
    11195
    11296        //pop eax
    … …  
    510494
    511495            //fistp dword ptr[esp]
    512             fpu_cast();
    513             OpBuffer[obp++]=(char)0xDB;
    514             OpBuffer[obp++]=(char)0x1C;
    515             OpBuffer[obp++]=(char)0x24;
    516             fpu_cast_end();
     496            op_fistp_ptr_esp( sizeof(long) );
    517497        }
    518498        else if(type[sp-1]==DEF_SINGLE){
    … …  
    521501
    522502            //fistp dword ptr[esp]
    523             fpu_cast();
    524             OpBuffer[obp++]=(char)0xDB;
    525             OpBuffer[obp++]=(char)0x1C;
    526             OpBuffer[obp++]=(char)0x24;
    527             fpu_cast_end();
     503            op_fistp_ptr_esp( sizeof(long) );
    528504        }
    529505
    … …  
    539515
    540516            //fistp dword ptr[esp]
    541             fpu_cast();
    542             OpBuffer[obp++]=(char)0xDB;
    543             OpBuffer[obp++]=(char)0x1C;
    544             OpBuffer[obp++]=(char)0x24;
    545             fpu_cast_end();
     517            op_fistp_ptr_esp( sizeof(long) );
    546518        }
    547519        else if(type[sp-2]==DEF_SINGLE){
    … …  
    550522
    551523            //fistp dword ptr[esp]
    552             fpu_cast();
    553             OpBuffer[obp++]=(char)0xDB;
    554             OpBuffer[obp++]=(char)0x1C;
    555             OpBuffer[obp++]=(char)0x24;
    556             fpu_cast_end();
     524            op_fistp_ptr_esp( sizeof(long) );
    557525        }
    558526
    … …  
    786754
    787755            //fistp dword ptr[esp]
    788             fpu_cast();
    789             OpBuffer[obp++]=(char)0xDB;
    790             OpBuffer[obp++]=(char)0x1C;
    791             OpBuffer[obp++]=(char)0x24;
    792             fpu_cast_end();
     756            op_fistp_ptr_esp( sizeof(long) );
    793757        }
    794758        else if(type[sp-1]==DEF_SINGLE){
    … …  
    797761
    798762            //fistp dword ptr[esp]
    799             fpu_cast();
    800             OpBuffer[obp++]=(char)0xDB;
    801             OpBuffer[obp++]=(char)0x1C;
    802             OpBuffer[obp++]=(char)0x24;
    803             fpu_cast_end();
     763            op_fistp_ptr_esp( sizeof(long) );
    804764        }
    805765
    … …  
    815775
    816776            //fistp dword ptr[esp]
    817             fpu_cast();
    818             OpBuffer[obp++]=(char)0xDB;
    819             OpBuffer[obp++]=(char)0x1C;
    820             OpBuffer[obp++]=(char)0x24;
    821             fpu_cast_end();
     777            op_fistp_ptr_esp( sizeof(long) );
    822778        }
    823779        else if(type[sp-2]==DEF_SINGLE){
    … …  
    826782
    827783            //fistp dword ptr[esp]
    828             fpu_cast();
    829             OpBuffer[obp++]=(char)0xDB;
    830             OpBuffer[obp++]=(char)0x1C;
    831             OpBuffer[obp++]=(char)0x24;
    832             fpu_cast_end();
     784            op_fistp_ptr_esp( sizeof(long) );
    833785        }
    834786
    … …  
    11191071
    11201072            //fistp dword ptr[esp]
    1121             fpu_cast();
    1122             OpBuffer[obp++]=(char)0xDB;
    1123             OpBuffer[obp++]=(char)0x1C;
    1124             OpBuffer[obp++]=(char)0x24;
    1125             fpu_cast_end();
     1073            op_fistp_ptr_esp( sizeof(long) );
    11261074
    11271075            //pop ecx
    … …  
    11331081
    11341082            //fistp dword ptr[esp]
    1135             fpu_cast();
    1136             OpBuffer[obp++]=(char)0xDB;
    1137             OpBuffer[obp++]=(char)0x1C;
    1138             OpBuffer[obp++]=(char)0x24;
    1139             fpu_cast_end();
     1083            op_fistp_ptr_esp( sizeof(long) );
    11401084
    11411085            //pop ecx
    … …  
    11601104
    11611105            //fistp qword ptr[esp]
    1162             fpu_cast();
    1163             OpBuffer[obp++]=(char)0xDF;
    1164             OpBuffer[obp++]=(char)0x3C;
    1165             OpBuffer[obp++]=(char)0x24;
    1166             fpu_cast_end();
     1106            op_fistp_ptr_esp( sizeof(_int64) );
    11671107
    11681108            //pop eax
    … …  
    11801120
    11811121            //fistp qword ptr[esp]
    1182             fpu_cast();
    1183             OpBuffer[obp++]=(char)0xDF;
    1184             OpBuffer[obp++]=(char)0x3C;
    1185             OpBuffer[obp++]=(char)0x24;
    1186             fpu_cast_end();
     1122            op_fistp_ptr_esp( sizeof(_int64) );
    11871123
    11881124            //pop eax
    … …  
    12451181
    12461182            //fistp dword ptr[esp]
    1247             fpu_cast();
    1248             OpBuffer[obp++]=(char)0xDB;
    1249             OpBuffer[obp++]=(char)0x1C;
    1250             OpBuffer[obp++]=(char)0x24;
    1251             fpu_cast_end();
     1183            op_fistp_ptr_esp( sizeof(long) );
    12521184
    12531185            //pop ecx
    … …  
    12591191
    12601192            //fistp dword ptr[esp]
    1261             fpu_cast();
    1262             OpBuffer[obp++]=(char)0xDB;
    1263             OpBuffer[obp++]=(char)0x1C;
    1264             OpBuffer[obp++]=(char)0x24;
    1265             fpu_cast_end();
     1193            op_fistp_ptr_esp( sizeof(long) );
    12661194
    12671195            //pop ecx
    … …  
    12881216
    12891217            //fistp dword ptr[esp]
    1290             fpu_cast();
    1291             OpBuffer[obp++]=(char)0xDB;
    1292             OpBuffer[obp++]=(char)0x1C;
    1293             OpBuffer[obp++]=(char)0x24;
    1294             fpu_cast_end();
     1218            op_fistp_ptr_esp( sizeof(long) );
    12951219        }
    12961220        else if(type[sp-2]==DEF_SINGLE){
    … …  
    12991223
    13001224            //fistp dword ptr[esp]
    1301             fpu_cast();
    1302             OpBuffer[obp++]=(char)0xDB;
    1303             OpBuffer[obp++]=(char)0x1C;
    1304             OpBuffer[obp++]=(char)0x24;
    1305             fpu_cast_end();
     1225            op_fistp_ptr_esp( sizeof(long) );
    13061226        }
    13071227
    … …  
    13531273
    13541274            //fistp dword ptr[esp]
    1355             fpu_cast();
    1356             OpBuffer[obp++]=(char)0xDB;
    1357             OpBuffer[obp++]=(char)0x1C;
    1358             OpBuffer[obp++]=(char)0x24;
    1359             fpu_cast_end();
     1275            op_fistp_ptr_esp( sizeof(long) );
    13601276
    13611277            //pop ecx
    … …  
    13671283
    13681284            //fistp dword ptr[esp]
    1369             fpu_cast();
    1370             OpBuffer[obp++]=(char)0xDB;
    1371             OpBuffer[obp++]=(char)0x1C;
    1372             OpBuffer[obp++]=(char)0x24;
    1373             fpu_cast_end();
     1285            op_fistp_ptr_esp( sizeof(long) );
    13741286
    13751287            //pop ecx
    … …  
    13941306
    13951307            //fistp qword ptr[esp]
    1396             fpu_cast();
    1397             OpBuffer[obp++]=(char)0xDF;
    1398             OpBuffer[obp++]=(char)0x3C;
    1399             OpBuffer[obp++]=(char)0x24;
    1400             fpu_cast_end();
     1308            op_fistp_ptr_esp( sizeof(_int64) );
    14011309
    14021310            //pop eax
    … …  
    14141322
    14151323            //fistp qword ptr[esp]
    1416             fpu_cast();
    1417             OpBuffer[obp++]=(char)0xDF;
    1418             OpBuffer[obp++]=(char)0x3C;
    1419             OpBuffer[obp++]=(char)0x24;
    1420             fpu_cast_end();
     1324            op_fistp_ptr_esp( sizeof(_int64) );
    14211325
    14221326            //pop eax
    … …  
    14901394
    14911395            //fistp dword ptr[esp]
    1492             fpu_cast();
    1493             OpBuffer[obp++]=(char)0xDB;
    1494             OpBuffer[obp++]=(char)0x1C;
    1495             OpBuffer[obp++]=(char)0x24;
    1496             fpu_cast_end();
     1396            op_fistp_ptr_esp( sizeof(long) );
    14971397
    14981398            //pop ecx
    … …  
    15041404
    15051405            //fistp dword ptr[esp]
    1506             fpu_cast();
    1507             OpBuffer[obp++]=(char)0xDB;
    1508             OpBuffer[obp++]=(char)0x1C;
    1509             OpBuffer[obp++]=(char)0x24;
    1510             fpu_cast_end();
     1406            op_fistp_ptr_esp( sizeof(long) );
    15111407
    15121408            //pop ecx
    … …  
    15331429
    15341430            //fistp dword ptr[esp]
    1535             fpu_cast();
    1536             OpBuffer[obp++]=(char)0xDB;
    1537             OpBuffer[obp++]=(char)0x1C;
    1538             OpBuffer[obp++]=(char)0x24;
    1539             fpu_cast_end();
     1431            op_fistp_ptr_esp( sizeof(long) );
    15401432        }
    15411433        else if(type[sp-2]==DEF_SINGLE){
    … …  
    15441436
    15451437            //fistp dword ptr[esp]
    1546             fpu_cast();
    1547             OpBuffer[obp++]=(char)0xDB;
    1548             OpBuffer[obp++]=(char)0x1C;
    1549             OpBuffer[obp++]=(char)0x24;
    1550             fpu_cast_end();
     1438            op_fistp_ptr_esp( sizeof(long) );
    15511439        }
    15521440

  • BasicCompiler32/NumOpe_TypeOperation.cpp

    r55 r66  
    147147
    148148            //fistp qword ptr[esp]
    149             fpu_cast();
    150             OpBuffer[obp++]=(char)0xDF;
    151             OpBuffer[obp++]=(char)0x3C;
    152             OpBuffer[obp++]=(char)0x24;
    153             fpu_cast_end();
     149            op_fistp_ptr_esp( sizeof(_int64) );
    154150        }
    155151        else{
    … …  
    161157
    162158            //fistp dword ptr[esp]
    163             fpu_cast();
    164             OpBuffer[obp++]=(char)0xDB;
    165             OpBuffer[obp++]=(char)0x1C;
    166             OpBuffer[obp++]=(char)0x24;
    167             fpu_cast_end();
     159            op_fistp_ptr_esp( sizeof(long) );
    168160        }
    169161    }
    … …  
    177169
    178170            //fistp qword ptr[esp]
    179             fpu_cast();
    180             OpBuffer[obp++]=(char)0xDF;
    181             OpBuffer[obp++]=(char)0x3C;
    182             OpBuffer[obp++]=(char)0x24;
    183             fpu_cast_end();
     171            op_fistp_ptr_esp( sizeof(_int64) );
    184172        }
    185173        else{
    … …  
    188176
    189177            //fistp dword ptr[esp]
    190             fpu_cast();
    191             OpBuffer[obp++]=(char)0xDB;
    192             OpBuffer[obp++]=(char)0x1C;
    193             OpBuffer[obp++]=(char)0x24;
    194             fpu_cast_end();
     178            op_fistp_ptr_esp( sizeof(long) );
    195179        }
    196180    }

  • BasicCompiler32/Opcode.h

    r64 r66  
    138138void SetStructVariable(LONG_PTR lpVarIndex,int CalcType,LONG_PTR lpCalcIndex,BOOL bUseHeap);
    139139void SetRealVariable(int VarType, int CalcType, RELATIVE_VAR *pRelativeVar);
    140 void SetWholeVariable(int var_size,int type,RELATIVE_VAR *pRelative);
     140void SetWholeVariable( int varSize,int calcType, RELATIVE_VAR *pRelative );
    141141
    142142void SetDoubleVariable(int type,DWORD VarKind,DWORD offset,BOOL bOffsetOffset);
    … …  
    179179
    180180//Compile_Var.cpp
     181void SetRelativeOffset( RELATIVE_VAR &relativeVar );
    181182void GetWithName(char *buffer);
    182183void SetThisPtrToReg(int reg);
    … …  
    333334void op_fstp_base_offset    (int type,int base_reg,int offset);
    334335void op_fstp_base_offset_ex (int type,int base_reg1,int base_reg2,int offset,BOOL bUseOffset);
     336void op_fistp_ptr_esp       ( int typeSize );
    335337void op_zero_reg(int reg);
    336338void fpu_cast();

  • BasicCompiler32/op32_main.cpp

    r64 r66  
    838838        //ベースレジスタ
    839839        OpBuffer[obp++]=(char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2));
     840    }
     841}
     842void op_fistp_ptr_esp( int typeSize ){
     843    if( typeSize == sizeof(_int64) ){
     844        //64bit
     845
     846        //fistp qword ptr[esp]
     847        fpu_cast();
     848        OpBuffer[obp++]=(char)0xDF;
     849        OpBuffer[obp++]=(char)0x3C;
     850        OpBuffer[obp++]=(char)0x24;
     851        fpu_cast_end();
     852    }
     853    else if( typeSize == sizeof(long) ){
     854        //32bit
     855
     856        //fistp dword ptr[esp]
     857        fpu_cast();
     858        OpBuffer[obp++]=(char)0xDB;
     859        OpBuffer[obp++]=(char)0x1C;
     860        OpBuffer[obp++]=(char)0x24;
     861        fpu_cast_end();
     862    }
     863    else{
     864        SetError();
    840865    }
    841866}

  • BasicCompiler64/CParameter.cpp

    r64 r66  
    6262                int type = NumOpe( &reg, Parms[i2], DummyTypeInfo.type, DummyTypeInfo.u.lpIndex, &lpVarIndex );
    6363
    64                 if( type == DEF_OBJECT ){
     64                if( type != DEF_STRUCT ){
    6565                    //一時参照を作成
    6666                    pobj_sf->push( reg );
    … …  
    115115                op_call(pSub_free);
    116116            }
    117             else if( types[i2].type == DEF_OBJECT ){
     117            else{
    118118                pobj_sf->pop();
    119119                pobj_sf->pop();
    120             }
    121             else{
    122                 SetError(300,NULL,cp);
    123120            }
    124121        }
    … …  
    423420            }
    424421            else{
    425                 //変数のアドレスを取得
    426                 int VarType;
    427                 LONG_PTR lpVarIndex;
    428                 if(GetVarOffset(
    429                     false,
    430                     false,
    431                     Parms[i2],
    432                     &VarType,
    433                     &RelativeVar,
    434                     &lpVarIndex)){
    435 
    436                         if(DummyTypeInfo.type!=DEF_ANY){
    437                             //型チェックを行う
    438                             if(DummyTypeInfo.type==VarType){
    439                                 if(DummyTypeInfo.type==DEF_OBJECT){
    440                                     if( !DummyTypeInfo.u.pobj_Class->IsEqualsOrSubClass( (CClass *)lpVarIndex ) ){
    441                                         SetError(11,Parms[i2],cp);
     422                if( useTempParameters[i2] ){
     423                    //一時オブジェクトをコピー
     424
     425                    //mov reg, qword ptr[rsp+offset]
     426                    pobj_sf->ref_offset_data( reg, StackOffsetOfTempObject[i2] );
     427                }
     428                else{
     429                    //変数のアドレスを取得
     430                    int VarType;
     431                    LONG_PTR lpVarIndex;
     432                    if(GetVarOffset(
     433                        false,
     434                        false,
     435                        Parms[i2],
     436                        &VarType,
     437                        &RelativeVar,
     438                        &lpVarIndex)){
     439
     440                            if(DummyTypeInfo.type!=DEF_ANY){
     441                                //型チェックを行う
     442                                if(DummyTypeInfo.type==VarType){
     443                                    if(DummyTypeInfo.type==DEF_OBJECT){
     444                                        if( !DummyTypeInfo.u.pobj_Class->IsEqualsOrSubClass( (CClass *)lpVarIndex ) ){
     445                                            SetError(11,Parms[i2],cp);
     446                                        }
     447                                    }
     448                                    else if(DummyTypeInfo.type==DEF_STRUCT){
     449                                        if( !DummyTypeInfo.u.pobj_Class->IsEquals( (CClass *)lpVarIndex ) ){
     450                                            SetError(11,Parms[i2],cp);
     451                                        }
    442452                                    }
    443453                                }
    444                                 else if(DummyTypeInfo.type==DEF_STRUCT){
    445                                     if( !DummyTypeInfo.u.pobj_Class->IsEquals( (CClass *)lpVarIndex ) ){
    446                                         SetError(11,Parms[i2],cp);
    447                                     }
     454                                else if((VarType&FLAG_PTR)&&((VarType^FLAG_PTR)==DummyTypeInfo.type)){
     455                                    //仮引数がポインタ参照で、実引数が配列の先頭ポインタのとき
     456                                }
     457                                else{
     458                                    SetError(11,Parms[i2],cp);
    448459                                }
    449460                            }
    450                             else if((VarType&FLAG_PTR)&&((VarType^FLAG_PTR)==DummyTypeInfo.type)){
    451                                 //仮引数がポインタ参照で、実引数が配列の先頭ポインタのとき
    452                             }
    453                             else{
    454                                 SetError(11,Parms[i2],cp);
    455                             }
    456                         }
    457 
    458                         //変数アドレスをレジスタにセット
    459                         SetVarPtrToReg(reg,&RelativeVar);
    460 
    461                 }
    462                 else{
    463                     //一時オブジェクトをコピー
    464 
    465                     //mov reg, qword ptr[rsp+offset]
    466                     pobj_sf->ref_offset_data( reg, StackOffsetOfTempObject[i2] );
    467 
    468                     //VarType = NumOpe( &reg, Parms[i2], DummyTypeInfo.type, DummyTypeInfo.u.lpIndex, &lpVarIndex );
     461
     462                            //変数アドレスをレジスタにセット
     463                            SetVarPtrToReg(reg,&RelativeVar);
     464
     465                    }
    469466                }
    470467            }

  • BasicCompiler64/Compile_Calc_PushVar.cpp

    r62 r66  
    174174
    175175void SetReg_WholeVariable(int type,RELATIVE_VAR *pRelativeVar,int reg){
    176     int var_size;
    177 
    178     var_size=GetTypeSize(type,-1);
     176    int varSize;
     177
     178    varSize=GetTypeSize(type,-1);
    179179
    180180    if(pRelativeVar->dwKind==VAR_GLOBAL){
    181181        if(pRelativeVar->bOffsetOffset){
    182182            //mov reg, ptr[r11+offset]
    183             op_mov_RM(var_size,reg,REG_R11,(int)pRelativeVar->offset,MOD_BASE_DISP32);
     183            op_mov_RM(varSize,reg,REG_R11,(int)pRelativeVar->offset,MOD_BASE_DISP32);
    184184            obp-=sizeof(long);
    185185            pobj_GlobalVarSchedule->add();
    … …  
    188188        else{
    189189            //mov reg, ptr[offset]
    190             op_mov_RM(var_size,reg,0,(int)pRelativeVar->offset,MOD_DISP32);
     190            op_mov_RM(varSize,reg,0,(int)pRelativeVar->offset,MOD_DISP32);
    191191            obp-=sizeof(long);
    192192            pobj_GlobalVarSchedule->add();
    … …  
    215215        if(pRelativeVar->bOffsetOffset){
    216216            //mov reg, ptr[rsp+r11+offset]
    217             op_mov_RM_ex(var_size,reg,REG_RSP,REG_R11,(int)pRelativeVar->offset,USE_OFFSET);
     217            op_mov_RM_ex(varSize,reg,REG_RSP,REG_R11,(int)pRelativeVar->offset,USE_OFFSET);
    218218            obp-=sizeof(long);
    219219            AddLocalVarAddrSchedule();
    … …  
    222222        else{
    223223            //mov reg, ptr[rsp+offset]
    224             op_mov_RM(var_size,reg,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
     224            op_mov_RM(varSize,reg,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
    225225            obp-=sizeof(long);
    226226            AddLocalVarAddrSchedule();
    … …  
    249249directmem:
    250250        //mov reg, ptr[r11]
    251         op_mov_RM(var_size,reg,REG_R11,0,MOD_BASE);
     251        op_mov_RM(varSize,reg,REG_R11,0,MOD_BASE);
    252252    }
    253253}

  • BasicCompiler64/Compile_Set_Var.cpp

    r64 r66  
    333333    SetWholeVariable( sizeof(char), DEF_BYTE, pRelative);
    334334}
    335 void SetWholeVariable(int var_size,int type,RELATIVE_VAR *pRelative){
     335void SetWholeVariable(int varSize,int type,RELATIVE_VAR *pRelative){
    336336    if(type==DEF_DOUBLE){
    337337        //Double型
    … …  
    349349        //その他の整数
    350350
    351         if(var_size==sizeof(_int64)){
     351        if(varSize==sizeof(_int64)){
    352352            //レジスタの値を64ビット（rax）に拡張する
    353353            ExtendTypeTo64(type,REG_RAX);
    354354        }
    355         else if(var_size==sizeof(long)){
     355        else if(varSize==sizeof(long)){
    356356            //レジスタの値を32ビット（eax）に拡張する
    357357            ExtendTypeTo32(type,REG_RAX);
    358358        }
    359         else if(var_size==sizeof(short)){
     359        else if(varSize==sizeof(short)){
    360360            //レジスタの値を16ビット（ax）に拡張する
    361361            ExtendTypeTo16(type,REG_RAX);
    … …  
    367367        if(pRelative->bOffsetOffset){
    368368            //mov ptr[r11+offset],rax/eax/ax/al
    369             op_mov_MR(var_size,REG_RAX,REG_R11,(int)pRelative->offset,MOD_BASE_DISP32);
     369            op_mov_MR(varSize,REG_RAX,REG_R11,(int)pRelative->offset,MOD_BASE_DISP32);
    370370            obp-=sizeof(long);
    371371            pobj_GlobalVarSchedule->add();
    … …  
    374374        else{
    375375            //mov ptr[offset],rax/eax/ax/al
    376             op_mov_MR(var_size,REG_RAX,0,(int)pRelative->offset,MOD_DISP32);
     376            op_mov_MR(varSize,REG_RAX,0,(int)pRelative->offset,MOD_DISP32);
    377377            obp-=sizeof(long);
    378378            pobj_GlobalVarSchedule->add();
    … …  
    401401        if(pRelative->bOffsetOffset){
    402402            //mov ptr[rsp+r11+offset],rax/eax/ax/al
    403             op_mov_MR_ex(var_size,REG_RAX,REG_RSP,REG_R11,(int)pRelative->offset,USE_OFFSET);
     403            op_mov_MR_ex(varSize,REG_RAX,REG_RSP,REG_R11,(int)pRelative->offset,USE_OFFSET);
    404404            obp-=sizeof(long);
    405405            AddLocalVarAddrSchedule();
    … …  
    408408        else{
    409409            //mov ptr[rsp+offset],rax/eax/ax/al
    410             op_mov_MR(var_size,REG_RAX,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32);
     410            op_mov_MR(varSize,REG_RAX,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32);
    411411            obp-=sizeof(long);
    412412            AddLocalVarAddrSchedule();
    … …  
    436436
    437437        //mov ptr[r11],rax/eax/ax/al
    438         op_mov_MR(var_size,REG_RAX,REG_R11,0,MOD_BASE);
    439     }
    440 }
     438        op_mov_MR(varSize,REG_RAX,REG_R11,0,MOD_BASE);
     439    }
     440}

  • BasicCompiler64/Opcode.h

    r64 r66  
    128128    void mov_sp( int reg );
    129129    int push(int reg);
    130     void push(int xmm_reg,int var_size);
     130    void push(int xmm_reg,int varSize);
    131131    void ref_offset_data( int reg, int sp_offset );
    132132    void ref(int reg);
    133     void ref(int xmm_reg,int var_size);
     133    void ref(int xmm_reg,int varSize);
    134134    void pop(int reg = REG_NON);
    135     void pop(int xmm_reg,int var_size);
     135    void pop(int xmm_reg,int varSize);
    136136    void parameter_allocate(int size);
    137137    void RunningSchedule(void);
    … …  
    289289void SetRealVariable(int VarType, int CalcType, RELATIVE_VAR *pRelativeVar);
    290290void SetBooleanVariable(int type,RELATIVE_VAR *pRelative);
    291 void SetWholeVariable(int var_size,int type,RELATIVE_VAR *pRelative);
     291void SetWholeVariable(int varSize,int type,RELATIVE_VAR *pRelative);
    292292
    293293//increment.cpp

  • BasicCompiler64/stack_frame.cpp

    r64 r66  
    7070    return now_sp;
    7171}
    72 void CStackFrame::push(int xmm_reg,int var_size){
     72void CStackFrame::push(int xmm_reg,int varSize){
    7373    now_sp-=sizeof(_int64);
    7474    if(lowest_sp>now_sp) lowest_sp=now_sp;
    7575
    76     if(var_size==sizeof(double)){
     76    if(varSize==sizeof(double)){
    7777        //movlpd qword ptr[rsp+offset],xmm_reg
    7878        op_movlpd_MR(xmm_reg,REG_RSP,now_sp,MOD_BASE_DISP32);
    7979    }
    80     if(var_size==sizeof(float)){
     80    if(varSize==sizeof(float)){
    8181        //movss dword ptr[rsp+offset],xmm_reg
    8282        OpBuffer[obp++]=(char)0xF3;
    … …  
    106106    ref_offset_data( reg, now_sp );
    107107}
    108 void CStackFrame::ref(int xmm_reg,int var_size){
    109     if(var_size==sizeof(double)){
     108void CStackFrame::ref(int xmm_reg,int varSize){
     109    if(varSize==sizeof(double)){
    110110        //movlpd xmm_reg,qword ptr[rsp+offset]
    111111        op_movlpd_RM(xmm_reg,REG_RSP,now_sp,MOD_BASE_DISP32);
    112112    }
    113     if(var_size==sizeof(float)){
     113    if(varSize==sizeof(float)){
    114114        //movss xmm_reg,dword ptr[rsp+offset]
    115115        OpBuffer[obp++]=(char)0xF3;
    … …  
    132132    now_sp+=sizeof(_int64);
    133133}
    134 void CStackFrame::pop(int xmm_reg,int var_size){
    135     ref(xmm_reg,var_size);
     134void CStackFrame::pop(int xmm_reg,int varSize){
     135    ref(xmm_reg,varSize);
    136136
    137137    now_sp+=sizeof(_int64);

  • BasicCompiler_Common/common.h

    r65 r66  
    4343
    4444#ifdef _AMD64_
    45 #define VER_INFO        "β14 (x64)"
     45#define VER_INFO        "β15 (x64)"
    4646#else
    47 #define VER_INFO        "β14"
     47#define VER_INFO        "β15"
    4848#endif
    4949

  • ProjectEditor/Common.h

    r65 r66  
    5959#define APPLICATION_NAME "ActiveBasic 5.0"
    6060#define VERSION_APPLI_NAME APPLICATION_NAME
    61 #define VERSION_STRING "5.00.00 β14"
     61#define VERSION_STRING "5.00.00 β15"
    6262
    6363#endif
Note: See TracChangeset for help on using the changeset viewer.