Changeset 19 in dev for BasicCompiler64


Ignore:
Timestamp:
Dec 26, 2006, 8:17:10 AM (18 years ago)
Author:
dai_9181
Message:

64ビットコンパイラでローカル変数の0初期化に対応。
raxまたはrdxを一時保存レジスタとして利用する際に、Mod演算子、\演算子が正常に動作しないバグを修正。

Location:
BasicCompiler64
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • BasicCompiler64/Compile_CallProc.cpp

    r18 r19  
    511511        Call_DebugSys_SaveContext();
    512512
    513     pdi->bUse=1;
    514513
    515514
    … …  
    539538
    540539    //call dword ptr[ImportTable]
    541     OpBuffer[obp++]=(char)0xFF;
    542     OpBuffer[obp++]=(char)0x15;
    543     pobj_ImportAddrSchedule->add(pdi);
    544     obp+=sizeof(long);
     540    op_call( pdi );
    545541
    546542    /* 64コンパイラでは不要

  • BasicCompiler64/Compile_ProcOp.cpp

    r18 r19  
    617617            }
    618618        }
    619         if(psi->name[0]=='~'){
     619        else if(psi->name[0]=='~'){
    620620            //デストラクタをコンパイルしたとき
    621621
    … …  
    646646            pobj_CompilingClass->NotifyFinishConstructorCompile();
    647647        }
    648 
    649         if(psi->name[0]=='~'){
     648        else if(psi->name[0]=='~'){
    650649            ////////////////////////////////////
    651650            //デストラクタをコンパイルしたとき

  • BasicCompiler64/Compile_Var.cpp

    r18 r19  
    11811181            }
    11821182            else{
    1183                 //0初期化未完成
     1183                //0初期化
     1184
     1185                //mov r8, 0
     1186                op_zero_reg( REG_R8 );
     1187
     1188                //mov rdx, VarSize
     1189                op_mov_RV( sizeof(_int64), REG_RDX, VarSize );
     1190
     1191                //mov rcx, rsp
     1192                op_mov_RR( REG_RCX, REG_RSP );
     1193
     1194                //add rcx, offset
     1195                op_add64_value( REG_RCX, -pVar->offset );
     1196                obp-=sizeof(long);
     1197                AddLocalVarAddrSchedule();
     1198                obp+=sizeof(long);
     1199
     1200                //call FillMemory
     1201                DECLAREINFO *pdi;
     1202                pdi=GetDeclareHash("FillMemory");
     1203                op_call( pdi );
    11841204            }
    11851205        }

  • BasicCompiler64/NumOpe.cpp

    r15 r19  
    566566                            SetUseRegFromRax(RetTypeInfo.type,UseReg,XmmReg);
    567567
    568                             if(IsRealNumberType(i2)) bXmm=1;
     568                            if(IsRealNumberType(type[sp])) bXmm=1;
    569569                            else bXmm=0;
    570570

  • BasicCompiler64/NumOpe_Arithmetic.cpp

    r3 r19  
    11#include "../BasicCompiler_Common/common.h"
    22#include "Opcode.h"
    3 
    4 void GetStackData_ToRegister(int *type,int sp){
    5     /*NumOpeポーランドのスタック蓄積による演算内容（2つのデータ）を
    6         レジスタedx:eax、ecx:ebxに取得する*/
    7 
    8     if(type[sp-1]==DEF_DOUBLE){
    9         //fld qword ptr[esp]
    10         op_fld_ptr_esp(DEF_DOUBLE);
    11 
    12         //fistp qword ptr[esp]
    13         OpBuffer[obp++]=(char)0xDF;
    14         OpBuffer[obp++]=(char)0x3C;
    15         OpBuffer[obp++]=(char)0x24;
    16 
    17         //pop ebx
    18         op_pop(REG_EBX);
    19 
    20         //pop ecx
    21         op_pop(REG_ECX);
    22     }
    23     else if(type[sp-1]==DEF_SINGLE){
    24         //fld dword ptr[esp]
    25         op_fld_ptr_esp(DEF_SINGLE);
    26 
    27         //sub esp,4
    28         op_sub_esp(4);
    29 
    30         //fistp qword ptr[esp]
    31         OpBuffer[obp++]=(char)0xDF;
    32         OpBuffer[obp++]=(char)0x3C;
    33         OpBuffer[obp++]=(char)0x24;
    34 
    35         //pop ebx
    36         op_pop(REG_EBX);
    37 
    38         //pop ecx
    39         op_pop(REG_ECX);
    40     }
    41     else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
    42         //pop ebx
    43         op_pop(REG_EBX);
    44 
    45         //pop ecx
    46         op_pop(REG_ECX);
    47     }
    48     else{
    49         //pop eax
    50         op_pop(REG_EAX);
    51 
    52         if(IsSignedType(type[sp-1])){
    53             //符号拡張
    54             //edx:eax ← eax
    55                
    56             //cdq
    57             OpBuffer[obp++]=(char)0x99;
    58         }
    59         else{
    60             //ビット拡張
    61             //edx:eax ← eax
    62 
    63             //xor rdx,rdx
    64             op_zero_reg(REG_RDX);
    65         }
    66 
    67         //mov ebx,eax
    68         OpBuffer[obp++]=(char)0x8B;
    69         OpBuffer[obp++]=(char)0xD8;
    70 
    71         //mov ecx,edx
    72         OpBuffer[obp++]=(char)0x8B;
    73         OpBuffer[obp++]=(char)0xCA;
    74     }
    75 
    76     //第1項を64ビットに対応させる
    77     if(type[sp-2]==DEF_DOUBLE){
    78         //fld qword ptr[esp]
    79         op_fld_ptr_esp(DEF_DOUBLE);
    80 
    81         //fistp qword ptr[esp]
    82         OpBuffer[obp++]=(char)0xDF;
    83         OpBuffer[obp++]=(char)0x3C;
    84         OpBuffer[obp++]=(char)0x24;
    85 
    86         //pop eax
    87         op_pop(REG_EAX);
    88 
    89         //pop edx
    90         op_pop(REG_EDX);
    91     }
    92     else if(type[sp-2]==DEF_SINGLE){
    93         //fld dword ptr[esp]
    94         op_fld_ptr_esp(DEF_SINGLE);
    95 
    96         //sub esp,4
    97         op_sub_esp(4);
    98 
    99         //fistp qword ptr[esp]
    100         OpBuffer[obp++]=(char)0xDF;
    101         OpBuffer[obp++]=(char)0x3C;
    102         OpBuffer[obp++]=(char)0x24;
    103 
    104         //pop eax
    105         op_pop(REG_EAX);
    106 
    107         //pop edx
    108         op_pop(REG_EDX);
    109     }
    110     else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
    111         //pop eax
    112         op_pop(REG_EAX);
    113 
    114         //pop edx
    115         op_pop(REG_EDX);
    116     }
    117     else{
    118         //pop eax
    119         op_pop(REG_EAX);
    120 
    121         if(IsSignedType(type[sp-2])){
    122             //符号拡張
    123             //edx:eax ← eax
    124                
    125             //cdq
    126             OpBuffer[obp++]=(char)0x99;
    127         }
    128         else{
    129             //ビット拡張
    130             //edx:eax ← eax
    131 
    132             //xor rdx,rdx
    133             op_zero_reg(REG_RDX);
    134         }
    135     }
    136 }
    1373
    1384BOOL CalcTwoTerm_Arithmetic(int idCalc,int *type,LONG_PTR *index_stack,int *pStackPointer){
    … …  
    316182    }
    317183
    318     //mov qword ptr[rsp+offset],rax     ※スタックフレームを利用
    319     pobj_sf->push(REG_RAX);
    320 
    321     if(reg1!=REG_RDX){
     184    //raxまたはrdxが使用中かどうかを調べる( true/使用中, false/未使用 )
     185    bool isUsingRax = pobj_reg->IsUsing( REG_RAX );
     186    bool isUsingRdx = pobj_reg->IsUsing( REG_RDX );
     187
     188    if(reg1!=REG_RDX && isUsingRdx){
     189        //結果レジスタがrdxでない場合（使用されている可能性があるとき）
     190
    322191        //mov qword ptr[rsp+offset],rdx     ※スタックフレームを利用
    323192        pobj_sf->push(REG_RDX);
    324193    }
    325194
    326     //mov rax,reg1
    327     op_mov64_ToReg_FromReg(REG_RAX,reg1);
    328 
    329     if(IsSignedType(type[sp-2])){
    330         //符号拡張
    331         //rdx:rax ← rax
    332 
    333         //cqo
    334         OpBuffer[obp++]=(char)0x48;
    335         OpBuffer[obp++]=(char)0x99;
    336     }
    337     else{
    338         //ビット拡張
    339         //rdx:rax ← rax
    340 
    341         //xor rdx,rdx
    342         op_zero_reg(REG_RDX);
    343     }
    344 
    345     if(IsSignedType(AnswerType)){
    346         //idiv reg2
    347         op_idiv64_reg(reg2);
    348     }
    349     else{
    350         //div reg2
    351         op_div64_reg(reg2);
    352     }
    353 
    354     //mov rax,qword ptr[rsp+offset]     ※スタックフレームを利用
    355     pobj_sf->pop(REG_RAX);
    356 
    357     //mov reg1,rdx
    358     op_mov64_ToReg_FromReg(reg1,REG_RDX);
    359 
    360     if(reg1!=REG_RDX){
     195    if(reg1!=REG_RAX && isUsingRax){
     196        //結果レジスタがraxでない場合（使用されている可能性があるとき）
     197
     198        //mov qword ptr[rsp+offset],rax     ※スタックフレームを利用
     199        pobj_sf->push(REG_RAX);
     200    }
     201
     202    {
     203
     204        //mov rax,reg1
     205        op_mov64_ToReg_FromReg(REG_RAX,reg1);
     206
     207        if(IsSignedType(type[sp-2])){
     208            //符号拡張
     209            //rdx:rax ← rax
     210
     211            //cqo
     212            OpBuffer[obp++]=(char)0x48;
     213            OpBuffer[obp++]=(char)0x99;
     214        }
     215        else{
     216            //ビット拡張
     217            //rdx:rax ← rax
     218
     219            //xor rdx,rdx
     220            op_zero_reg(REG_RDX);
     221        }
     222
     223        if(IsSignedType(AnswerType)){
     224            //idiv reg2
     225            op_idiv64_reg(reg2);
     226        }
     227        else{
     228            //div reg2
     229            op_div64_reg(reg2);
     230        }
     231
     232        //mov reg1,rdx
     233        op_mov64_ToReg_FromReg(reg1,REG_RDX);
     234
     235    }
     236
     237    if(reg1!=REG_RAX && isUsingRax){
     238        //結果レジスタがraxでない場合（使用されている可能性があるとき）
     239
     240        //mov rax,qword ptr[rsp+offset]     ※スタックフレームを利用
     241        pobj_sf->pop(REG_RAX);
     242    }
     243
     244    if(reg1!=REG_RDX && isUsingRdx){
     245        //結果レジスタがrdxでない場合（使用されている可能性があるとき）
     246
    361247        //mov rdx,qword ptr[rsp+offset]     ※スタックフレームを利用
    362248        pobj_sf->pop(REG_RDX);
    363249    }
     250
    364251
    365252    if(reg1==REG_R14){
    … …  
    471358    }
    472359
    473     //mov qword ptr[rsp+offset],rdx     ※スタックフレームを利用
    474     pobj_sf->push(REG_RDX);
    475 
    476     if(reg1!=REG_RAX){
     360    //raxまたはrdxが使用中かどうかを調べる( true/使用中, false/未使用 )
     361    bool isUsingRax = pobj_reg->IsUsing( REG_RAX );
     362    bool isUsingRdx = pobj_reg->IsUsing( REG_RDX );
     363
     364    if(reg1!=REG_RDX && isUsingRdx){
     365        //結果レジスタがrdxでない場合（使用されている可能性があるとき）
     366
     367        //mov qword ptr[rsp+offset],rdx     ※スタックフレームを利用
     368        pobj_sf->push(REG_RDX);
     369    }
     370
     371    if(reg1!=REG_RAX && isUsingRax){
     372        //結果レジスタがraxでない場合（使用されている可能性があるとき）
     373
    477374        //mov qword ptr[rsp+offset],rax     ※スタックフレームを利用
    478375        pobj_sf->push(REG_RAX);
    479376    }
    480377
    481     //mov rax,reg1
    482     op_mov64_ToReg_FromReg(REG_RAX,reg1);
    483 
    484     if(IsSignedType(type[sp-2])){
    485         //符号拡張
    486         //rdx:rax ← rax
    487 
    488         //cqo
    489         OpBuffer[obp++]=(char)0x48;
    490         OpBuffer[obp++]=(char)0x99;
    491     }
    492     else{
    493         //ビット拡張
    494         //rdx:rax ← rax
    495 
    496         //xor rdx,rdx
    497         op_zero_reg(REG_RDX);
    498     }
    499 
    500     if(IsSignedType(AnswerType)){
    501         //idiv reg2
    502         op_idiv64_reg(reg2);
    503     }
    504     else{
    505         //div reg2
    506         op_div64_reg(reg2);
    507     }
    508 
    509     //mov reg1,rax
    510     op_mov64_ToReg_FromReg(reg1,REG_RAX);
    511 
    512     if(reg1!=REG_RAX){
     378    {
     379
     380        //mov rax,reg1
     381        op_mov64_ToReg_FromReg(REG_RAX,reg1);
     382
     383        if(IsSignedType(type[sp-2])){
     384            //符号拡張
     385            //rdx:rax ← rax
     386
     387            //cqo
     388            OpBuffer[obp++]=(char)0x48;
     389            OpBuffer[obp++]=(char)0x99;
     390        }
     391        else{
     392            //ビット拡張
     393            //rdx:rax ← rax
     394
     395            //xor rdx,rdx
     396            op_zero_reg(REG_RDX);
     397        }
     398
     399        if(IsSignedType(AnswerType)){
     400            //idiv reg2
     401            op_idiv64_reg(reg2);
     402        }
     403        else{
     404            //div reg2
     405            op_div64_reg(reg2);
     406        }
     407
     408        //mov reg1,rax
     409        op_mov64_ToReg_FromReg(reg1,REG_RAX);
     410
     411    }
     412
     413    if(reg1!=REG_RAX && isUsingRax){
     414        //結果レジスタがraxでない場合（使用されている可能性があるとき）
     415
    513416        //mov rax,qword ptr[rsp+offset]     ※スタックフレームを利用
    514417        pobj_sf->pop(REG_RAX);
    515418    }
    516419
    517     //mov rdx,qword ptr[rsp+offset]     ※スタックフレームを利用
    518     pobj_sf->pop(REG_RDX);
     420    if(reg1!=REG_RDX && isUsingRdx){
     421        //結果レジスタがrdxでない場合（使用されている可能性があるとき）
     422
     423        //mov rdx,qword ptr[rsp+offset]     ※スタックフレームを利用
     424        pobj_sf->pop(REG_RDX);
     425    }
    519426
    520427
    … …  
    526433    sp--;
    527434    type[sp-1]=AnswerType;
    528 
    529435
    530436    *pStackPointer=sp;

  • BasicCompiler64/Opcode.h

    r17 r19  
    185185    int UnlockXmmReg();
    186186
     187    //レジスタが利用中かどうかを調べる
     188    bool IsUsing( int reg );
     189
    187190    //レジスタのバックアップと復旧
    188191    void backup();
    … …  
    253256
    254257//NumOpe_Arithmetic.cpp
    255 void GetStackData_ToRegister(int *type,int sp);
    256258BOOL CalcTwoTerm_Arithmetic(int idCalc,int *type,LONG_PTR *index_stack,int *pStackPointer);
    257259BOOL Calc_Mod(int *type,LONG_PTR *index_stack,int *pStackPointer);
    … …  
    503505void op_fld_ptr_esp(int type);
    504506void op_zero_reg(int reg);
    505 void op_call(SUBINFO *psi);
     507void op_call( SUBINFO *psi );
     508void op_call( DECLAREINFO *pdi );

  • BasicCompiler64/Register.cpp

    r3 r19  
    226226    return GetNextXmmReg();
    227227}
     228bool CRegister::IsUsing( int reg ){
     229    int i;
     230
     231    //汎用レジスタを調べる
     232    for(i=init_sp_reg;i>sp_UseReg;i--){
     233        if( array_UseReg[i] == reg ) return true;
     234    }
     235
     236    //XMMレジスタを調べる
     237    for(i=init_sp_xmm_reg;i>sp_XmmReg;i--){
     238        if( array_XmmReg[i] == reg ) return true;
     239    }
     240
     241    //ブロックされている場合を考慮
     242    if( pobj_BlockReg->check( reg ) ) return true;
     243
     244    //使用中でないとき
     245    return false;
     246}
    228247void CRegister::backup(){
    229248    int i;

  • BasicCompiler64/amd64_main.cpp

    r3 r19  
    17651765/////////////////////////////
    17661766
    1767 void op_call(SUBINFO *psi){
    1768     OpBuffer[obp++]=(char)0xE8;
    1769     pobj_SubAddrSchedule->add(psi,1);
    1770     psi->bUse=1;
    1771     obp+=sizeof(long);
    1772 }
     1767void op_call( SUBINFO *psi ){
     1768    OpBuffer[obp++] = (char)0xE8;
     1769    pobj_SubAddrSchedule->add( psi, 1 );
     1770    psi->bUse = 1;
     1771    obp += sizeof(long);
     1772}
     1773void op_call( DECLAREINFO *pdi ){
     1774    OpBuffer[obp++] = (char)0xFF;
     1775    OpBuffer[obp++] = (char)0x15;
     1776    pobj_ImportAddrSchedule->add(pdi);
     1777    obp += sizeof(long);
     1778
     1779    pdi->bUse=1;
     1780}
Note: See TracChangeset for help on using the changeset viewer.