source: dev/trunk/ab5.0/abdev/BasicCompiler_Common/DebugMiddleFile.cpp@ 612

#include "stdafx.h"

#include "../BasicCompiler_Common/DebugSection.h"

#ifdef _AMD64_
#include "../compiler_x64/opcode.h"
#else
#include "../compiler_x86/opcode.h"
#endif

#define MDLFILE_VER 0x70000003

using namespace ActiveBasic::Compiler;


void SetLpIndex_DebugFile(char *buffer,int *p,const Type &type){
    if(NATURAL_TYPE(type.GetBasicType())==DEF_OBJECT || NATURAL_TYPE(type.GetBasicType())==DEF_STRUCT){
        lstrcpy(buffer+(*p),type.GetClass().GetName().c_str());
        (*p)+=lstrlen(buffer+(*p))+1;
    }
    else{
        *(LONG_PTR *)(buffer+(*p))=type.GetIndex();
        (*p)+=sizeof(LONG_PTR);
    }
}


void GetLpIndex_DebugFile(char *buffer,int *p,Type &type){
    if(NATURAL_TYPE(type.GetBasicType())==DEF_OBJECT || NATURAL_TYPE(type.GetBasicType())==DEF_STRUCT){
        char szClassName[VN_SIZE];
        lstrcpy(szClassName,buffer+(*p));
        (*p)+=lstrlen(buffer+(*p))+1;

        type.SetClassPtr(
            compiler.GetObjectModule().meta.GetClasses().FindEx( LexicalAnalyzer::FullNameToSymbol( szClassName ) )
        );
    }
    else{
        type.SetIndex( *(LONG_PTR *)(buffer+(*p)) );
        (*p)+=sizeof(LONG_PTR);
    }
}



CDebugSection::~CDebugSection(){
    if(dwImageBase) DeleteDebugInfo();
    if(buffer){
        HeapDefaultFree(buffer);
        buffer=0;
    }
}
void CDebugSection::make(void){
    int i2,BufferSize;

    if(buffer){
        HeapDefaultFree(buffer);
        buffer=0;
    }

    i2=0;

    extern char *basbuf;
    BufferSize=lstrlen(basbuf)+65535;
    buffer=(char *)HeapAlloc(hHeap,0,BufferSize);

    //デバッグ用ファイルのバージョン
    *(long *)(buffer+i2)=MDLFILE_VER;
    i2+=sizeof(long);

    //プラットフォームのビット数
    *(long *)(buffer+i2)=PLATFORM;
    i2+=sizeof(long);


    // オブジェクトモジュール
    {
        // テキストデータにシリアライズ
        std::string textString;
        compiler.GetObjectModule().WriteString( textString );

        // サイズ
        *(long *)(buffer+i2) = (long)textString.size();
        i2+=sizeof(long);

        //バッファが足りない場合は再確保
        if(BufferSize<i2+(int)textString.size()+32768){
            while( BufferSize<i2+(int)textString.size()+32768 )
            {
                BufferSize+=32768;
            }

            buffer=(char *)HeapReAlloc(hHeap,0,buffer,BufferSize);
        }

        // バッファ
        memcpy( buffer+i2, textString.c_str(), textString.size() );
        i2 += (int)textString.size();
    }


    ////////////////////////
    // コードと行番号の関係
    ////////////////////////
    extern SourceLines oldSourceLines;

    *(long *)(buffer+i2)=(long)oldSourceLines.size();
    i2+=sizeof(long);
    BOOST_FOREACH( const SourceLine &sourceLine, oldSourceLines )
    {
        *(long *)(buffer+i2) = sourceLine.GetLineNum();
        i2+=sizeof(long);

        *(long *)(buffer+i2) = sourceLine.GetNativeCodePos();
        i2+=sizeof(long);

        *(long *)(buffer+i2) = sourceLine.GetSourceIndex();
        i2+=sizeof(long);

        *(long *)(buffer+i2) = sourceLine.GetSourceCodePos();
        i2+=sizeof(long);

        *(long *)(buffer+i2) = sourceLine.GetCodeType();
        i2+=sizeof(long);

        //バッファが足りない場合は再確保
        if(BufferSize<i2+32768){
            BufferSize+=32768;
            buffer=(char *)HeapReAlloc(hHeap,0,buffer,BufferSize);
        }
    }

    //グローバル実行領域のサイズ
    extern int GlobalOpBufferSize;
    *(long *)(buffer+i2)=GlobalOpBufferSize;
    i2+=sizeof(long);

    length=i2;
}

char *CDebugSection::MakeSingleStepCode(void){
    char *buffer;
    buffer=(char *)HeapAlloc(hHeap,0,SizeOf_CodeSection);

    memcpy(buffer,OpBuffer,SizeOf_CodeSection);

    BOOST_FOREACH( const SourceLine &sourceLine, _oldSourceLines )
    {
        if(!(
            sourceLine.IsInSystemProc()
            || sourceLine.IsInDebugProc() ) )
        {
            //int 3
            buffer[sourceLine.GetNativeCodePos()]=(char)0xCC;
        }
    }

    return buffer;
}
BOOL CDebugSection::__load(void){
    int i2,i3;

    compiler.ClearCompilingUserProcAndClass();

    i2=0;

    //デバッグ用ファイルのバージョンをチェック
    if(*(long *)(buffer+i2)<MDLFILE_VER){
        HeapDefaultFree(buffer);
        return 0;
    }
    i2+=sizeof(long);

    //プラットフォームのビット数をチェック
    if(*(long *)(buffer+i2)!=PLATFORM){
        HeapDefaultFree(buffer);
        return 0;
    }
    i2+=sizeof(long);

    // オブジェクトモジュール
    {
        // サイズ
        int size = *(long *)(buffer+i2);
        i2 += sizeof(long);

        // バッファ
        const std::string textString( (const char *)(buffer + i2), size );
        i2 += size;

        // テキストデータからシリアライズ
        this->objectModule.ReadString( textString );

        compiler.SelectObjectModule( this->objectModule );
    }


    //コードと行番号の関係
    int maxLineInfoNum = *(long *)(buffer+i2);
    i2+=sizeof(long);
    for(i3=0;i3<maxLineInfoNum;i3++){
        int lineNum = *(long *)(buffer+i2);
        i2+=sizeof(long);

        int nativeCodePos = *(long *)(buffer+i2);
        i2+=sizeof(long);

        int sourceIndex = *(long *)(buffer+i2);
        i2+=sizeof(long);

        int sourceCodePos = *(long *)(buffer+i2);
        i2+=sizeof(long);

        DWORD sourceLineType = *(DWORD *)(buffer+i2);
        i2+=sizeof(long);

        _oldSourceLines.push_back(
            SourceLine(
                lineNum,
                nativeCodePos,
                sourceIndex,
                sourceCodePos,
                sourceLineType
            )
        );
    }

    //グローバル実行領域のサイズ
    GlobalOpBufferSize=*(long *)(buffer+i2);
    i2+=sizeof(long);


    HeapDefaultFree(buffer);
    buffer=0;


    this->pSub_DebugSys_EndProc=GetSubHash("_DebugSys_EndProc");
    if( this->pSub_DebugSys_EndProc == NULL )
    {
        MessageBox( 0, "_DebugSys_EndProcが見つからない", "ActiveBasic", MB_OK );
    }


    SingleStepCodeBuffer=MakeSingleStepCode();
    
    //ソースコード
    extern char *basbuf;
    basbuf = const_cast<char *>(compiler.GetObjectModule().GetSource(0).GetBuffer());


    /////////////////////////////
    // ブレークポイントを適用
    /////////////////////////////

    //コードと行番号の関係
    extern SourceLines oldSourceLines;
    oldSourceLines = this->_oldSourceLines;

    BreakStepCodeBuffer=pobj_DBBreakPoint->update(OpBuffer,SizeOf_CodeSection);

    //プロセスメモリにコピー
    extern HANDLE hDebugProcess;
    SIZE_T accessBytes;
    WriteProcessMemory(hDebugProcess,(void *)(ULONG_PTR)(dwImageBase+dwRVA_CodeSection),
        BreakStepCodeBuffer,
        SizeOf_CodeSection,&accessBytes);


    return 1;
}

BOOL CDebugSection::load(HMODULE hModule){
    if(buffer){
        HeapDefaultFree(buffer);
        buffer=0;
    }


    extern HANDLE hDebugProcess;
    SIZE_T accessBytes;
    IMAGE_DOS_HEADER ImageDosHeader;
    ReadProcessMemory(hDebugProcess,hModule,&ImageDosHeader,sizeof(IMAGE_DOS_HEADER),&accessBytes);

    int pe_size;
#ifdef _AMD64_
    IMAGE_NT_HEADERS64 pe_hdr;
    pe_size=sizeof(IMAGE_NT_HEADERS64);
#else
    IMAGE_NT_HEADERS pe_hdr;
    pe_size=sizeof(IMAGE_NT_HEADERS);
#endif
    ReadProcessMemory(hDebugProcess,(void *)(((ULONG_PTR)hModule)+ImageDosHeader.e_lfanew),&pe_hdr,pe_size,&accessBytes);

    IMAGE_SECTION_HEADER *pSectionHdr;
    pSectionHdr=(IMAGE_SECTION_HEADER *)HeapAlloc(hHeap,0,pe_hdr.FileHeader.NumberOfSections*sizeof(IMAGE_SECTION_HEADER));
    ReadProcessMemory(hDebugProcess,
        (void *)(((ULONG_PTR)hModule)+ImageDosHeader.e_lfanew+pe_size),
        pSectionHdr,
        pe_hdr.FileHeader.NumberOfSections*sizeof(IMAGE_SECTION_HEADER),
        &accessBytes);

    int i;
    for(i=0;i<pe_hdr.FileHeader.NumberOfSections;i++){

        //リライタブルセクション内の情報
        if(lstrcmp((char *)pSectionHdr[i].Name,".data")==0){
            dwRVA_RWSection=pSectionHdr[i].VirtualAddress;
        }

        //コードセクション内の情報
        if(lstrcmp((char *)pSectionHdr[i].Name,".text")==0){
            dwRVA_CodeSection=pSectionHdr[i].VirtualAddress;
            SizeOf_CodeSection=pSectionHdr[i].SizeOfRawData;
        }

        //デバッグセクション内の情報
        if(lstrcmp((char *)pSectionHdr[i].Name,".debug")==0){
            length=pSectionHdr[i].Misc.VirtualSize;
            buffer=(char *)HeapAlloc(hHeap,0,length+1);

            ReadProcessMemory(hDebugProcess,
                (void *)(((ULONG_PTR)hModule)+pSectionHdr[i].VirtualAddress),
                buffer,
                length,
                &accessBytes);
            buffer[length]=0;
        }

    }
    HeapDefaultFree(pSectionHdr);

    if(!buffer) return 0;


    dwImageBase=(DWORD)(ULONG_PTR)hModule;



    if(OpBuffer) free(OpBuffer);
    OpBuffer=(char *)malloc(SizeOf_CodeSection);

    ReadProcessMemory(hDebugProcess,
        (void *)(ULONG_PTR)(dwImageBase+dwRVA_CodeSection),OpBuffer,
        SizeOf_CodeSection,&accessBytes);


    return __load();
}

void CDebugSection::choice(void){
    //イメージベース
    extern DWORD ImageBase;
    ImageBase=this->dwImageBase;

    //リライタブルセクションのRVA
    extern int MemPos_RWSection;
    MemPos_RWSection=this->dwRVA_RWSection;

    //コードセクションのRVAとサイズ
    extern int MemPos_CodeSection;
    extern int FileSize_CodeSection;
    MemPos_CodeSection=this->dwRVA_CodeSection;
    FileSize_CodeSection=this->SizeOf_CodeSection;

    // オブジェクトモジュール
    compiler.SelectObjectModule( this->objectModule );

    //コードと行番号の関係
    extern SourceLines oldSourceLines;
    oldSourceLines = this->_oldSourceLines;

    //グローバル実行領域のサイズ
    extern int GlobalOpBufferSize;
    GlobalOpBufferSize=this->GlobalOpBufferSize;

    extern const UserProc *pSub_DebugSys_EndProc;
    pSub_DebugSys_EndProc=this->pSub_DebugSys_EndProc;

    //ネイティブコードバッファ
    extern char *OpBuffer;
    OpBuffer=this->OpBuffer;
}

void CDebugSection::DeleteDebugInfo(void){
    //コードバッファを解放
    free(OpBuffer);
    OpBuffer=0;

    HeapDefaultFree(SingleStepCodeBuffer);
    SingleStepCodeBuffer=0;

    HeapDefaultFree(BreakStepCodeBuffer);
    BreakStepCodeBuffer=0;
}



CDBDebugSection::CDBDebugSection(){
    ppobj_ds=(CDebugSection **)HeapAlloc(hHeap,0,1);
    num=0;
}
CDBDebugSection::~CDBDebugSection(){
    int i;
    for(i=0;i<num;i++){
        delete ppobj_ds[i];
    }
    HeapDefaultFree(ppobj_ds);
}

BOOL CDBDebugSection::add(HMODULE hModule){
    CDebugSection *pobj_d;
    pobj_d=new CDebugSection();
    if(!pobj_d->load(hModule)){
        //デバッグ情報が存在しないとき
        delete pobj_d;
        return 0;
    }

    ppobj_ds=(CDebugSection **)HeapReAlloc(hHeap,0,ppobj_ds,(num+1)*sizeof(CDebugSection *));
    ppobj_ds[num]=pobj_d;
    num++;

    return 1;
}

void CDBDebugSection::del(HMODULE hModule){
    int i;
    for(i=0;i<num;i++){
        if((HMODULE)(ULONG_PTR)ppobj_ds[i]->dwImageBase==hModule){
            delete ppobj_ds[i];

            num--;
            for(;i<num;i++){
                ppobj_ds[i]=ppobj_ds[i+1];
            }
            break;
        }
    }
}

void CDBDebugSection::choice(int index){
    pobj_now=ppobj_ds[index];
    pobj_now->choice();
}



CDBDebugSection *pobj_DBDebugSection;