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

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

File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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;
Note: See TracChangeset for help on using the changeset viewer.