Changeset 66 in dev for BasicCompiler64


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

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

Location:
BasicCompiler64
Files:
5 edited

Legend:

Unmodified
Added
Removed

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