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

#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);
    }
}



DebugSection::~DebugSection(){
    if(dwImageBase) DeleteDebugInfo();
    if(buffer){
        HeapDefaultFree(buffer);
        buffer=0;
    }
}
void DebugSection::make( const SourceLines &sourceLines )
{
    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();
    }

    // オブジェクトモジュールリストに類似したソースコードリスト
    {
        // オブジェクトモジュールリストに類似したソースコードリストを作成
        BasicSources sources;
        BOOST_FOREACH( const ObjectModule *pObjectModule, compiler.staticLibraries )
        {
            sources.push_back( pObjectModule->GetSource() );
        }

        // テキストデータにシリアライズ
        std::string textString;
        sources.WriteBinaryString( 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();
    }


    ////////////////////////
    // コードと行番号の関係
    ////////////////////////
    *(long *)(buffer+i2)=(long)sourceLines.size();
    i2+=sizeof(long);
    BOOST_FOREACH( const SourceLine &sourceLine, sourceLines )
    {
        *(long *)(buffer+i2) = sourceLine.GetNativeCodePos();
        i2+=sizeof(long);

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

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

        *(long *)(buffer+i2) = sourceLine.GetSourceCodePosition().GetPos();
        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 *DebugSection::MakeSingleStepCode(){
    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 DebugSection::__load(){
    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 size = *(long *)(buffer+i2);
        i2 += sizeof(long);

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

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

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

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

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

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

        _oldSourceLines.push_back(
            SourceLine(
                nativeCodePos,
                sourceLineType,
                SourceCodePosition( relationalObjectModuleIndex, sourceCodePos )
            )
        );
    }

    //グローバル実行領域のサイズ
    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().GetBuffer());


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

    // オブジェクトモジュールリストに類似したソースコードリスト
    extern BasicSources sourcesLinkRelationalObjectModule;
    sourcesLinkRelationalObjectModule = this->_sourcesLinkRelationalObjectModule;

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

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


    return 1;
}

BOOL DebugSection::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 DebugSection::choice(){
    //イメージベース
    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 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 DebugSection::DeleteDebugInfo(){
    //コードバッファを解放
    free(OpBuffer);
    OpBuffer=0;

    HeapDefaultFree(SingleStepCodeBuffer);
    SingleStepCodeBuffer=0;

    HeapDefaultFree(BreakStepCodeBuffer);
    BreakStepCodeBuffer=0;
}



DebugSectionCollection::DebugSectionCollection()
{
}
DebugSectionCollection::~DebugSectionCollection()
{
    BOOST_FOREACH( DebugSection *pDebugSection, debugSections )
    {
        delete pDebugSection;
    }
    debugSections.clear();
}

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

    debugSections.push_back( pobj_d );

    return 1;
}

void DebugSectionCollection::del(HMODULE hModule){
    for( int i=0; i<static_cast<int>(this->debugSections.size()); i++ )
    {
        if( (HMODULE)(ULONG_PTR)this->debugSections[i]->dwImageBase == hModule )
        {
            delete debugSections[i];
            Jenga::Common::EraseVectorItem<std::vector<DebugSection *>>( debugSections, i );
            break;
        }
    }
}

void DebugSectionCollection::choice( int index )
{
    pCurrent = debugSections[index];
    pCurrent->choice();
}