Changeset 232 in dev


Ignore:
Timestamp:
Jul 25, 2007, 4:04:11 AM (16 years ago)
Author:
dai_9181
Message:
 
Location:
trunk/abdev
Files:
1 added
20 edited

Legend:

Unmodified
Added
Removed
  • trunk/abdev/BasicCompiler32/BasicCompiler.vcproj

    r225 r232  
    13081308                </File>
    13091309                <File
     1310                    RelativePath="..\BasicCompiler_Common\src\NativeCode.cpp"
     1311                    >
     1312                </File>
     1313                <File
    13101314                    RelativePath="..\BasicCompiler_Common\src\Procedure.cpp"
    13111315                    >
  • trunk/abdev/BasicCompiler64/BasicCompiler.vcproj

    r226 r232  
    11171117                </File>
    11181118                <File
     1119                    RelativePath="..\BasicCompiler_Common\src\NativeCode.cpp"
     1120                    >
     1121                </File>
     1122                <File
    11191123                    RelativePath="..\BasicCompiler_Common\src\Procedure.cpp"
    11201124                    >
  • trunk/abdev/BasicCompiler64/CodeGenerator.cpp

    r228 r232  
    160160///////////////////
    161161
    162 void CodeGenerator::op_mov_RV(int op_size,int reg,long i32data){
     162void CodeGenerator::op_mov_RV(int op_size,int reg,long i32data, Schedule::Type scheduleType ){
    163163    //mov reg,i32data
    164164
     
    179179
    180180    //即値
    181     pNativeCode->Put( i32data );
     181    pNativeCode->Put( i32data, scheduleType );
    182182}
    183183void CodeGenerator::op_mov_RV64(int reg,_int64 i64data){
     
    258258    }
    259259}
    260 void CodeGenerator::op_mov_MR(int op_size,int reg,int base_reg,long offset,char mod){
     260void CodeGenerator::op_mov_MR(int op_size,int reg,int base_reg,long offset,char mod, Schedule::Type scheduleType ){
    261261    //mov qword ptr[base_reg+offset],reg64
    262262    //mov dword ptr[base_reg+offset],reg32
     
    273273    else opcode=(char)0x89;
    274274
    275     __op_format(op_size,op_prefix,opcode,0,reg,base_reg,offset,mod);
    276 }
    277 void CodeGenerator::op_mov_MR_ex(int op_size,int reg,int base_reg1,int base_reg2,long offset,BOOL bUseOffset){
     275    __op_format(op_size,op_prefix,opcode,0,reg,base_reg,offset,mod, scheduleType );
     276}
     277void CodeGenerator::op_mov_MR_ex(int op_size,int reg,int base_reg1,int base_reg2,long offset,BOOL bUseOffset, Schedule::Type scheduleType ){
    278278    //mov qword ptr[base_reg1+base_reg2+offset],reg64
    279279    //mov dword ptr[base_reg1+base_reg2+offset],reg32
     
    309309
    310310        //オフセット値
    311         pNativeCode->Put( offset );
     311        pNativeCode->Put( offset, scheduleType );
    312312    }
    313313    else{
     
    389389}
    390390
    391 
    392 
    393 ///////////////////
    394 // mov64関連
    395 ///////////////////
    396 
    397 void CodeGenerator::op_mov64_ToReg(int reg,_int64 i64data){
    398     //mov reg,i64data
    399 
    400     if(REG_RAX<=reg&&reg<=REG_RDI){
    401         /*  rax~rdi
    402             0100 1000 1011 1xxx [64bit data]    */
    403         pNativeCode->Put( (char)0x48 );
    404         pNativeCode->Put( (char)(0xB8| REGISTER_OPERAND(reg) ) );
    405         pNativeCode->Put( i64data );
    406     }
    407     if(REG_R8<=reg&&reg<=REG_R15){
    408         /*  r8~r15
    409             0100 1001 1011 1xxx [64bit data]    */
    410         pNativeCode->Put( (char)0x49 );
    411         pNativeCode->Put( (char)(0xB8| REGISTER_OPERAND(reg) ) );
    412         pNativeCode->Put( i64data );
    413     }
    414 }
    415 void CodeGenerator::op_mov64_ToReg(int reg,long i32data){
    416     //mov reg,i32data
    417 
    418     if(REG_RAX<=reg&&reg<=REG_RDI){
    419         /*  rax~rdi
    420             0100 1000 1100 0111 1100 0xxx [32bit data]  */
    421         pNativeCode->Put( (char)0x48 );
    422         pNativeCode->Put( (char)0xC7 );
    423         pNativeCode->Put( (char)(0xC0| REGISTER_OPERAND(reg) ) );
    424         pNativeCode->Put( i32data );
    425     }
    426     if(REG_R8<=reg&&reg<=REG_R15){
    427         /*  r8~r15
    428             0100 1001 1100 0111 1100 0xxx [32bit data]  */
    429         pNativeCode->Put( (char)0x49 );
    430         pNativeCode->Put( (char)0xC7 );
    431         pNativeCode->Put( (char)(0xC0| REGISTER_OPERAND(reg) ) );
    432         pNativeCode->Put( i32data );
    433     }
    434 }
    435391void CodeGenerator::op_movsxd(int reg64,int reg32){
    436392    //movsxd reg64,reg32
     
    641597}
    642598
    643 void CodeGenerator::op_add_RV(int reg,long offset){
     599void CodeGenerator::op_add_RV(int reg,long offset, Schedule::Type scheduleType ){
    644600    //add reg,offset
    645601    char RexByte=-1;
     
    656612        pNativeCode->Put( (char)RexByte );
    657613        pNativeCode->Put( (char)0x05 );
    658         pNativeCode->Put( offset );
     614        pNativeCode->Put( offset, scheduleType );
    659615    }
    660616    else{
     
    665621        pNativeCode->Put( (char)0x81 );
    666622        pNativeCode->Put( (char)(0xC0| REGISTER_OPERAND(reg)) );
    667         pNativeCode->Put( offset );
     623        pNativeCode->Put( offset, scheduleType );
    668624    }
    669625}
     
    13651321////////////////////
    13661322
    1367 void CodeGenerator::op_movlpd_MR(int xmm_reg,int base_reg,int offset,char mod){
     1323void CodeGenerator::op_movlpd_MR(int xmm_reg,int base_reg,int offset,char mod, Schedule::Type scheduleType ){
    13681324    //movlpd qword ptr[base_reg+offset],xmm_reg
    1369     __op_format(0,(char)0x66,(char)0x0F,(char)0x13,xmm_reg,base_reg,offset,mod);
    1370 }
    1371 void CodeGenerator::op_movlpd_RM(int xmm_reg,int base_reg,int offset,char mod){
     1325    __op_format(0,(char)0x66,(char)0x0F,(char)0x13,xmm_reg,base_reg,offset,mod, scheduleType );
     1326}
     1327void CodeGenerator::op_movlpd_RM(int xmm_reg,int base_reg,int offset,char mod, Schedule::Type scheduleType ){
    13721328    //movlpd xmm_reg,qword ptr[base_reg+offset]
    1373     __op_format(0,(char)0x66,(char)0x0F,(char)0x12,xmm_reg,base_reg,offset,mod);
     1329    __op_format(0,(char)0x66,(char)0x0F,(char)0x12,xmm_reg,base_reg,offset,mod, scheduleType );
    13741330}
    13751331void CodeGenerator::op_movsd_RR(int xmm_reg1,int xmm_reg2){
     
    13791335    __op_format(0,(char)0xF2,(char)0x0F,(char)0x10,xmm_reg1,xmm_reg2,0,MOD_REG);
    13801336}
    1381 void CodeGenerator::op_movsd_MR(int xmm_reg,int base_reg,int offset,char mod){
     1337void CodeGenerator::op_movsd_MR(int xmm_reg,int base_reg,int offset,char mod, Schedule::Type scheduleType ){
    13821338    //movsd qword ptr[reg+offset],xmm_reg
    13831339    //movsd qword ptr[reg],xmm_reg
    1384     __op_format(0,(char)0xF2,(char)0x0F,(char)0x11,xmm_reg,base_reg,offset,mod);
     1340    __op_format(0,(char)0xF2,(char)0x0F,(char)0x11,xmm_reg,base_reg,offset,mod, scheduleType );
    13851341}
    13861342void CodeGenerator::op_movss_RR(int xmm_reg1,int xmm_reg2){
     
    13901346    __op_format(0,(char)0xF3,(char)0x0F,(char)0x10,xmm_reg1,xmm_reg2,0,MOD_REG);
    13911347}
    1392 void CodeGenerator::op_movss_RM(int xmm_reg,int base_reg,int offset,char mod){
     1348void CodeGenerator::op_movss_RM(int xmm_reg,int base_reg,int offset,char mod, Schedule::Type scheduleType ){
    13931349    //movss xmm_reg,dword ptr[base_reg+offset]
    1394     __op_format(0,(char)0xF3,(char)0x0F,(char)0x10,xmm_reg,base_reg,offset,mod);
    1395 }
    1396 void CodeGenerator::op_movss_MR(int xmm_reg,int base_reg,int offset,char mod){
     1350    __op_format(0,(char)0xF3,(char)0x0F,(char)0x10,xmm_reg,base_reg,offset,mod, scheduleType );
     1351}
     1352void CodeGenerator::op_movss_MR(int xmm_reg,int base_reg,int offset,char mod, Schedule::Type scheduleType ){
    13971353    //movss dword ptr[reg+offset],xmm_reg
    13981354    //movss dword ptr[reg],xmm_reg
    1399     __op_format(0,(char)0xF3,(char)0x0F,(char)0x11,xmm_reg,base_reg,offset,mod);
     1355    __op_format(0,(char)0xF3,(char)0x0F,(char)0x11,xmm_reg,base_reg,offset,mod, scheduleType );
    14001356}
    14011357
  • trunk/abdev/BasicCompiler64/Compile_Calc_PushVar.cpp

    r228 r232  
    1111        if(pRelativeVar->bOffsetOffset){
    1212            //movlpd xmm_reg,qword ptr[r11+offset]
    13             OpBuffer[obp++]=(char)0x66;
    14             OpBuffer[obp++]=(char)0x41;
    15             OpBuffer[obp++]=(char)0x0F;
    16             OpBuffer[obp++]=(char)0x12;
    17             OpBuffer[obp++]=(char)(0x83 | REGISTER_OPERAND(xmm_reg)<<3);
    18             *((long *)(OpBuffer+obp))=(int)pRelativeVar->offset;
    19             pobj_GlobalVarSchedule->add();
    20             obp+=sizeof(long);
     13            compiler.codeGenerator.op_movlpd_RM( xmm_reg, REG_R11, (long)pRelativeVar->offset, MOD_BASE_DISP32, Schedule::GlobalVar );
    2114        }
    2215        else{
    2316            //movlpd xmm_reg,qword ptr[offset]
    24             OpBuffer[obp++]=(char)0x66;
    25             OpBuffer[obp++]=(char)0x0F;
    26             OpBuffer[obp++]=(char)0x12;
    27             OpBuffer[obp++]=(char)(0x04 | REGISTER_OPERAND(xmm_reg)<<3);
    28             OpBuffer[obp++]=(char)0x25;
    29             *((long *)(OpBuffer+obp))=(int)pRelativeVar->offset;
    30             pobj_GlobalVarSchedule->add();
    31             obp+=sizeof(long);
     17            compiler.codeGenerator.op_movlpd_RM( xmm_reg, 0, (long)pRelativeVar->offset, MOD_DISP32, Schedule::GlobalVar );
    3218        }
    3319    }
     
    5036        else{
    5137            //movlpd xmm_reg,qword ptr[rsp+offset]
    52             OpBuffer[obp++]=(char)0x66;
    53             OpBuffer[obp++]=(char)0x0F;
    54             OpBuffer[obp++]=(char)0x12;
    55             OpBuffer[obp++]=(char)(0x84 | REGISTER_OPERAND(xmm_reg)<<3);
    56             OpBuffer[obp++]=(char)0x24;
    57             *((long *)(OpBuffer+obp))=(int)pRelativeVar->offset;
    58             AddLocalVarAddrSchedule();
    59             obp+=sizeof(long);
     38            compiler.codeGenerator.op_movlpd_RM( xmm_reg, REG_RSP, (long)pRelativeVar->offset, MOD_BASE_DISP32, Schedule::LocalVar );
    6039        }
    6140    }
     
    6342        if(pRelativeVar->bOffsetOffset){
    6443            //add r11,qword ptr[rsp+offset]
    65             OpBuffer[obp++]=(char)0x4C;
    66             OpBuffer[obp++]=(char)0x03;
    67             OpBuffer[obp++]=(char)0x9C;
    68             OpBuffer[obp++]=(char)0x24;
    69             *((long *)(OpBuffer+obp))=(int)pRelativeVar->offset;
    70             AddLocalVarAddrSchedule();
    71             obp+=sizeof(long);
     44            compiler.codeGenerator.op_add_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32, Schedule::LocalVar );
    7245        }
    7346        else{
    7447            //mov r11,qword ptr[rsp+offset]
    75             compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
    76             obp-=sizeof(long);
    77             AddLocalVarAddrSchedule();
    78             obp+=sizeof(long);
     48            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32, Schedule::LocalVar );
    7949        }
    8050
     
    8454directmem:
    8555        //movlpd xmm_reg,qword ptr[r11]
    86         OpBuffer[obp++]=(char)0x66;
    87         OpBuffer[obp++]=(char)0x41;
    88         OpBuffer[obp++]=(char)0x0F;
    89         OpBuffer[obp++]=(char)0x12;
    90         OpBuffer[obp++]=(char)(0x03 | REGISTER_OPERAND(xmm_reg)<<3);
     56        compiler.codeGenerator.op_movlpd_RM( xmm_reg, REG_R11, 0, MOD_BASE);
    9157    }
    9258}
     
    9561        if(pRelativeVar->bOffsetOffset){
    9662            //movss xmm_reg,dword ptr[r11+offset]
    97             OpBuffer[obp++]=(char)0xF3;
    98             OpBuffer[obp++]=(char)0x41;
    99             OpBuffer[obp++]=(char)0x0F;
    100             OpBuffer[obp++]=(char)0x10;
    101             OpBuffer[obp++]=(char)(0x83 | REGISTER_OPERAND(xmm_reg)<<3);
    102             *((long *)(OpBuffer+obp))=(int)pRelativeVar->offset;
    103             pobj_GlobalVarSchedule->add();
    104             obp+=sizeof(long);
     63            compiler.codeGenerator.op_movss_RM( xmm_reg, REG_R11, (long)pRelativeVar->offset, MOD_BASE_DISP32, Schedule::GlobalVar );
    10564        }
    10665        else{
    10766            //movss xmm_reg,dword ptr[offset]
    108             OpBuffer[obp++]=(char)0xF3;
    109             OpBuffer[obp++]=(char)0x0F;
    110             OpBuffer[obp++]=(char)0x10;
    111             OpBuffer[obp++]=(char)(0x04 | REGISTER_OPERAND(xmm_reg)<<3);
    112             OpBuffer[obp++]=(char)0x25;
    113             *((long *)(OpBuffer+obp))=(int)pRelativeVar->offset;
    114             pobj_GlobalVarSchedule->add();
    115             obp+=sizeof(long);
     67            compiler.codeGenerator.op_movss_RM( xmm_reg, 0, (long)pRelativeVar->offset, MOD_BASE, Schedule::GlobalVar );
    11668        }
    11769    }
     
    13486        else{
    13587            //movss xmm_reg,dword ptr[rsp+offset]
    136             OpBuffer[obp++]=(char)0xF3;
    137             OpBuffer[obp++]=(char)0x0F;
    138             OpBuffer[obp++]=(char)0x10;
    139             OpBuffer[obp++]=(char)(0x84 | REGISTER_OPERAND(xmm_reg)<<3);
    140             OpBuffer[obp++]=(char)0x24;
    141             *((long *)(OpBuffer+obp))=(int)pRelativeVar->offset;
    142             AddLocalVarAddrSchedule();
    143             obp+=sizeof(long);
     88            compiler.codeGenerator.op_movss_RM( xmm_reg, REG_RSP, (long)pRelativeVar->offset, MOD_BASE_DISP32, Schedule::LocalVar );
    14489        }
    14590    }
     
    14792        if(pRelativeVar->bOffsetOffset){
    14893            //add r11,qword ptr[rsp+offset]
    149             OpBuffer[obp++]=(char)0x4C;
    150             OpBuffer[obp++]=(char)0x03;
    151             OpBuffer[obp++]=(char)0x9C;
    152             OpBuffer[obp++]=(char)0x24;
    153             *((long *)(OpBuffer+obp))=(int)pRelativeVar->offset;
    154             AddLocalVarAddrSchedule();
    155             obp+=sizeof(long);
     94            compiler.codeGenerator.op_add_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32, Schedule::LocalVar );
    15695        }
    15796        else{
    15897            //mov r11,qword ptr[rsp+offset]
    159             compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
    160             obp-=sizeof(long);
    161             AddLocalVarAddrSchedule();
    162             obp+=sizeof(long);
     98            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32, Schedule::LocalVar );
    16399        }
    164100
     
    168104directmem:
    169105        //movss xmm_reg,dword ptr[r11]
    170         OpBuffer[obp++]=(char)0xF3;
    171         OpBuffer[obp++]=(char)0x41;
    172         OpBuffer[obp++]=(char)0x0F;
    173         OpBuffer[obp++]=(char)0x10;
    174         OpBuffer[obp++]=(char)(0x03 | REGISTER_OPERAND(xmm_reg)<<3);
     106        compiler.codeGenerator.op_movss_RM( xmm_reg, REG_R11, 0, MOD_BASE);
    175107    }
    176108}
  • trunk/abdev/BasicCompiler64/Compile_ProcOp.cpp

    r226 r232  
    740740    //ローカル変数領域のサイズをスタックフレームに通知
    741741    int localParmSize = AllLocalVarSize - BaseLocalVar;
    742     int stackFrameSize = pobj_sf->GetFrameSize( AllLocalVarSize );
     742    int stackFrameSize = pobj_sf->GetFrameSize( localParmSize );
    743743
    744744    //ローカル変数アドレススケジュール
  • trunk/abdev/BasicCompiler64/Compile_Set_Var.cpp

    r228 r232  
    105105        if(pRelative->bOffsetOffset){
    106106            //movsd qword ptr[r11+offset],xmm0
    107             OpBuffer[obp++]=(char)0xF2;
    108             OpBuffer[obp++]=(char)0x41;
    109             OpBuffer[obp++]=(char)0x0F;
    110             OpBuffer[obp++]=(char)0x11;
    111             OpBuffer[obp++]=(char)0x83;
    112             *((long *)(OpBuffer+obp))=(int)pRelative->offset;
    113             pobj_GlobalVarSchedule->add();
    114             obp+=sizeof(long);
     107            compiler.codeGenerator.op_movsd_MR( REG_XMM0, REG_R11, (long)pRelative->offset, MOD_BASE_DISP32, Schedule::GlobalVar );
    115108        }
    116109        else{
    117110            //movsd qword ptr[offset],xmm0
    118             OpBuffer[obp++]=(char)0xF2;
    119             OpBuffer[obp++]=(char)0x0F;
    120             OpBuffer[obp++]=(char)0x11;
    121             OpBuffer[obp++]=(char)0x04;
    122             OpBuffer[obp++]=(char)0x25;
    123             *((long *)(OpBuffer+obp))=(int)pRelative->offset;
    124             pobj_GlobalVarSchedule->add();
    125             obp+=sizeof(long);
     111            compiler.codeGenerator.op_movsd_MR( REG_XMM0, 0, (long)pRelative->offset, MOD_DISP32, Schedule::GlobalVar );
    126112        }
    127113    }
     
    144130        else{
    145131            //movsd qword ptr[rsp+offset],xmm0
    146             OpBuffer[obp++]=(char)0xF2;
    147             OpBuffer[obp++]=(char)0x0F;
    148             OpBuffer[obp++]=(char)0x11;
    149             OpBuffer[obp++]=(char)0x84;
    150             OpBuffer[obp++]=(char)0x24;
    151             *((long *)(OpBuffer+obp))=(int)pRelative->offset;
    152             AddLocalVarAddrSchedule();
    153             obp+=sizeof(long);
     132            compiler.codeGenerator.op_movsd_MR( REG_XMM0, REG_RSP, (long)pRelative->offset, MOD_BASE_DISP32, Schedule::LocalVar );
    154133        }
    155134    }
     
    157136        if(pRelative->bOffsetOffset){
    158137            //add r11,qword ptr[rsp+offset]
    159             OpBuffer[obp++]=(char)0x4C;
    160             OpBuffer[obp++]=(char)0x03;
    161             OpBuffer[obp++]=(char)0x9C;
    162             OpBuffer[obp++]=(char)0x24;
    163             *((long *)(OpBuffer+obp))=(int)pRelative->offset;
    164             AddLocalVarAddrSchedule();
    165             obp+=sizeof(long);
     138            compiler.codeGenerator.op_add_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32, Schedule::LocalVar );
    166139        }
    167140        else{
    168141            //mov r11,qword ptr[rsp+offset]
    169             compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32);
    170             obp-=sizeof(long);
    171             AddLocalVarAddrSchedule();
    172             obp+=sizeof(long);
     142            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32, Schedule::LocalVar );
    173143        }
    174144
     
    192162        if(pRelative->bOffsetOffset){
    193163            //movss dword ptr[r11+offset],xmm0
    194             OpBuffer[obp++]=(char)0xF3;
    195             OpBuffer[obp++]=(char)0x41;
    196             OpBuffer[obp++]=(char)0x0F;
    197             OpBuffer[obp++]=(char)0x11;
    198             OpBuffer[obp++]=(char)0x83;
    199             *((long *)(OpBuffer+obp))=(int)pRelative->offset;
    200             pobj_GlobalVarSchedule->add();
    201             obp+=sizeof(long);
     164            compiler.codeGenerator.op_movss_MR( REG_XMM0, REG_R11, (long)pRelative->offset, MOD_BASE_DISP32, Schedule::GlobalVar );
    202165        }
    203166        else{
    204167            //movss dword ptr[offset],xmm0
    205             OpBuffer[obp++]=(char)0xF3;
    206             OpBuffer[obp++]=(char)0x0F;
    207             OpBuffer[obp++]=(char)0x11;
    208             OpBuffer[obp++]=(char)0x04;
    209             OpBuffer[obp++]=(char)0x25;
    210             *((long *)(OpBuffer+obp))=(int)pRelative->offset;
    211             pobj_GlobalVarSchedule->add();
    212             obp+=sizeof(long);
     168            compiler.codeGenerator.op_movss_MR( REG_XMM0, 0, (long)pRelative->offset, MOD_DISP32, Schedule::GlobalVar );
    213169        }
    214170    }
     
    231187        else{
    232188            //movss dword ptr[rsp+offset],xmm0
    233             OpBuffer[obp++]=(char)0xF3;
    234             OpBuffer[obp++]=(char)0x0F;
    235             OpBuffer[obp++]=(char)0x11;
    236             OpBuffer[obp++]=(char)0x84;
    237             OpBuffer[obp++]=(char)0x24;
    238             *((long *)(OpBuffer+obp))=(int)pRelative->offset;
    239             AddLocalVarAddrSchedule();
    240             obp+=sizeof(long);
     189            compiler.codeGenerator.op_movss_MR( REG_XMM0, REG_RSP, (long)pRelative->offset, MOD_BASE_DISP32, Schedule::LocalVar );
    241190        }
    242191    }
     
    244193        if(pRelative->bOffsetOffset){
    245194            //add r11,qword ptr[rsp+offset]
    246             OpBuffer[obp++]=(char)0x4C;
    247             OpBuffer[obp++]=(char)0x03;
    248             OpBuffer[obp++]=(char)0x9C;
    249             OpBuffer[obp++]=(char)0x24;
    250             *((long *)(OpBuffer+obp))=(int)pRelative->offset;
    251             AddLocalVarAddrSchedule();
    252             obp+=sizeof(long);
     195            compiler.codeGenerator.op_add_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32, Schedule::LocalVar );
    253196        }
    254197        else{
    255198            //mov r11,qword ptr[rsp+offset]
    256             compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32);
    257             obp-=sizeof(long);
    258             AddLocalVarAddrSchedule();
    259             obp+=sizeof(long);
     199            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32, Schedule::LocalVar );
    260200        }
    261201
     
    334274        if(pRelative->bOffsetOffset){
    335275            //mov ptr[r11+offset],rax/eax/ax/al
    336             compiler.codeGenerator.op_mov_MR(varSize,REG_RAX,REG_R11,(int)pRelative->offset,MOD_BASE_DISP32);
    337             obp-=sizeof(long);
    338             pobj_GlobalVarSchedule->add();
    339             obp+=sizeof(long);
     276            compiler.codeGenerator.op_mov_MR(varSize,REG_RAX,REG_R11,(int)pRelative->offset,MOD_BASE_DISP32, Schedule::GlobalVar );
    340277        }
    341278        else{
    342279            //mov ptr[offset],rax/eax/ax/al
    343             compiler.codeGenerator.op_mov_MR(varSize,REG_RAX,0,(int)pRelative->offset,MOD_DISP32);
    344             obp-=sizeof(long);
    345             pobj_GlobalVarSchedule->add();
    346             obp+=sizeof(long);
     280            compiler.codeGenerator.op_mov_MR(varSize,REG_RAX,0,(int)pRelative->offset,MOD_DISP32, Schedule::GlobalVar );
    347281        }
    348282    }
     
    350284        if(pRelative->bOffsetOffset){
    351285            //add r11,qword ptr[offset]
    352             compiler.codeGenerator.op_add_RM( sizeof(_int64), REG_R11, REG_NON, (int)pRelative->offset, MOD_DISP32 );
    353             obp-=sizeof(long);
    354             pobj_GlobalVarSchedule->add();
    355             obp+=sizeof(long);
     286            compiler.codeGenerator.op_add_RM( sizeof(_int64), REG_R11, REG_NON, (int)pRelative->offset, MOD_DISP32, Schedule::GlobalVar );
    356287        }
    357288        else{
    358289            //mov r11,qword ptr[offset]
    359             compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_NON,(int)pRelative->offset,MOD_DISP32);
    360             obp-=sizeof(long);
    361             pobj_GlobalVarSchedule->add();
    362             obp+=sizeof(long);
     290            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_NON,(int)pRelative->offset,MOD_DISP32, Schedule::GlobalVar );
    363291        }
    364292
     
    368296        if(pRelative->bOffsetOffset){
    369297            //mov ptr[rsp+r11+offset],rax/eax/ax/al
    370             compiler.codeGenerator.op_mov_MR_ex(varSize,REG_RAX,REG_RSP,REG_R11,(int)pRelative->offset,USE_OFFSET);
    371             obp-=sizeof(long);
    372             AddLocalVarAddrSchedule();
    373             obp+=sizeof(long);
     298            compiler.codeGenerator.op_mov_MR_ex(varSize,REG_RAX,REG_RSP,REG_R11,(int)pRelative->offset,USE_OFFSET, Schedule::LocalVar );
    374299        }
    375300        else{
    376301            //mov ptr[rsp+offset],rax/eax/ax/al
    377             compiler.codeGenerator.op_mov_MR(varSize,REG_RAX,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32);
    378             obp-=sizeof(long);
    379             AddLocalVarAddrSchedule();
    380             obp+=sizeof(long);
     302            compiler.codeGenerator.op_mov_MR(varSize,REG_RAX,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32, Schedule::LocalVar );
    381303        }
    382304    }
     
    384306        if(pRelative->bOffsetOffset){
    385307            //add r11,qword ptr[rsp+offset]
    386             compiler.codeGenerator.op_add_RM( sizeof(_int64), REG_R11, REG_RSP, (int)pRelative->offset, MOD_BASE_DISP32 );
    387             obp-=sizeof(long);
    388             AddLocalVarAddrSchedule();
    389             obp+=sizeof(long);
     308            compiler.codeGenerator.op_add_RM( sizeof(_int64), REG_R11, REG_RSP, (int)pRelative->offset, MOD_BASE_DISP32, Schedule::LocalVar );
    390309        }
    391310        else{
    392311            //mov r11,qword ptr[rsp+offset]
    393             compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32);
    394             obp-=sizeof(long);
    395             AddLocalVarAddrSchedule();
    396             obp+=sizeof(long);
     312            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32, Schedule::LocalVar );
    397313        }
    398314
  • trunk/abdev/BasicCompiler64/Compile_Var.cpp

    r228 r232  
    868868
    869869            //mov qword ptr[offset],rax
    870             compiler.codeGenerator.op_mov_MR(sizeof(_int64),REG_RAX,0,offset,MOD_DISP32);
    871             obp-=sizeof(long);
    872             pobj_GlobalVarSchedule->add();
    873             obp+=sizeof(long);
     870            compiler.codeGenerator.op_mov_MR(sizeof(_int64),REG_RAX,0,offset,MOD_DISP32, Schedule::GlobalVar );
    874871        }
    875872        else{
     
    992989
    993990        //mov rax,i64data
    994         compiler.codeGenerator.op_mov64_ToReg(REG_RAX,i64data);
     991        compiler.codeGenerator.op_mov_RV64(REG_RAX,i64data);
    995992
    996993        //mov qword ptr[rsp+offset],rax
     
    10341031            if(i64data&0xFFFFFFFF00000000){
    10351032                //mov rax,i64data
    1036                 compiler.codeGenerator.op_mov64_ToReg(REG_RAX,i64data);
     1033                compiler.codeGenerator.op_mov_RV64(REG_RAX,i64data);
    10371034
    10381035                //mov qword ptr[rsp+offset],rax
     
    11161113        //アラインメントを考慮
    11171114        if( pVar->GetType().IsStruct() ){
    1118             int alignment = pVar->GetType().GetClass().iAlign;
     1115            int alignment = pVar->GetType().GetClass().GetFixedAlignment();
    11191116
    11201117            if( alignment ){
     
    12221219        if(pRelativeVar->bOffsetOffset){
    12231220            //add r11,offset
    1224             OpBuffer[obp++]=(char)0x49;
    1225             OpBuffer[obp++]=(char)0x81;
    1226             OpBuffer[obp++]=(char)0xC3;
    1227             *((long *)(OpBuffer+obp))=(int)pRelativeVar->offset;
    1228             pobj_GlobalVarSchedule->add();
    1229             obp+=sizeof(long);
     1221            compiler.codeGenerator.op_add_RV( REG_R11, (long)pRelativeVar->offset, Schedule::GlobalVar );
    12301222
    12311223            //mov reg,r11
     
    12341226        else{
    12351227            //mov reg,offset
    1236             compiler.codeGenerator.op_mov64_ToReg(reg,(long)pRelativeVar->offset);
    1237             obp-=sizeof(long);
    1238             pobj_GlobalVarSchedule->add();
    1239             obp+=sizeof(long);
     1228            compiler.codeGenerator.op_mov_RV( sizeof(_int64), reg, (long)pRelativeVar->offset, Schedule::GlobalVar );
    12401229        }
    12411230    }
     
    12431232        if(pRelativeVar->bOffsetOffset){
    12441233            //add r11,qword ptr[offset]
    1245             compiler.codeGenerator.op_add_RM( sizeof(_int64), REG_R11, REG_NON, (int)pRelativeVar->offset, MOD_DISP32 );
    1246             obp-=sizeof(long);
    1247             pobj_GlobalVarSchedule->add();
    1248             obp+=sizeof(long);
     1234            compiler.codeGenerator.op_add_RM( sizeof(_int64), REG_R11, REG_NON, (int)pRelativeVar->offset, MOD_DISP32, Schedule::GlobalVar );
    12491235        }
    12501236        else{
    12511237            //mov r11,qword ptr[offset]
    1252             compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);
    1253             obp-=sizeof(long);
    1254             pobj_GlobalVarSchedule->add();
    1255             obp+=sizeof(long);
     1238            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_NON,(int)pRelativeVar->offset,MOD_DISP32, Schedule::GlobalVar );
    12561239        }
    12571240
     
    12611244        if(pRelativeVar->bOffsetOffset){
    12621245            //add r11,offset
    1263             OpBuffer[obp++]=(char)0x49;
    1264             OpBuffer[obp++]=(char)0x81;
    1265             OpBuffer[obp++]=(char)0xC3;
    1266             *((long *)(OpBuffer+obp))=(int)pRelativeVar->offset;
    1267             AddLocalVarAddrSchedule();
    1268             obp+=sizeof(long);
     1246            compiler.codeGenerator.op_add_RV( REG_R11, (long)pRelativeVar->offset, Schedule::LocalVar );
    12691247
    12701248            //add r11,rsp
     
    12791257
    12801258            //add reg,offset
    1281             compiler.codeGenerator.op_add_RV(reg,(int)pRelativeVar->offset);
    1282             obp-=sizeof(long);
    1283             AddLocalVarAddrSchedule();
    1284             obp+=sizeof(long);
     1259            compiler.codeGenerator.op_add_RV(reg,(long)pRelativeVar->offset, Schedule::LocalVar );
    12851260        }
    12861261    }
     
    12881263        if(pRelativeVar->bOffsetOffset){
    12891264            //add r11,qword ptr[rsp+offset]
    1290             OpBuffer[obp++]=(char)0x4C;
    1291             OpBuffer[obp++]=(char)0x03;
    1292             OpBuffer[obp++]=(char)0x9C;
    1293             OpBuffer[obp++]=(char)0x24;
    1294             *((long *)(OpBuffer+obp))=(int)pRelativeVar->offset;
    1295             AddLocalVarAddrSchedule();
    1296             obp+=sizeof(long);
     1265            compiler.codeGenerator.op_add_RM( REG_R11, REG_RSP, (long)pRelativeVar->offset, MOD_BASE_DISP32, Schedule::LocalVar );
    12971266        }
    12981267        else{
    12991268            //mov r11,qword ptr[rsp+offset]
    1300             compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
    1301             obp-=sizeof(long);
    1302             AddLocalVarAddrSchedule();
    1303             obp+=sizeof(long);
     1269            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32, Schedule::LocalVar );
    13041270        }
    13051271
     
    13311297            // ルートポインタを引き渡す
    13321298            //mov rdx,offset
    1333             compiler.codeGenerator.op_mov_RV(sizeof(_int64), REG_RDX,(int)pVar->GetOffsetAddress());
    1334             obp-=sizeof(long);
    1335             pobj_GlobalVarSchedule->add();
    1336             obp+=sizeof(long);
     1299            compiler.codeGenerator.op_mov_RV(sizeof(_int64), REG_RDX,(int)pVar->GetOffsetAddress(), Schedule::GlobalVar );
    13371300
    13381301            // Thisポインタを引き渡す
  • trunk/abdev/BasicCompiler64/NumOpe.cpp

    r226 r232  
    971971                        if(XmmReg==REG_XMM4){
    972972                            //mov r14,i64data
    973                             compiler.codeGenerator.op_mov64_ToReg(REG_R14,i64data);
     973                            compiler.codeGenerator.op_mov_RV64(REG_R14,i64data);
    974974
    975975
     
    10261026
    10271027                        //mov reg,i64data
    1028                         compiler.codeGenerator.op_mov64_ToReg(UseReg,i64data);
     1028                        compiler.codeGenerator.op_mov_RV64(UseReg,i64data);
    10291029
    10301030                        if(UseReg==REG_R14){
     
    11941194
    11951195            //mov reg,i64data
    1196             compiler.codeGenerator.op_mov64_ToReg(UseReg,i64data);
     1196            compiler.codeGenerator.op_mov_RV64(UseReg,i64data);
    11971197        }
    11981198
  • trunk/abdev/BasicCompiler64/stack_frame.cpp

    r228 r232  
    2525    answer_sp=lowest_sp-max_parm_size;
    2626
    27     if((localParamSize%0x10)){
    28         if((answer_sp%0x10)==0){
    29             //関数のエントリポイントで128ビット境界ラインに合わせるため
    30             return -(answer_sp-0x08);
    31         }
    32         return -(answer_sp-0x10);
     27    if(((answer_sp-localParamSize)%0x10)==0){
     28        //関数のエントリポイントで128ビット境界ラインに合わせるため
     29        return -(answer_sp-0x08);
    3330    }
    34 
    35     if((answer_sp%0x10)==0){
    36         //関数のエントリポイントで128ビット境界ラインに合わせるため
    37         return -(answer_sp-0x10);
    38     }
    39     return -(answer_sp-0x08);
     31    return -(answer_sp-0x10);
    4032}
    4133int CStackFrame::GetNowSp(){
  • trunk/abdev/BasicCompiler_Common/BasicCompiler.cpp

    r212 r232  
    9898
    9999    extern int obp;
    100     if(obp==1115){
     100    if(obp>=0x988DE){
     101        int test=0;
    101102    }
    102103}
  • trunk/abdev/BasicCompiler_Common/Compile.cpp

    r206 r232  
    684684            }
    685685
    686 #ifdef _DEBUG
     686
    687687            epi_check();
    688 #endif
     688
    689689
    690690            //コンパイルを中断するとき
  • trunk/abdev/BasicCompiler_Common/Debug.cpp

    r206 r232  
    596596            if(de.u.Exception.ExceptionRecord.ExceptionCode==EXCEPTION_ACCESS_VIOLATION){
    597597
    598                 //"スレッド(&H%X)でアクセス違反がありました(EPI=&H%08X)。\r\n"
     598                //"スレッド(&H%X)でアクセス違反がありました(EIP=&H%08X)。\r\n"
    599599                sprintf(temporary,STRING_DEBUG_THREAD_ACCESSVIOLATION,de.dwThreadId,(ULONG_PTR)de.u.Exception.ExceptionRecord.ExceptionAddress);
    600600                DebugMessage(temporary);
     
    621621                    if(de.dwThreadId==_DebugSys_dwThreadID[i4]) break;
    622622                }
    623                 Context.ContextFlags=CONTEXT_CONTROL;
     623                Context.ContextFlags=CONTEXT_CONTROL | CONTEXT_INTEGER;
    624624                GetThreadContext(array_hDebugThread[i4],&Context);
    625625
     
    627627                    i3&&(!(ImageBase+MemPos_CodeSection<=EIP_RIP(Context)&&EIP_RIP(Context)<ImageBase+MemPos_CodeSection+FileSize_CodeSection))
    628628                    ){
    629                     //"スレッド(&H%X)のブレーク ポイント(EPI=&H%08X)。\r\n"
    630                     sprintf(temporary,STRING_DEBUG_BREAKPOINT,de.dwThreadId,(ULONG_PTR)de.u.Exception.ExceptionRecord.ExceptionAddress);
     629                    //"スレッド(&H%X)のブレーク ポイント(EIP=&H%08X)。\r\n"
     630                    sprintf(temporary,
     631                        STRING_DEBUG_BREAKPOINT,
     632                        de.dwThreadId,
     633                        (ULONG_PTR)de.u.Exception.ExceptionRecord.ExceptionAddress,
     634                        (ULONG_PTR)Context.Rsp);
    631635                    DebugMessage(temporary);
    632636                }
     
    726730            }
    727731            else if(de.u.Exception.ExceptionRecord.ExceptionCode==STATUS_INTEGER_DIVIDE_BY_ZERO){
    728                 //"0による除算が行われました。スレッド(&H%X) ブレーク ポイント(EPI=&H%08X)。\r\n"
     732                //"0による除算が行われました。スレッド(&H%X) ブレーク ポイント(EIP=&H%08X)。\r\n"
    729733                sprintf(temporary,STRING_DEBUG_DIVIDE_BY_ZERO,de.dwThreadId,(ULONG_PTR)de.u.Exception.ExceptionRecord.ExceptionAddress);
    730734                DebugMessage(temporary);
     
    734738            }
    735739            else if(de.u.Exception.ExceptionRecord.ExceptionCode==STATUS_NO_MEMORY){
    736                 //"メモリ不足、またはヒープが壊れていることが原因で、メモリの割り当てに失敗しました。スレッド(&H%X) ブレーク ポイント(EPI=&H%08X)。\r\n"
     740                //"メモリ不足、またはヒープが壊れていることが原因で、メモリの割り当てに失敗しました。スレッド(&H%X) ブレーク ポイント(EIP=&H%08X)。\r\n"
    737741                sprintf(temporary,STRING_DEBUG_DIVIDE_NO_MEMORY,de.dwThreadId,(ULONG_PTR)de.u.Exception.ExceptionRecord.ExceptionAddress);
    738742                DebugMessage(temporary);
  • trunk/abdev/BasicCompiler_Common/DebugMiddleFile.cpp

    r206 r232  
    325325
    326326        //アラインメント
    327         *(long *)(buffer+i2)=pobj_c->iAlign;
     327        *(long *)(buffer+i2)=pobj_c->GetFixedAlignment();
    328328        i2+=sizeof(long);
    329329
     
    705705
    706706        //アラインメント
    707         pobj_c->iAlign=*(long *)(buffer+i2);
     707        pobj_c->SetFixedAlignment( *(long *)(buffer+i2) );
    708708        i2+=sizeof(long);
    709709
  • trunk/abdev/BasicCompiler_Common/VariableOpe.cpp

    r206 r232  
    10021002    int alignment = 0;
    10031003    if( pVar->GetType().IsStruct() ){
    1004         alignment = pVar->GetType().GetClass().iAlign;
     1004        alignment = pVar->GetType().GetClass().GetFixedAlignment();
    10051005    }
    10061006
  • trunk/abdev/BasicCompiler_Common/common_msg_eng.h

    r4 r232  
    3939#define STRING_DEBUG_THREADFINISH           "Thread(&H%X) exited with code &H%X.\r\n"
    4040#define STRING_DEBUG_PROCESSFINISH          "Program exited with code &H%X.\r\n"
    41 #define STRING_DEBUG_THREAD_INVALID_HANDLE  "Handle violation.   Thread=&H%X   EPI=&H%08X\r\n"
    42 #define STRING_DEBUG_THREAD_ACCESSVIOLATION "Access violation.   Thread=&H%X   EPI=&H%08X\r\n"
    43 #define STRING_DEBUG_BREAKPOINT             "Breakpoint.         Thread=&H%X   EPI=&H%08X\r\n"
    44 #define STRING_DEBUG_DIVIDE_BY_ZERO         "Divided by zero.    Thread=&H%X   EPI=&H%08X\r\n"
     41#define STRING_DEBUG_THREAD_INVALID_HANDLE  "Handle violation.   Thread=&H%X   EIP=&H%08X\r\n"
     42#define STRING_DEBUG_THREAD_ACCESSVIOLATION "Access violation.   Thread=&H%X   EIP=&H%08X\r\n"
     43#define STRING_DEBUG_BREAKPOINT             "Breakpoint.         Thread=&H%X   EIP=&H%08X/ESP=&H%08X\r\n"
     44#define STRING_DEBUG_DIVIDE_BY_ZERO         "Divided by zero.    Thread=&H%X   EIP=&H%08X\r\n"
    4545#define STRING_DEBUG_ERROR                  "Unknown error.\ncode:%X"
    4646#define STRING_DEBUG_FAILED                 "Failed to read the debug information."
  • trunk/abdev/BasicCompiler_Common/common_msg_jpn.h

    r4 r232  
    3939#define STRING_DEBUG_THREADFINISH           "スレッド(&H%X)はコード &H%X で終了しました。\r\n"
    4040#define STRING_DEBUG_PROCESSFINISH          "プログラムはコード &H%X で終了しました。\r\n"
    41 #define STRING_DEBUG_THREAD_INVALID_HANDLE  "スレッド(&H%X)でハンドル違反がありました(EPI=&H%08X)。\r\n"
    42 #define STRING_DEBUG_THREAD_ACCESSVIOLATION "スレッド(&H%X)でアクセス違反がありました(EPI=&H%08X)。\r\n"
    43 #define STRING_DEBUG_BREAKPOINT             "スレッド(&H%X)のブレーク ポイント(EPI=&H%08X)。\r\n"
    44 #define STRING_DEBUG_DIVIDE_BY_ZERO         "0による除算が行われました。スレッド(&H%X) ブレーク ポイント(EPI=&H%08X)。\r\n"
    45 #define STRING_DEBUG_DIVIDE_NO_MEMORY       "メモリ不足、またはヒープが壊れていることが原因で、メモリの割り当てに失敗しました。スレッド(&H%X) ブレーク ポイント(EPI=&H%08X)。\r\n"
     41#define STRING_DEBUG_THREAD_INVALID_HANDLE  "スレッド(&H%X)でハンドル違反がありました(EIP=&H%08X)。\r\n"
     42#define STRING_DEBUG_THREAD_ACCESSVIOLATION "スレッド(&H%X)でアクセス違反がありました(EIP=&H%08X)。\r\n"
     43#define STRING_DEBUG_BREAKPOINT             "スレッド(&H%X)のブレーク ポイント(EIP=&H%08X/ESP=&H%08X)。\r\n"
     44#define STRING_DEBUG_DIVIDE_BY_ZERO         "0による除算が行われました。スレッド(&H%X) ブレーク ポイント(EIP=&H%08X)。\r\n"
     45#define STRING_DEBUG_DIVIDE_NO_MEMORY       "メモリ不足、またはヒープが壊れていることが原因で、メモリの割り当てに失敗しました。スレッド(&H%X) ブレーク ポイント(EIP=&H%08X)。\r\n"
    4646#define STRING_DEBUG_ERROR                  "例外処理(code:&H%08X)\r\n"
    4747#define STRING_DEBUG_FAILED                 "デバッグ情報の取得に失敗"
  • trunk/abdev/BasicCompiler_Common/include/Class.h

    r208 r232  
    7171    // 静的メソッド
    7272    Methods staticMethods;
     73
     74    //アラインメント値
     75    int fixedAlignment;
    7376
    7477    // XMLシリアライズ用
     
    9396        ar & BOOST_SERIALIZATION_NVP( vtblNum );
    9497        ar & BOOST_SERIALIZATION_NVP( staticMethods );
     98        ar & BOOST_SERIALIZATION_NVP( fixedAlignment );
    9599    }
    96100
    97101    bool isReady;
    98102public:
    99 
    100     //アラインメント値
    101     int iAlign;
    102103
    103104    CClass( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, const string &name )
     
    107108        , pSuperClass( NULL )
    108109        , isReady( false )
    109         , iAlign( 0 )
     110        , fixedAlignment( 0 )
    110111        , ConstructorMemberSubIndex( -1 )
    111112        , DestructorMemberSubIndex( -1 )
     
    123124        , pSuperClass( NULL )
    124125        , isReady( false )
    125         , iAlign( 0 )
     126        , fixedAlignment( 0 )
    126127        , ConstructorMemberSubIndex( -1 )
    127128        , DestructorMemberSubIndex( -1 )
     
    320321    }
    321322
     323    // ユーザ指定のアラインメント固定値
     324    int GetFixedAlignment() const
     325    {
     326        return fixedAlignment;
     327    }
     328    void SetFixedAlignment( int fixedAlignment )
     329    {
     330        this->fixedAlignment = fixedAlignment;
     331    }
     332
    322333    // メンバの総合サイズを取得
    323334    int GetSize() const;
  • trunk/abdev/BasicCompiler_Common/include/CodeGenerator.h

    r230 r232  
    4141    void __jmp_op_format( char opcode, long offset, int op_size );
    4242public:
    43     void op_mov_RV                  (int op_size,int reg,long i32data);
     43    void op_mov_RV                  (int op_size,int reg,long i32data, Schedule::Type scheduleType = Schedule::None );
    4444    void op_mov_RV64                (int reg,_int64 i64data);
    4545    void op_mov_RM                  (int op_size,int reg,int base_reg,long offset,char mod, Schedule::Type scheduleType = Schedule::None );
    4646    void op_mov_RM_ex               (int op_size,int reg,int base_reg1,int base_reg2,long offset,BOOL bUseOffset, Schedule::Type scheduleType = Schedule::None );
    47     void op_mov_MR                  (int op_size,int reg,int base_reg,long offset,char mod);
    48     void op_mov_MR_ex               (int op_size,int reg,int base_reg1,int base_reg2,long offset,BOOL bUseOffset);
     47    void op_mov_MR                  (int op_size,int reg,int base_reg,long offset,char mod, Schedule::Type scheduleType = Schedule::None );
     48    void op_mov_MR_ex               (int op_size,int reg,int base_reg1,int base_reg2,long offset,BOOL bUseOffset, Schedule::Type scheduleType = Schedule::None );
    4949    void op_mov_MV                  (int op_size,int base_reg,int offset,BOOL bUseOffset,long i32data);
    5050    void op_mov_RR                  (int reg1,int reg2);
    51     void op_mov64_ToReg             (int reg,_int64 i64data);
    52     void op_mov64_ToReg             (int reg,long i32data);
    5351    void op_movsxd                  (int reg64,int reg32);
    5452    void op_movsx64_FromReg16       (int reg64,int reg16);
     
    6159    void op_dec                     (int reg);
    6260    void op_add_RM                  (int op_size,int reg,int base_reg,int offset,char mod, Schedule::Type scheduleType = Schedule::None );
    63     void op_add_RV                  (int reg,long offset);
     61    void op_add_RV                  (int reg,long offset, Schedule::Type scheduleType = Schedule::None );
    6462    void op_add_RR              (int reg1,int reg2);
    6563    void op_add32_reg               (int reg1,int reg2);
     
    8684    void op_cmp_value               (int op_size,int reg,char byte_data);
    8785    void op_setne                   (int reg);
    88     void op_movlpd_MR               (int xmm_reg,int base_reg,int offset,char mod);
    89     void op_movlpd_RM               (int xmm_reg,int base_reg,int offset,char mod);
     86    void op_movlpd_MR               (int xmm_reg,int base_reg,int offset,char mod, Schedule::Type scheduleType = Schedule::None );
     87    void op_movlpd_RM               (int xmm_reg,int base_reg,int offset,char mod, Schedule::Type scheduleType = Schedule::None );
    9088    void op_movsd_RR                (int xmm_reg1,int xmm_reg2);
    91     void op_movsd_MR                (int xmm_reg,int base_reg,int offset,char mod);
     89    void op_movsd_MR                (int xmm_reg,int base_reg,int offset,char mod, Schedule::Type scheduleType = Schedule::None );
    9290    void op_movss_RR                (int xmm_reg1,int xmm_reg2);
    93     void op_movss_RM                (int xmm_reg,int base_reg,int offset,char mod);
    94     void op_movss_MR                (int xmm_reg,int base_reg,int offset,char mod);
     91    void op_movss_RM                (int xmm_reg,int base_reg,int offset,char mod, Schedule::Type scheduleType = Schedule::None );
     92    void op_movss_MR                (int xmm_reg,int base_reg,int offset,char mod, Schedule::Type scheduleType = Schedule::None );
    9593    void op_movd_RX                 (int reg,int xmm_reg);
    9694    void op_cvtsd2ss                (int xmm_reg1,int xmm_reg2);
  • trunk/abdev/BasicCompiler_Common/include/NativeCode.h

    r228 r232  
    88
    99void AddLocalVarAddrSchedule();
     10void ObpPlus( int step = 1 );
    1011
    1112class Schedule
     
    137138        extern int obp;
    138139        memcpy( OpBuffer + obp, codeBuffer, size );
    139         obp += size;
     140        ObpPlus( size );
    140141    }
    141142    void Put( const NativeCode &nativeCode )
     
    180181        extern int obp;
    181182        *((long *)(OpBuffer+obp))=l;
    182         obp+=sizeof(long);
     183        ObpPlus( sizeof(long) );
    183184    }
    184185    void Put( short s )
     
    196197        extern char *OpBuffer;
    197198        extern int obp;
    198         OpBuffer[obp++]=c;
     199        OpBuffer[obp]=c;
     200        ObpPlus();
    199201    }
    200202};
  • trunk/abdev/BasicCompiler_Common/src/Class.cpp

    r224 r232  
    581581    int offset = IsExistVirtualFunctions() ? PTR_SIZE : 0;
    582582
    583     int alignment;
    584     if(iAlign) alignment=iAlign;
    585     else alignment=1;
     583    int alignment = 1;
     584    if( GetFixedAlignment() )
     585    {
     586        alignment = GetFixedAlignment();
     587    }
    586588
    587589    int iMaxAlign=0;
     
    605607
    606608        //アラインメントを考慮
    607         if(iAlign&&iAlign<member_size){
     609        if(GetFixedAlignment()&&GetFixedAlignment()<member_size){
    608610            if(offset%alignment) offset+=alignment-(offset%alignment);
    609611        }
     
    667669    if(alignment==0) return 0;
    668670
    669     if(iAlign) alignment=iAlign;
     671    if(GetFixedAlignment()) alignment=GetFixedAlignment();
    670672
    671673    return alignment;
     
    12541256            }
    12551257
    1256             pobj_c->iAlign=iAlign;
     1258            pobj_c->SetFixedAlignment( iAlign );
    12571259
    12581260            pobj_c->Readed();
Note: See TracChangeset for help on using the changeset viewer.