void
Compile_Poke ( Compiler * compiler, int32 stackReg ) // =
{
//if ( CheckOptimizeOperands ( compiler, 3 ) )
int optFlag = CheckOptimizeOperands ( compiler, 4 ) ;
if ( optFlag == OPTIMIZE_DONE ) return ;
else if ( optFlag )
{
// _Compile_MoveImm ( cell direction, cell rm, cell disp, cell imm, cell operandSize )
if ( compiler->Optimizer->OptimizeFlag & OPTIMIZE_IMM ) _Compile_MoveImm ( compiler->Optimizer->Optimize_Dest_RegOrMem,
compiler->Optimizer->Optimize_Rm, 0, compiler->Optimizer->Optimize_Disp, compiler->Optimizer->Optimize_Imm, CELL ) ;
else if ( compiler->Optimizer->OptimizeFlag & OPTIMIZE_REGISTER )
{
// allow for one of these to be EAX which is 0
if ( compiler->Optimizer->Optimize_SrcReg || compiler->Optimizer->Optimize_DstReg ) _Compile_Move_Reg_To_Reg ( compiler->Optimizer->Optimize_DstReg, compiler->Optimizer->Optimize_SrcReg ) ;
//_Compile_Move ( int32 direction, int32 reg, int32 rm, int32 sib, int32 disp )
else _Compile_Move ( compiler->Optimizer->Optimize_Dest_RegOrMem, compiler->Optimizer->Optimize_Reg, compiler->Optimizer->Optimize_Rm, 0, 0 ) ;
}
else _Compile_Move_Reg_To_Rm ( compiler->Optimizer->Optimize_Rm, compiler->Optimizer->Optimize_Disp, compiler->Optimizer->Optimize_Reg ) ;
}
else
{
_Compile_Move_Rm_To_Reg ( ECX, stackReg, 0 ) ;
_Compile_Move_Rm_To_Reg ( EAX, stackReg, - CELL_SIZE ) ;
_Compile_Move_Reg_To_Rm ( EAX, 0, ECX ) ;
Compile_SUBI ( REG, stackReg, 0, 8, BYTE ) ;
}
}
void
_Compile_CpuState_Save ( CpuState * cpu )
{
// push order for pushad
// nb : intel stacks grow down toward lesser memory by subtracting from ESP to push and adding to pop
// SoftwareDevelopersManual-253665.pdf, section 6.2
// registers are pushed in this order ...
// eax, ecx, edx, ebx, esp, ebp, esi, edi
_Compile_PushAD ( ) ;
// get flags first
_Compile_PushFD ( ) ;
_Compile_MoveImm_To_Reg ( EAX, 0, CELL ) ;
_Compile_PopToReg ( EAX ) ;
//_Compile_Lahf ( ) ; // doesn't work with core 2 duo
_Compile_MoveImm_To_Reg ( ECX, ( int32 ) & cpu->EFlags, CELL ) ;
_Compile_Move_Reg_To_Rm ( ECX, 0, EAX ) ;
_Compile_MoveImm_To_Reg ( EAX, ( int32 ) & cpu->Edi, CELL ) ;
_Compile_PopToReg ( ECX ) ;
_Compile_Move_Reg_To_Rm ( EAX, 0, ECX ) ;
_Compile_MoveImm_To_Reg ( EAX, ( int32 ) & cpu->Esi, CELL ) ;
_Compile_PopToReg ( ECX ) ;
_Compile_Move_Reg_To_Rm ( EAX, 0, ECX ) ;
_Compile_MoveImm_To_Reg ( EAX, ( int32 ) & cpu->Ebp, CELL ) ;
_Compile_PopToReg ( ECX ) ;
_Compile_Move_Reg_To_Rm ( EAX, 0, ECX ) ;
_Compile_MoveImm_To_Reg ( EAX, ( int32 ) & cpu->Esp, CELL ) ;
_Compile_PopToReg ( ECX ) ;
_Compile_Move_Reg_To_Rm ( EAX, 0, ECX ) ;
_Compile_MoveImm_To_Reg ( EAX, ( int32 ) & cpu->Ebx, CELL ) ;
_Compile_PopToReg ( ECX ) ;
_Compile_Move_Reg_To_Rm ( EAX, 0, ECX ) ;
_Compile_MoveImm_To_Reg ( EAX, ( int32 ) & cpu->Edx, CELL ) ;
_Compile_PopToReg ( ECX ) ;
_Compile_Move_Reg_To_Rm ( EAX, 0, ECX ) ;
_Compile_MoveImm_To_Reg ( EAX, ( int32 ) & cpu->Ecx, CELL ) ;
_Compile_PopToReg ( ECX ) ;
_Compile_Move_Reg_To_Rm ( EAX, 0, ECX ) ;
_Compile_MoveImm_To_Reg ( EAX, ( int32 ) & cpu->Eax, CELL ) ;
_Compile_PopToReg ( ECX ) ;
_Compile_Move_Reg_To_Rm ( EAX, 0, ECX ) ;
_Compile_Return ( ) ; // x86 - return opcode
}
// n = *m
// ( n m -- )
//
void
Compile_AtEqual ( int32 stackReg ) // !
{
_Compile_Move_Rm_To_Reg ( EAX, stackReg, 0 ) ;
_Compile_Move_Rm_To_Reg ( EAX, EAX, 0 ) ;
_Compile_Move_Rm_To_Reg ( ECX, stackReg, - CELL_SIZE ) ;
_Compile_Move_Reg_To_Rm ( ECX, 0, EAX ) ;
Compile_SUBI ( REG, stackReg, 0, CELL_SIZE * 2, BYTE ) ;
}
void
_Compile_ESP_Save ( )
{
_Compile_Move_Reg_To_Rm ( ESI, 4, ESP ) ; // 4 : placeholder
_Context_->Compiler0->EspSaveOffset = Here - 1 ; // only takes one byte for _Compile_Move_Reg_To_Rm ( ESI, 4, ESP )
// TO DO : i think this (below) is what it should be but some adjustments need to be made to make it work
//byte * here = Here ;
//_Compile_Stack_Push_Reg ( DSP, ESP ) ;
//compiler->EspSaveOffset = here ; // only takes one byte for _Compile_Move_Reg_To_Rm ( ESI, 4, ESP )
}
void
_Compile_JmpCall_Using_RStack ( byte * jmpToAddr )
{
// push rstack here + 5 so RET can jmp back
_Compile_MoveImm_To_Reg ( EAX, &Rsp, CELL ) ; // the lvalue of Rsp
Compile_ADDI ( MEM, EAX, 0, CELL, BYTE ) ; // add 4 to Rsp
Compile_ADDI ( REG, EAX, 0, CELL, BYTE ) ; //
//_Compile_Move_Reg_To_Reg ( int32 dstReg, int32 srcReg ) ;
_Compile_MoveImm_To_Reg ( ECX, Here + x, CELL ) ; // x : number of bytes to the first byte after the jmp instruction
_Compile_Move_Reg_To_Rm ( EAX, 0, ECX ) ;
_Compile_JumpToAddress ( byte * jmpToAddr ) ;
}
void
Compile_Peek ( Compiler * compiler, int32 stackReg ) // @
{
int optFlag = CheckOptimizeOperands ( compiler, 2 ) ;
if ( optFlag == OPTIMIZE_DONE ) return ;
else // assume arg is tos
{
_Compile_Move_Rm_To_Reg ( EAX, stackReg, 0 ) ;
_Compile_Move_Rm_To_Reg ( EAX, EAX, 0 ) ;
_Compile_Move_Reg_To_Rm ( stackReg, 0, EAX ) ;
}
}
// set the value at address to reg - value in reg
void
_Compile_SetAtAddress_WithReg ( int * address, int32 reg, int32 thruReg )
{
_Compile_Move_Literal_Immediate_To_Reg ( thruReg, ( int32 ) address ) ;
_Compile_Move_Reg_To_Rm ( thruReg, reg, 0 ) ;
}
void
_Compile_MoveReg_To_Mem ( int32 reg, byte * address, int32 thruReg, int32 iSize )
{
_Compile_MoveImm_To_Reg ( thruReg, (int32) address, iSize ) ;
_Compile_Move_Reg_To_Rm ( thruReg, reg, 0 ) ;
}
