Changeset 263 in dev for trunk


Ignore:
Timestamp:
Aug 5, 2007, 3:47:49 AM (17 years ago)
Author:
dai_9181
Message:
 
Location:
trunk/abdev
Files:
24 edited

Legend:

Unmodified
Added
Removed

  • trunk/abdev/BasicCompiler32/Compile_Object.cpp

    r259 r263  
    6161        if( subs.size() == 1 ){
    6262            char temporary[VN_SIZE];
    63             sprintf( temporary, "ActiveBasic.Core._System_TypeBase.Search(\"\",\"%s\"))", pobj_c->GetName().c_str() );
     63            sprintf( temporary, "_System_TypeBase_Search(\"\",\"%s\"))", pobj_c->GetName().c_str() );
    6464
    6565            Opcode_CallProc(temporary,

  • trunk/abdev/BasicCompiler32/Compile_ProcOp.cpp

    r261 r263  
    121121        };
    122122
    123         compiler.codeGenerator.PutOld( NativeCode( (const char *)Buffer_allrem, 178 ) );
     123        compiler.codeGenerator.PutOld( NativeCode( (const char *)Buffer_allrem, 178, false ) );
    124124    }
    125125    else if( userProc.GetName() == "_aullrem" ){
    … …  
    137137        };
    138138
    139         compiler.codeGenerator.PutOld( NativeCode( (const char *)Buffer_aullrem, 117 ) );
     139        compiler.codeGenerator.PutOld( NativeCode( (const char *)Buffer_aullrem, 117, false ) );
    140140    }
    141141    else if( userProc.GetName() == "_allmul" ){
    … …  
    145145        };
    146146
    147         compiler.codeGenerator.PutOld( NativeCode( (const char *)Buffer_allmul, 52 ) );
     147        compiler.codeGenerator.PutOld( NativeCode( (const char *)Buffer_allmul, 52, false ) );
    148148    }
    149149    else if( userProc.GetName() == "_alldiv" ){
    … …  
    153153        };
    154154
    155         compiler.codeGenerator.PutOld( NativeCode( (const char *)Buffer_alldiv, 170 ) );
     155        compiler.codeGenerator.PutOld( NativeCode( (const char *)Buffer_alldiv, 170, false ) );
    156156    }
    157157    else if( userProc.GetName() == "_aulldiv" ){
    … …  
    168168        };
    169169
    170         compiler.codeGenerator.PutOld( NativeCode( (const char *)Buffer_aulldiv, 104 ) );
     170        compiler.codeGenerator.PutOld( NativeCode( (const char *)Buffer_aulldiv, 104, false ) );
    171171    }
    172172    else if( userProc.GetName() == "_allshl" ){
    … …  
    176176        };
    177177
    178         compiler.codeGenerator.PutOld( NativeCode( (const char *)Buffer_allshl, 31 ) );
     178        compiler.codeGenerator.PutOld( NativeCode( (const char *)Buffer_allshl, 31, false ) );
    179179    }
    180180    else if( userProc.GetName() == "_allshr" ){
    … …  
    184184        };
    185185
    186         compiler.codeGenerator.PutOld( NativeCode( (const char *)Buffer_allshr, 33 ) );
     186        compiler.codeGenerator.PutOld( NativeCode( (const char *)Buffer_allshr, 33, false ) );
    187187    }
    188188    else if( userProc.GetName() == "_aullshr" ){
    … …  
    208208        };
    209209
    210         compiler.codeGenerator.PutOld( NativeCode( (const char *)Buffer_aullshr, 31 ) );
     210        compiler.codeGenerator.PutOld( NativeCode( (const char *)Buffer_aullshr, 31, false ) );
    211211    }
    212212    else{
    … …  
    744744
    745745    _compile_proc( &userProc );
     746
    746747/*
    747748    // ログを履く

  • trunk/abdev/BasicCompiler32/MakePeHdr.cpp

    r261 r263  
    239239
    240240    //コードと行番号の関係
    241     extern LINEINFO *pLineInfo;
    242     extern int MaxLineInfoNum;
    243     pLineInfo=(LINEINFO *)HeapAlloc(hHeap,0,1);
    244     MaxLineInfoNum=0;
     241    extern SourceLines oldSourceLines;
     242    oldSourceLines.clear();
    245243
    246244
    … …  
    887885
    888886    //機械語コードとBasicコードの関係を整理
    889     extern LINEINFO *pLineInfo;
    890     extern int MaxLineInfoNum;
     887    extern SourceLines oldSourceLines;
    891888    int MinObp,MaxObp;
    892     LINEINFO *pTempLineInfo;
    893     pTempLineInfo=(LINEINFO *)HeapAlloc(hHeap,0,MaxLineInfoNum*sizeof(LINEINFO));
    894     i2=0;
     889    SourceLines tempSourceLines;
    895890    MaxObp=0;
    896891    while(1){
    897         for(i3=0,MinObp=0x0FFFFFFF;i3<MaxLineInfoNum;i3++){
    898             if(pLineInfo[i3].TopObp<MinObp&&MaxObp<pLineInfo[i3].TopObp){
    899                 MinObp=pLineInfo[i3].TopObp;
     892        for(i3=0,MinObp=0x0FFFFFFF;i3<(int)oldSourceLines.size();i3++){
     893            if(oldSourceLines[i3].GetNativeCodePos()<MinObp&&MaxObp<oldSourceLines[i3].GetNativeCodePos()){
     894                MinObp=oldSourceLines[i3].GetNativeCodePos();
    900895                i4=i3;
    901896            }
    902897        }
    903898        if(MinObp==0x0FFFFFFF) break;
    904         pTempLineInfo[i2]=pLineInfo[i4];
    905         MaxObp=pTempLineInfo[i2].TopObp;
    906         i2++;
    907     }
    908     HeapDefaultFree(pLineInfo);
    909     pLineInfo=(LINEINFO *)HeapAlloc(hHeap,0,i2*sizeof(LINEINFO));
    910     memcpy(pLineInfo,pTempLineInfo,i2*sizeof(LINEINFO));
    911     MaxLineInfoNum=i2;
    912     HeapDefaultFree(pTempLineInfo);
     899        tempSourceLines.push_back( oldSourceLines[i4] );
     900        MaxObp=tempSourceLines.back().GetNativeCodePos();
     901    }
     902    oldSourceLines = tempSourceLines;
    913903
    914904    //デバッグセクションを生成
    … …  
    12161206    delete pobj_GlobalVarSchedule;
    12171207
    1218 /*
     1208
    12191209    compiler.linker.SetImageBase( ImageBase );
    12201210    compiler.linker.ResolveDataTableSchedules( MemPos_DataSection );
    12211211    compiler.linker.ResolveDllProcSchedules( MemPos_CodeSection, MemPos_ImportSection, LookupSize, HintSize );
    12221212    compiler.linker.ResolveUserProcSchedules( MemPos_CodeSection );
    1223     compiler.linker.ResolveDataTableSchedules( MemPos_RWSection );
    1224 */
     1213    compiler.linker.ResolveGlobalVarSchedules( MemPos_RWSection );
     1214
     1215    if( obp == compiler.linker.GetNativeCode().GetSize() )
     1216    {
     1217        //memcpy( OpBuffer, compiler.linker.GetNativeCode().GetCodeBuffer(), compiler.linker.GetNativeCode().GetSize() );
     1218    }
     1219    else
     1220    {
     1221        SetError();
     1222    }
     1223
    12251224
    12261225

  • trunk/abdev/BasicCompiler64/Compile_Object.cpp

    r262 r263  
    6060        if( subs.size() == 1 ){
    6161            char temporary[VN_SIZE];
    62             sprintf( temporary, "ActiveBasic.Core._System_TypeBase.Search(\"\",\"%s\"))", pobj_c->GetName().c_str() );
     62            sprintf( temporary, "_System_TypeBase_Search(\"\",\"%s\"))", pobj_c->GetName().c_str() );
    6363
    6464            Opcode_CallProc(temporary,
    … …  
    258258
    259259    //jnzの番地
    260     int jnz_back;
    261     jnz_back=obp;
     260    //int jnz_back=obp;
    262261
    263262    //mov qword ptr[rsp+offset],rcx     ※スタックフレームを利用
    … …  
    280279
    281280    //jnz ↑
    282     compiler.codeGenerator.op_jne( jnz_back-obp, sizeof(long), false, true );
     281    //compiler.codeGenerator.op_jne( jnz_back-obp, sizeof(long), false, true );
    283282
    284283

  • trunk/abdev/BasicCompiler64/Compile_ProcOp.cpp

    r262 r263  
    140140        && userProc.HasParentClass()
    141141        && userProc.GetParentClass().GetName() == "_System_TypeBase" ){
    142 
    143142            compiler.objectModule.meta.GetClasses().Compile_System_InitializeUserTypes();
    144143    }
    … …  
    670669
    671670
    672     pUserProc->SetEndOpAddress( obp );
     671    pUserProc->_endOpAddressOld = obp;
    673672
    674673

  • trunk/abdev/BasicCompiler64/Compile_Statement.cpp

    r262 r263  
    272272        {
    273273            //jmp ...(schedule)
    274             extern int obp;
    275274            compiler.codeGenerator.op_jmp_goto_schedule( (const std::string)(Parameter + 1), 0, cp );
    276275        }
    … …  
    289288        {
    290289            //jmp ...(schedule)
    291             extern int obp;
    292290            compiler.codeGenerator.op_jmp_goto_schedule( "", LineNum, cp );
    293291        }

  • trunk/abdev/BasicCompiler64/MakePeHdr.cpp

    r262 r263  
    222222
    223223    //コードと行番号の関係
    224     extern LINEINFO *pLineInfo;
    225     extern int MaxLineInfoNum;
    226     pLineInfo=(LINEINFO *)HeapAlloc(hHeap,0,1);
    227     MaxLineInfoNum=0;
     224    extern SourceLines oldSourceLines;
     225    oldSourceLines.clear();
    228226
    229227
    … …  
    387385
    388386        //未完成
    389         //OpBuffer[obp++]=(char)0xCC;
     387        //breakpoint;
    390388
    391389        //sub rsp,スタックフレームサイズ
    … …  
    503501    //////////////////////////////////////////////////////////
    504502
     503
     504
     505    trace( "コード生成が終了しました。" );
     506
     507    vector<ObjectModule *> masterObjectModules;
     508    masterObjectModules.push_back( &compiler.objectModule );
     509    compiler.linker.Link( masterObjectModules );
    505510
    506511
    … …  
    836841
    837842    //機械語コードとBasicコードの関係を整理
    838     extern LINEINFO *pLineInfo;
    839     extern int MaxLineInfoNum;
     843    extern SourceLines oldSourceLines;
    840844    int MinObp,MaxObp;
    841     LINEINFO *pTempLineInfo;
    842     pTempLineInfo=(LINEINFO *)HeapAlloc(hHeap,0,MaxLineInfoNum*sizeof(LINEINFO));
    843     i2=0;
     845    SourceLines tempSourceLines;
    844846    MaxObp=0;
    845847    while(1){
    846         for(i3=0,MinObp=0x0FFFFFFF;i3<MaxLineInfoNum;i3++){
    847             if(pLineInfo[i3].TopObp<MinObp&&MaxObp<pLineInfo[i3].TopObp){
    848                 MinObp=pLineInfo[i3].TopObp;
     848        for(i3=0,MinObp=0x0FFFFFFF;i3<oldSourceLines.size();i3++){
     849            if(oldSourceLines[i3].GetNativeCodePos()<MinObp&&MaxObp<oldSourceLines[i3].GetNativeCodePos()){
     850                MinObp=oldSourceLines[i3].GetNativeCodePos();
    849851                i4=i3;
    850852            }
    851853        }
    852854        if(MinObp==0x0FFFFFFF) break;
    853         pTempLineInfo[i2]=pLineInfo[i4];
    854         MaxObp=pTempLineInfo[i2].TopObp;
    855         i2++;
    856     }
    857     HeapDefaultFree(pLineInfo);
    858     pLineInfo=(LINEINFO *)HeapAlloc(hHeap,0,i2*sizeof(LINEINFO));
    859     memcpy(pLineInfo,pTempLineInfo,i2*sizeof(LINEINFO));
    860     MaxLineInfoNum=i2;
    861     HeapDefaultFree(pTempLineInfo);
     855        tempSourceLines.push_back( oldSourceLines[i4] );
     856        MaxObp=tempSourceLines.back().GetNativeCodePos();
     857    }
     858    oldSourceLines = tempSourceLines;
    862859
    863860    //デバッグセクションを生成
    … …  
    11651162
    11661163
     1164
     1165    compiler.linker.SetImageBase( ImageBase );
     1166    compiler.linker.ResolveDataTableSchedules( MemPos_DataSection );
     1167    compiler.linker.ResolveDllProcSchedules( MemPos_CodeSection, MemPos_ImportSection, LookupSize, HintSize );
     1168    compiler.linker.ResolveUserProcSchedules( MemPos_CodeSection );
     1169    compiler.linker.ResolveGlobalVarSchedules( MemPos_RWSection );
     1170
     1171    if( obp == compiler.linker.GetNativeCode().GetSize() )
     1172    {
     1173        memcpy( OpBuffer, compiler.linker.GetNativeCode().GetCodeBuffer(), compiler.linker.GetNativeCode().GetSize() );
     1174    }
     1175    else
     1176    {
     1177        SetError();
     1178    }
     1179
     1180
    11671181    ////////////////////////////////
    11681182    // リソースアドレススケジュール

  • trunk/abdev/BasicCompiler64/Opcode.h

    r262 r263  
    4545
    4646
    47 class CStackFrame:public CSchedule{
     47class CStackFrame
     48{
    4849    ///////////////////////////
    4950    // スタックフレーム管理
    5051    ///////////////////////////
     52
     53    PertialSchedules pertialSchedules;
    5154
    5255    int lowest_sp;          //スタックポインタの最下位位置

  • trunk/abdev/BasicCompiler64/stack_frame.cpp

    r232 r263  
    3939
    4040    //add reg,now_sp
    41     compiler.codeGenerator.op_add_RV( reg, now_sp );
    42 
    43     //スケジュールをセット
    44     obp-=sizeof(long);
    45     add();
    46     obp+=sizeof(long);
     41    pertialSchedules.push_back(
     42        compiler.codeGenerator.op_add_RV( reg, now_sp, Schedule::None, true )
     43    );
    4744}
    4845int CStackFrame::push(int reg){
    … …  
    5350
    5451    //mov qword ptr[rsp+offset],reg
    55     compiler.codeGenerator.op_mov_MR(sizeof(_int64),reg,REG_RSP,now_sp,MOD_BASE_DISP32);
    56 
    57     //スケジュールをセット
    58     obp-=sizeof(long);
    59     add();
    60     obp+=sizeof(long);
     52    pertialSchedules.push_back(
     53        compiler.codeGenerator.op_mov_MR(sizeof(_int64),reg,REG_RSP,now_sp,MOD_BASE_DISP32, Schedule::None, true)
     54    );
    6155
    6256    return now_sp;
    … …  
    6862    if(varSize==sizeof(double)){
    6963        //movlpd qword ptr[rsp+offset],xmm_reg
    70         compiler.codeGenerator.op_movlpd_MR(xmm_reg,REG_RSP,now_sp,MOD_BASE_DISP32);
     64        pertialSchedules.push_back(
     65            compiler.codeGenerator.op_movlpd_MR(xmm_reg,REG_RSP,now_sp,MOD_BASE_DISP32, Schedule::None, true )
     66        );
    7167    }
    7268    if(varSize==sizeof(float)){
    7369        //movss dword ptr[rsp+offset],xmm_reg
    74         compiler.codeGenerator.op_movss_MR( xmm_reg, REG_RSP, now_sp, MOD_BASE_DISP32 );
     70        pertialSchedules.push_back(
     71            compiler.codeGenerator.op_movss_MR( xmm_reg, REG_RSP, now_sp, MOD_BASE_DISP32, Schedule::None, true )
     72        );
    7573    }
    76 
    77     //スケジュールをセット
    78     obp-=sizeof(long);
    79     add();
    80     obp+=sizeof(long);
    8174}
    8275void CStackFrame::ref_offset_data( int reg, int sp_offset ){
    8376    //mov reg,qword ptr[rsp+offset]     ※スタックフレームを利用
    84     compiler.codeGenerator.op_mov_RM(sizeof(_int64),reg,REG_RSP,sp_offset,MOD_BASE_DISP32);
    85 
    86     //スケジュールをセット
    87     obp-=sizeof(long);
    88     add();
    89     obp+=sizeof(long);
     77    pertialSchedules.push_back(
     78        compiler.codeGenerator.op_mov_RM(sizeof(_int64),reg,REG_RSP,sp_offset,MOD_BASE_DISP32, Schedule::None, true )
     79    );
    9080}
    9181void CStackFrame::ref(int reg){
    … …  
    9585    if(varSize==sizeof(double)){
    9686        //movlpd xmm_reg,qword ptr[rsp+offset]
    97         compiler.codeGenerator.op_movlpd_RM(xmm_reg,REG_RSP,now_sp,MOD_BASE_DISP32);
     87        pertialSchedules.push_back(
     88            compiler.codeGenerator.op_movlpd_RM(xmm_reg,REG_RSP,now_sp,MOD_BASE_DISP32, Schedule::None, true )
     89        );
    9890    }
    9991    if(varSize==sizeof(float)){
    10092        //movss xmm_reg,dword ptr[rsp+offset]
    101         compiler.codeGenerator.op_movss_MR( xmm_reg, REG_RSP, now_sp, MOD_BASE_DISP32 );
     93        pertialSchedules.push_back(
     94            compiler.codeGenerator.op_movss_MR( xmm_reg, REG_RSP, now_sp, MOD_BASE_DISP32, Schedule::None, true )
     95        );
    10296    }
    103 
    104     //スケジュールをセット
    105     obp-=sizeof(long);
    106     add();
    107     obp+=sizeof(long);
    10897}
    10998void CStackFrame::pop(int reg){
    … …  
    121110}
    122111void CStackFrame::RunningSchedule( int stackFrameSize ){
    123     for(int i=0;i<num;i++){
    124         *((long *)(OpBuffer+pObpValues[i])) += stackFrameSize;
     112    BOOST_FOREACH( const PertialSchedule *pPertialSchedule, pertialSchedules )
     113    {
     114        compiler.codeGenerator.opfix_offset( pPertialSchedule, stackFrameSize );
    125115    }
    126116}

  • trunk/abdev/BasicCompiler_Common/BasicCompiler.h

    r209 r263  
    5757char szDebugExeForDll[1024];
    5858
    59 //デバッグ用行番号情報
    60 LINEINFO *pLineInfo;
    61 int MaxLineInfoNum;
    62 
    6359//ウォッチリスト
    6460int width_WatchColumn_Expression=200;

  • trunk/abdev/BasicCompiler_Common/BreakPoint.cpp

    r256 r263  
    33#include <jenga/include/common/Environment.h>
    44#include <jenga/include/smoothie/Source.h>
     5
     6#include <Compiler.h>
    57
    68#include "common.h"
    … …  
    6971
    7072        if(i2==piLine[nCount]){
    71             extern int MaxLineInfoNum;
    72             extern LINEINFO *pLineInfo;
     73            extern SourceLines oldSourceLines;
    7374
    7475loop:
    … …  
    7778
    7879            int i3;
    79             for(i3=0;i3<MaxLineInfoNum-1;i3++){
    80                 if(pLineInfo[i3].TopCp==tempCp) break;
     80            for(i3=0;i3<(int)oldSourceLines.size()-1;i3++){
     81                if(oldSourceLines[i3].GetSourceCodePos()==tempCp) break;
    8182            }
    82             if(i3==MaxLineInfoNum-1){
     83            if(i3==oldSourceLines.size()-1){
    8384                i2--;
    8485                goto loop;
    8586            }
    8687
    87             nativeCodeBuffer[pLineInfo[i3].TopObp]=(char)0xCC;
     88            nativeCodeBuffer[oldSourceLines[i3].GetNativeCodePos()]=(char)0xCC;
    8889
    8990            nCount++;

  • trunk/abdev/BasicCompiler_Common/Compile.cpp

    r261 r263  
    2525//With情報
    2626WITHINFO WithInfo;
     27
     28//デバッグ用行番号情報
     29SourceLines oldSourceLines;
    2730
    2831
    … …  
    8083
    8184void NextLine(void){
    82     extern HANDLE hHeap;
    83     extern int MaxLineInfoNum;
    84     extern LINEINFO *pLineInfo;
    85     if(MaxLineInfoNum){
    86         extern int obp;
    87         if(pLineInfo[MaxLineInfoNum-1].TopObp==obp){
    88             pLineInfo[MaxLineInfoNum-1].TopCp=cp;
     85    extern int obp;
     86
     87    extern SourceLines oldSourceLines;
     88    if( oldSourceLines.size() )
     89    {
     90        if( oldSourceLines.back().GetNativeCodePos() == obp )
     91        {
     92            oldSourceLines.back().SetSourceCodePos( cp );
    8993            return;
    9094        }
    9195    }
    92     pLineInfo=(LINEINFO *)HeapReAlloc(hHeap,0,pLineInfo,(MaxLineInfoNum+1)*sizeof(LINEINFO));
    93     pLineInfo[MaxLineInfoNum].TopCp=cp;
    94     extern int obp;
    95     pLineInfo[MaxLineInfoNum].TopObp=obp;
    9696
    9797    extern BOOL bDebugSupportProc;
    9898    extern BOOL bSystemProc;
    99     pLineInfo[MaxLineInfoNum].dwCodeType=0;
    100     if(bDebugSupportProc)
    101         pLineInfo[MaxLineInfoNum].dwCodeType|=CODETYPE_DEBUGPROC;
    102     if(bSystemProc)
    103         pLineInfo[MaxLineInfoNum].dwCodeType|=CODETYPE_SYSTEMPROC;
    104 
    105     MaxLineInfoNum++;
     99    DWORD sourceLineType = 0;
     100    if( bDebugSupportProc )
     101    {
     102        sourceLineType |= CODETYPE_DEBUGPROC;
     103    }
     104    if( bSystemProc )
     105    {
     106        sourceLineType |= CODETYPE_SYSTEMPROC;
     107    }
     108    oldSourceLines.push_back( SourceLine( (long)oldSourceLines.size(), obp, cp, sourceLineType ) );
    106109}
    107110
    … …  
    334337                breakpoint;
    335338            }
    336 #if defined(_DEBUG)
    337339            else
    338340            {
     341//#if defined(_DEBUG)
    339342                breakpoint;
    340             }
    341 #endif
     343//#endif
     344            }
    342345            break;
    343346
    … …  
    637640
    638641            NextLine();
     642            compiler.codeGenerator.NextSourceLine();
    639643
    640644            if(Command[0]==1){

  • trunk/abdev/BasicCompiler_Common/Debug.cpp

    r259 r263  
    7979
    8080        if(i2==iLineNum){
    81             extern int MaxLineInfoNum;
    82             extern LINEINFO *pLineInfo;
     81            extern SourceLines oldSourceLines;
    8382
    8483loop:
    … …  
    8786
    8887            int i3;
    89             for(i3=0;i3<MaxLineInfoNum-1;i3++){
    90                 if(pLineInfo[i3].TopCp==tempCp) break;
    91             }
    92             if(i3==MaxLineInfoNum-1){
     88            for(i3=0;i3<(int)oldSourceLines.size()-1;i3++){
     89                if(oldSourceLines[i3].GetSourceCodePos()==tempCp) break;
     90            }
     91            if(i3==oldSourceLines.size()-1){
    9392                i2--;
    9493                goto loop;
    9594            }
    9695
    97             StepCursorObpSchedule=pLineInfo[i3].TopObp;
     96            StepCursorObpSchedule=oldSourceLines[i3].GetNativeCodePos();
    9897            StepCursor_BackupChar=pobj_DBDebugSection->pobj_now->BreakStepCodeBuffer[StepCursorObpSchedule];
    9998

  • trunk/abdev/BasicCompiler_Common/DebugMiddleFile.cpp

    r259 r263  
    9898    // コードと行番号の関係
    9999    ////////////////////////
    100     extern int MaxLineInfoNum;
    101     extern LINEINFO *pLineInfo;
    102 
    103     //バッファが足りない場合は再確保
    104     if(MaxLineInfoNum*sizeof(LINEINFO)<32768) i3=32768;
    105     else i3=MaxLineInfoNum*sizeof(LINEINFO)+32768;
    106     if(BufferSize<i2+i3){
    107         BufferSize+=i3;
    108         buffer=(char *)HeapReAlloc(hHeap,0,buffer,BufferSize);
    109     }
    110 
    111     *(long *)(buffer+i2)=MaxLineInfoNum;
    112     i2+=sizeof(long);
    113     memcpy(buffer+i2,pLineInfo,MaxLineInfoNum*sizeof(LINEINFO));
    114     i2+=MaxLineInfoNum*sizeof(LINEINFO);
     100    extern SourceLines oldSourceLines;
     101
     102    *(long *)(buffer+i2)=(long)oldSourceLines.size();
     103    i2+=sizeof(long);
     104    BOOST_FOREACH( const SourceLine &sourceLine, oldSourceLines )
     105    {
     106        *(long *)(buffer+i2) = sourceLine.GetLineNum();
     107        i2+=sizeof(long);
     108
     109        *(long *)(buffer+i2) = sourceLine.GetNativeCodePos();
     110        i2+=sizeof(long);
     111
     112        *(long *)(buffer+i2) = sourceLine.GetSourceCodePos();
     113        i2+=sizeof(long);
     114
     115        *(long *)(buffer+i2) = sourceLine.GetCodeType();
     116        i2+=sizeof(long);
     117
     118        //バッファが足りない場合は再確保
     119        if(BufferSize<i2+32768){
     120            BufferSize+=32768;
     121            buffer=(char *)HeapReAlloc(hHeap,0,buffer,BufferSize);
     122        }
     123    }
    115124
    116125
    … …  
    431440    memcpy(buffer,OpBuffer,SizeOf_CodeSection);
    432441
    433     int i2;
    434     for(i2=0;i2<MaxLineInfoNum;i2++){
     442    BOOST_FOREACH( const SourceLine &sourceLine, oldSourceLines )
     443    {
    435444        if(!(
    436             pLineInfo[i2].dwCodeType&CODETYPE_SYSTEMPROC||
    437             pLineInfo[i2].dwCodeType&CODETYPE_DEBUGPROC
    438             )){
     445            sourceLine.IsInSystemProc()
     446            || sourceLine.IsInDebugProc() ) )
     447        {
    439448            //int 3
    440             buffer[pLineInfo[i2].TopObp]=(char)0xCC;
     449            buffer[sourceLine.GetNativeCodePos()]=(char)0xCC;
    441450        }
    442451    }
    … …  
    487496
    488497    //コードと行番号の関係
    489     MaxLineInfoNum=*(long *)(buffer+i2);
    490     i2+=sizeof(long);
    491     pLineInfo=(LINEINFO *)HeapAlloc(hHeap,0,MaxLineInfoNum*sizeof(LINEINFO)+1);
    492     memcpy(pLineInfo,buffer+i2,MaxLineInfoNum*sizeof(LINEINFO));
    493     i2+=MaxLineInfoNum*sizeof(LINEINFO);
     498    int maxLineInfoNum;
     499    maxLineInfoNum=*(long *)(buffer+i2);
     500    i2+=sizeof(long);
     501    for(i3=0;i3<maxLineInfoNum;i3++){
     502        int lineNum = *(long *)(buffer+i2);
     503        i2+=sizeof(long);
     504
     505        int nativeCodePos = *(long *)(buffer+i2);
     506        i2+=sizeof(long);
     507
     508        int sourceCodePos = *(long *)(buffer+i2);
     509        i2+=sizeof(long);
     510
     511        DWORD sourceLineType = *(DWORD *)(buffer+i2);
     512        i2+=sizeof(long);
     513
     514        oldSourceLines.push_back( SourceLine( lineNum, nativeCodePos, sourceCodePos, sourceLineType ) );
     515    }
    494516
    495517
    … …  
    837859
    838860    //コードと行番号の関係
    839     extern int MaxLineInfoNum;
    840     extern LINEINFO *pLineInfo;
    841     MaxLineInfoNum=this->MaxLineInfoNum;
    842     pLineInfo=this->pLineInfo;
     861    extern SourceLines oldSourceLines;
     862    oldSourceLines = this->oldSourceLines;
    843863
    844864    BreakStepCodeBuffer=pobj_DBBreakPoint->update(OpBuffer,SizeOf_CodeSection);
    … …  
    956976
    957977    //コードと行番号の関係
    958     extern int MaxLineInfoNum;
    959     extern LINEINFO *pLineInfo;
    960     MaxLineInfoNum=this->MaxLineInfoNum;
    961     pLineInfo=this->pLineInfo;
     978    extern SourceLines oldSourceLines;
     979    oldSourceLines = this->oldSourceLines;
    962980
    963981    // クラス情報
    … …  
    9961014    delete this->pobj_DBClass;
    9971015    this->pobj_DBClass=0;
    998 
    999     //コードと行番号の関係を解放
    1000     HeapDefaultFree(pLineInfo);
    10011016
    10021017    //コードバッファを解放

  • trunk/abdev/BasicCompiler_Common/DebugSection.h

    r206 r263  
    33#include <jenga/include/smoothie/Source.h>
    44
    5 #include <Class.h>
    6 #include <Procedure.h>
    7 #include <Const.h>
    8 
     5#include <Compiler.h>
    96
    107class CDebugSection{
    … …  
    2926    int SizeOf_CodeSection;
    3027
     28    // オブジェクトモジュール
     29    ObjectModule objectModule;
     30
    3131    //インクルード情報
    3232    INCLUDEFILEINFO IncludeFileInfo;
    … …  
    3636
    3737    //コードと行番号の関係
    38     int MaxLineInfoNum;
    39     LINEINFO *pLineInfo;
     38    SourceLines oldSourceLines;
    4039
    4140    // クラス情報

  • trunk/abdev/BasicCompiler_Common/MakeExe.cpp

    r256 r263  
    160160    HeapDefaultFree(pBitmapResourceInfo);
    161161    HeapDefaultFree(pIconResourceInfo);
    162 
    163     //コードと行番号の関係情報を解放
    164     extern LINEINFO *pLineInfo;
    165     HeapDefaultFree(pLineInfo);
    166162
    167163    //コンパイルダイアログのプログレスバーを上げる

  • trunk/abdev/BasicCompiler_Common/VarList.cpp

    r259 r263  
    569569
    570570    //行番号情報
    571     extern int MaxLineInfoNum;
    572     extern LINEINFO *pLineInfo;
     571    extern SourceLines oldSourceLines;
    573572    for(i3=0;i3<(int)pobj_dti->iProcLevel+1;i3++){
    574         for(i2=0;i2<MaxLineInfoNum-1;i2++){
    575             if((ULONG_PTR)(pLineInfo[i2].TopObp+ImageBase+MemPos_CodeSection)<=pobj_dti->lplpObp[i3]&&
    576                 pobj_dti->lplpObp[i3]<=(ULONG_PTR)(pLineInfo[i2+1].TopObp+ImageBase+MemPos_CodeSection)) break;
    577         }
    578         if(i2==MaxLineInfoNum) pobj_dti->lpdwCp[i3]=-1;
    579         else pobj_dti->lpdwCp[i3]=pLineInfo[i2].TopCp;
     573        for(i2=0;i2<(int)oldSourceLines.size()-2;i2++){
     574            if((ULONG_PTR)(oldSourceLines[i2].GetNativeCodePos()+ImageBase+MemPos_CodeSection)<=pobj_dti->lplpObp[i3]&&
     575                pobj_dti->lplpObp[i3]<=(ULONG_PTR)(oldSourceLines[i2+1].GetNativeCodePos()+ImageBase+MemPos_CodeSection)) break;
     576        }
     577        if(i2==oldSourceLines.size()-1) pobj_dti->lpdwCp[i3]=-1;
     578        else pobj_dti->lpdwCp[i3]=oldSourceLines[i2].GetSourceCodePos();
    580579    }
    581580    for(i3=0;i3<(int)pobj_dti->iProcLevel+1;i3++){

  • trunk/abdev/BasicCompiler_Common/common.h

    r254 r263  
    140140
    141141
    142 #define CODETYPE_SYSTEMPROC     0x0001
    143 #define CODETYPE_DEBUGPROC      0x0002
    144 struct LINEINFO{
    145     int TopCp;
    146     int TopObp;
    147     DWORD dwCodeType;
    148 };
    149142struct RESOURCEDATAINFO{
    150143    DWORD dwId;

  • trunk/abdev/BasicCompiler_Common/include/CodeGenerator.h

    r262 r263  
    238238        }
    239239        pNativeCode = &nativeCode;
     240    }
     241
     242    void NextSourceLine()
     243    {
     244        pNativeCode->NextSourceLine();
    240245    }
    241246

  • trunk/abdev/BasicCompiler_Common/include/Linker.h

    r258 r263  
    4141    }
    4242
     43    const NativeCode &GetNativeCode() const
     44    {
     45        return nativeCode;
     46    }
     47
    4348    void SetImageBase( DWORD imageBase )
    4449    {

  • trunk/abdev/BasicCompiler_Common/include/NativeCode.h

    r258 r263  
    112112typedef std::vector<Schedule> Schedules;
    113113
     114#define CODETYPE_SYSTEMPROC     0x0001
     115#define CODETYPE_DEBUGPROC      0x0002
     116class SourceLine
     117{
     118    int lineNum;
     119    long nativeCodePos;
     120    long sourceCodePos;
     121    DWORD codeType;
     122
     123    // XMLシリアライズ用
     124private:
     125    friend class boost::serialization::access;
     126    template<class Archive> void serialize(Archive& ar, const unsigned int version)
     127    {
     128        trace_for_serialize( "serializing - SourceLine" );
     129
     130        ar & BOOST_SERIALIZATION_NVP( lineNum );
     131        ar & BOOST_SERIALIZATION_NVP( nativeCodePos );
     132        ar & BOOST_SERIALIZATION_NVP( sourceCodePos );
     133        ar & BOOST_SERIALIZATION_NVP( codeType );
     134    }
     135
     136public:
     137    SourceLine( int lineNum, int nativeCodePos, int sourceCodePos, DWORD codeType )
     138        : lineNum( lineNum )
     139        , nativeCodePos( nativeCodePos )
     140        , sourceCodePos( sourceCodePos )
     141        , codeType( codeType )
     142    {
     143    }
     144    SourceLine()
     145    {
     146    }
     147
     148    int GetLineNum() const
     149    {
     150        return lineNum;
     151    }
     152    long GetNativeCodePos() const
     153    {
     154        return nativeCodePos;
     155    }
     156    long GetSourceCodePos() const
     157    {
     158        return sourceCodePos;
     159    }
     160    void SetSourceCodePos( int sourceCodePos )
     161    {
     162        this->sourceCodePos = sourceCodePos;
     163    }
     164    DWORD GetCodeType() const
     165    {
     166        return codeType;
     167    }
     168    bool IsInSystemProc() const
     169    {
     170        return ( (codeType&CODETYPE_SYSTEMPROC) != 0 );
     171    }
     172    bool IsInDebugProc() const
     173    {
     174        return ( (codeType&CODETYPE_DEBUGPROC) != 0 );
     175    }
     176};
     177typedef std::vector<SourceLine> SourceLines;
     178
    114179class NativeCode
    115180{
    … …  
    118183    int size;
    119184
     185    // リンカで解決しなければならないスケジュール
    120186    Schedules schedules;
     187
     188    // ソースコード行番号とネイティブコード位置の対応情報
     189    SourceLines sourceLines;
    121190
    122191    // XMLシリアライズ用
    … …  
    132201        ar & BOOST_SERIALIZATION_NVP( size );
    133202        ar & BOOST_SERIALIZATION_NVP( schedules );
     203        ar & BOOST_SERIALIZATION_NVP( sourceLines );
    134204
    135205        // 読み込み後の処理
    … …  
    163233        ar & BOOST_SERIALIZATION_NVP( size );
    164234        ar & BOOST_SERIALIZATION_NVP( schedules );
     235        ar & BOOST_SERIALIZATION_NVP( sourceLines );
    165236    }
    166237
    … …  
    192263        Put( nativeCode, isOpBuffer );
    193264    }
    194     NativeCode( const char *codeBuffer, int size )
     265    NativeCode( const char *codeBuffer, int size, bool isOpBuffer )
    195266        : allocateSize( 8192 )
    196267        , codeBuffer( (char *)malloc( allocateSize ) )
    197268        , size( 0 )
    198269    {
    199         Put( codeBuffer, size );
     270        Put( codeBuffer, size, isOpBuffer );
    200271    }
    201272    ~NativeCode()
    … …  
    214285    }
    215286
     287    const char *GetCodeBuffer() const
     288    {
     289        return codeBuffer;
     290    }
    216291    int GetSize() const
    217292    {
    … …  
    332407        ObpPlus();
    333408    }
     409
     410    void NextSourceLine();
    334411};

  • trunk/abdev/BasicCompiler_Common/src/Class.cpp

    r259 r263  
    737737        pUserProc=(UserProc *)pVtbl[i];
    738738        if(!pUserProc) continue;
    739         pVtbl[i]=pUserProc->_beginOpAddressOld+ImageBase+MemPos_CodeSection;
     739
     740        // 古いOpBufferを利用する場合は_beginOpAddressOldでないとダメ
     741        //pVtbl[i]=pUserProc->_beginOpAddressOld+ImageBase+MemPos_CodeSection;
     742        pVtbl[i]=pUserProc->GetBeginOpAddress()+ImageBase+MemPos_CodeSection;
    740743    }
    741744}

  • trunk/abdev/BasicCompiler_Common/src/Linker.cpp

    r258 r263  
    2626        if( schedule.GetType() == Schedule::DllProc )
    2727        {
    28 #ifdef _AMD64
     28#ifdef _AMD64_
    2929            nativeCode.Overwrite(
    3030                schedule.GetOffset(),
    … …  
    103103void Linker::Link( vector<ObjectModule *> &objectModules )
    104104{
     105    // nativeCodeは初期状態でなければならない
     106    if( nativeCode.GetSize() > 0 )
     107    {
     108        SetError();
     109    }
     110
    105111    /*
    106112    BOOST_FOREACH( ObjectModule *pObjectModule, objectModules )

  • trunk/abdev/BasicCompiler_Common/src/NativeCode.cpp

    r258 r263  
    2222    long baseOffset = size;
    2323
     24    // コードバッファを追加
    2425    Put( nativeCode.codeBuffer, nativeCode.size, isOpBuffer );
    2526
     27    // スケジュールを追加
    2628    BOOST_FOREACH( const Schedule &schedule, nativeCode.schedules )
    2729    {
    … …  
    3133                baseOffset + schedule.GetOffset(),
    3234                schedule.GetLongPtrValue()
     35            )
     36        );
     37    }
     38
     39    // ソースコード行番号とネイティブコード位置の対応情報を追加
     40    BOOST_FOREACH( const SourceLine &sourceLine, nativeCode.sourceLines )
     41    {
     42        this->sourceLines.push_back(
     43            SourceLine(
     44                sourceLine.GetLineNum(),
     45                baseOffset + sourceLine.GetNativeCodePos(),
     46                sourceLine.GetSourceCodePos(),
     47                sourceLine.GetCodeType()
    3348            )
    3449        );
    … …  
    85100    ObpPlus( sizeof(long) );
    86101}
     102
     103void NativeCode::NextSourceLine()
     104{
     105    if( sourceLines.size() )
     106    {
     107        if( sourceLines.back().GetNativeCodePos() == size )
     108        {
     109            sourceLines.back().SetSourceCodePos( cp );
     110            return;
     111        }
     112    }
     113
     114    extern BOOL bDebugSupportProc;
     115    extern BOOL bSystemProc;
     116    DWORD sourceLineType = 0;
     117    if( bDebugSupportProc )
     118    {
     119        sourceLineType |= CODETYPE_DEBUGPROC;
     120    }
     121    if( bSystemProc )
     122    {
     123        sourceLineType |= CODETYPE_SYSTEMPROC;
     124    }
     125    sourceLines.push_back( SourceLine( (long)sourceLines.size(), size, cp, sourceLineType ) );
     126}
Note: See TracChangeset for help on using the changeset viewer.