source: dev/BasicCompiler_Common/PESchedule.cpp@ 75

#include "../BasicCompiler_Common/common.h"

#ifdef _AMD64_
#include "../BasicCompiler64/opcode.h"
#else
#include "../BasicCompiler32/opcode.h"
#endif

extern HANDLE hHeap;

/////////////////////////////////////////////
// 再配置スケジュール
//
// メモリの再配置は.textセクション、または.dataセクションに行われることが予想される。
//        .textセクション … セクションデータへのポインタ
//        .dataセクション … vtblの再配置
/////////////////////////////////////////////

CReloc *pobj_Reloc;

CReloc::CReloc(){
    buffer=0;
    length=0;
    NowPageRVAToReloc=0;

    pdwData_CodeSection=(DWORD *)HeapAlloc(hHeap,0,1);
    iNum_CodeSection=0;
    pdwData_DataSection=(DWORD *)HeapAlloc(hHeap,0,1);
    iNum_DataSection=0;
}
CReloc::~CReloc(){
    AllFree();
}
void CReloc::AllFree(void){
    if(buffer){
        HeapDefaultFree(buffer);
        buffer=0;
    }

    HeapDefaultFree(pdwData_CodeSection);
    HeapDefaultFree(pdwData_DataSection);
}
void CReloc::copy(CReloc *por){
    AllFree();

    if(por->buffer){
        buffer=(char *)HeapReAlloc(hHeap,0,buffer,por->length);
        memcpy(buffer,por->buffer,por->length);
    }
    else buffer=0;

    length=por->length;

    NowPageRVAToReloc=por->NowPageRVAToReloc;
    NowCountAddrToReloc=por->NowCountAddrToReloc;

    iNum_CodeSection=por->iNum_CodeSection;
    pdwData_CodeSection=(DWORD *)HeapAlloc(hHeap,0,iNum_CodeSection*sizeof(DWORD));
    memcpy(pdwData_CodeSection,por->pdwData_CodeSection,iNum_CodeSection*sizeof(DWORD));

    iNum_DataSection=por->iNum_DataSection;
    pdwData_DataSection=(DWORD *)HeapAlloc(hHeap,0,iNum_DataSection*sizeof(DWORD));
    memcpy(pdwData_DataSection,por->pdwData_DataSection,iNum_DataSection*sizeof(DWORD));
}

void CReloc::AddSchedule_CodeSection(DWORD addr){
    extern BOOL bDll;
    if(!bDll) return;

    pdwData_CodeSection=(DWORD *)HeapReAlloc(hHeap,0,pdwData_CodeSection,(iNum_CodeSection+1)*sizeof(DWORD));
    pdwData_CodeSection[iNum_CodeSection]=addr;
    iNum_CodeSection++;
}
void CReloc::AddSchedule_DataSection(DWORD addr){
    extern BOOL bDll;
    if(!bDll) return;

    pdwData_DataSection=(DWORD *)HeapReAlloc(hHeap,0,pdwData_DataSection,(iNum_DataSection+1)*sizeof(DWORD));
    pdwData_DataSection[iNum_DataSection]=addr;
    iNum_DataSection++;
}

void CReloc::__add(DWORD addr){
    extern BOOL bDll;
    if(!bDll) return;

    BOOL sw;
    sw=0;
    while((addr-(addr%MEM_ALIGNMENT))>NowPageRVAToReloc){
        NowPageRVAToReloc+=MEM_ALIGNMENT;
        sw=1;
    }

    if(sw){
        //ページを増やす
        while(length%4){
            buffer=(char *)HeapReAlloc(hHeap,0,buffer,length+sizeof(WORD));
            (*(WORD *)(buffer+length))=0;
            length+=2;

            (*(DWORD *)(buffer+NowCountAddrToReloc))+=sizeof(WORD);
        }

        buffer=(char *)HeapReAlloc(hHeap,0,buffer,
            length+
            sizeof(DWORD)+
            sizeof(DWORD));

        //Page RVA
        *(DWORD *)(buffer+length)=NowPageRVAToReloc;
        length+=sizeof(DWORD);

        NowCountAddrToReloc=length;

        //Block size
        *(DWORD *)(buffer+length)=sizeof(DWORD)*2;
        length+=sizeof(DWORD);
    }

    //リロケーション情報の追加
    buffer=(char *)HeapReAlloc(hHeap,0,buffer,length+sizeof(WORD));
    buffer[length]=0;
    buffer[length+1]=0x30;  //=IMAGE_REL_BASED_HIGHLOW
    (*(WORD *)(buffer+length))|=addr&0x0FFF;
    length+=2;

    (*(DWORD *)(buffer+NowCountAddrToReloc))+=sizeof(WORD);
}
void CReloc::ResetRelocBuffer(void){
    if(buffer) HeapDefaultFree(buffer);

    buffer=(char *)HeapAlloc(hHeap,0,1);
    length=0;
    NowPageRVAToReloc=0;

    int i;
    for(i=0;i<iNum_CodeSection;i++){
        extern int MemPos_CodeSection;
        __add(MemPos_CodeSection + pdwData_CodeSection[i]);
    }

    for(i=0;i<iNum_DataSection;i++){
        extern int MemPos_DataSection;
        __add(MemPos_DataSection + pdwData_DataSection[i]);
    }
}




//////////////////////////
// 一般スケジュール
//////////////////////////

CSchedule::CSchedule(){
    pObpValues=(int *)HeapAlloc(hHeap,0,1);
    num=0;

    this->flag=0;
}
CSchedule::~CSchedule(){
    HeapDefaultFree(pObpValues);
}
void CSchedule::SetFlag(int flag){
    this->flag=flag;
}
void CSchedule::add(){
    pObpValues=(int *)HeapReAlloc(hHeap,0,pObpValues,(num+1)*sizeof(int));
    pObpValues[num]=obp;
    num++;

    if(flag&SCHEDULE_FLAG_RELOC){
        //リロケーション情報を追加する
        pobj_Reloc->AddSchedule_CodeSection(obp);
    }
}
void CSchedule::move(int iStartPos,int iSize,int offset){
    int i;
    for(i=0;i<num;i++){
        if(iStartPos<=pObpValues[i] && pObpValues[i]<iStartPos+iSize){
            pObpValues[i]+=offset;
        }
    }
}

//データテーブルスケジュール
CSchedule *pobj_DataTableSchedule;

//グローバル変数アドレススケジュール
CSchedule *pobj_GlobalVarSchedule;



/////////////////////////////////////////
// インポート アドレス スケジューリング
/////////////////////////////////////////

CImportAddrSchedule::CImportAddrSchedule(){
    ppdi=(DllProc **)HeapAlloc(hHeap,0,1);
}
CImportAddrSchedule::~CImportAddrSchedule(){
    HeapDefaultFree(ppdi);
}

void CImportAddrSchedule::add(DllProc *pDllProc){
    ppdi=(DllProc **)HeapReAlloc(hHeap,0,ppdi,(num+1)*sizeof(DllProc *));
    ppdi[num]=pDllProc;

    CSchedule::add();
}

CImportAddrSchedule *pobj_ImportAddrSchedule;




/////////////////////////////////////////
// プロシージャ アドレス スケジューリング
/////////////////////////////////////////

CSubAddrSchedule::CSubAddrSchedule(){
    ppsi=(UserProc **)HeapAlloc(hHeap,0,1);
    pbCall=(BOOL *)HeapAlloc(hHeap,0,1);
}
CSubAddrSchedule::~CSubAddrSchedule(){
    HeapDefaultFree(ppsi);
    HeapDefaultFree(pbCall);
}

void CSubAddrSchedule::add(UserProc *pUserProc,BOOL bCall){
    if(!pUserProc) return;

    ppsi=(UserProc **)HeapReAlloc(hHeap,0,ppsi,(num+1)*sizeof(UserProc *));
    ppsi[num]=pUserProc;
    pbCall=(BOOL *)HeapReAlloc(hHeap,0,pbCall,(num+1)*sizeof(BOOL));
    pbCall[num]=bCall;

    CSchedule::add();

    if(!bCall){
        //リロケーション情報を追加する
        pobj_Reloc->AddSchedule_CodeSection(obp);
    }
}

CSubAddrSchedule *pobj_SubAddrSchedule;




/////////////////////////////////////////
// 一時スケジューリングポインタ
/////////////////////////////////////////
CTempSchedule::CTempSchedule(){
    ppObpValues=(int **)HeapAlloc(hHeap,0,1);
    num=0;
}
CTempSchedule::~CTempSchedule(){
    HeapDefaultFree(ppObpValues);
}
void CTempSchedule::lock(int *pobp){
    ppObpValues=(int **)HeapReAlloc(hHeap,0,ppObpValues,(num+1)*sizeof(int *));
    ppObpValues[num]=pobp;
    num++;
}
void CTempSchedule::unlock(){
    if( num <= 0 ){
        //エラー
        SetError(300,NULL,cp);
    }
    num--;
}
void CTempSchedule::move(int iStartPos,int iSize,int offset){
    int i;
    for(i=0;i<num;i++){
        if(iStartPos<=*ppObpValues[i] && *ppObpValues[i]<iStartPos+iSize){
            (*ppObpValues[i])+=offset;
        }
    }
}

CTempSchedule *pobj_TempSchedule;