// CPUreset() - Resets CPU to startup state
void CPUreset() {
banksel(1); //bank 1 is always loaded on reset, it has the reset vector
regA = regX = regY = 0;
regSP = 0xFF;
regP = 0;
regPC = memReadByte(0xFFFC) + (memReadByte(0xFFFD) << 8);
}
/* Not */
void i8086not(i8086core *core, unsigned char opcode, i8086Parameter para, i8086Parameter data)
{
unsigned char wData=0;
i808616BitAdr adr;
i8086SingleRegister sreg;
wData = opcode & i8086_BIT_0; /* 1=wReg, 0=bReg */
if ((para.b[0] & 192) == 192) //Reg - bit 6 und bit7 von para.b[0] sind 1
{
i8086GetRegisterRef(&sreg,core, wData, para.b[0]&7); /* Source-Register lesen */
i8086SetRegister(core, para.b[0]&7, wData,~(sreg.x)); /* Dest-Register schreiben */
}
else //not MEM
{
adr=decodeMemAdr(core, para.b[0], joinBytes(para.b[1],para.b[2])); //adr berechnen
//16bit
if( opcode & 1)
{
memWriteWord(core,adr,~(memReadWord(core,adr,i8086_REG_DS)),i8086_REG_DS); //16bitadr
}
//8bit
else
memWriteByte(core,adr,~(memReadByte(core,adr,i8086_REG_DS)),i8086_REG_DS); //8bit adr
}
}
/*mov acc,mem16/8 mov mem16/8,acc*/
void i8086MovAcc(i8086core *core, unsigned char opcode, i8086Parameter para, i8086Parameter data)
{
unsigned char wData=0;
i808616BitAdr ea;
i8086SingleRegister sreg;
wData=opcode & i8086_BIT_0;
ea=joinBytes(para.b[1],para.b[0]);//EA setzt sich aus den 1. beiden parameterbytes zusammen!
i8086GetRegisterRef(&sreg,core,wData,i8086_REG_AX); //register ax bzw. al = acc
if(opcode & i8086_BIT_1) //mov ACC to MEM
{
if(wData) //16 Bit Operation
{
memWriteWord(core,ea,sreg.x,i8086_REG_DS); //schreibe inhalt von AX in den Speicher an die Adr. EA
}
else //8 Bit Operation
{
memWriteByte(core,ea,sreg.b[0],i8086_REG_DS); //schreibe inhalt von AL in den Speicher an die Adr EA
}
}
else //mov MEM to ACC
{
if(wData) //16 Bit Operation
{
i8086SetRegister(core,i8086_REG_AX,wData,memReadWord(core,ea,i8086_REG_DS)); //schreibe Word an der Adresse EA in AX
}
else //8 Bit Operation
{
i8086SetRegister(core,i8086_REG_AL,wData,memReadByte(core,ea,i8086_REG_DS)); //schreibe Byte an der Adresse EA in AL
}
}
}
void INC(int addr)
{
int value;
value = memReadByte( addr );
++value;
memStoreByte( addr, value&UMASK );
setNVflags(value);
}
/* bestmögliche beschreibung dieses befehls MOV AL,[BX+AL]*/
void i8086Xlat(i8086core *core, unsigned char opcode, i8086Parameter para, i8086Parameter data)
{
unsigned short offset;
i8086SingleRegister regbx,regal;
i8086GetRegisterRef(®al,core, 0, i8086_REG_AL); //reg al
i8086GetRegisterRef(®bx,core, 1, i8086_REG_BX); //reg bx
offset=regbx.x+regal.b[0]; //berechnung der speicheradresse aus al und bx
i8086SetRegister(core, i8086_REG_AL, 0, memReadByte(core,offset,i8086_REG_DS));//schreibe den wert an der speicheradresse offset nach al
}
/* xchg reg,acc */
void i8086XchgReg(i8086core *core, unsigned char opcode, i8086Parameter para, i8086Parameter data)
{
unsigned char destReg=0, sourceReg=0, wData=0, templo;
signed short disp,temp;/*variablen fuer xchg mem,reg bzw. xchg reg,mem */
i808616BitAdr ea;
i8086SingleRegister sreg;
wData = opcode & i8086_BIT_0; /* 1=wReg, 0=bReg */
if ( ((para.b[0] & i8086_BIT_6) && (para.b[0] & i8086_BIT_7)) || para.b[0]==0) /* Reg to Reg */
{
if(para.b[0]!=0) /*hat der Befehl nur 1 byte groesse?*/
{
sourceReg = getBitSnipped(para.b[0], 5, 3); /*normaler xchg reg,reg*/
destReg = getBitSnipped(para.b[0], 2, 3);
}
else
{
sourceReg = getBitSnipped(opcode, 2, 3); /* Xchg acc, reg bzw. reg,acc */
destReg = i8086_REG_AX;
wData=1; //immer 16 Bit Operation!
}
i8086GetRegisterRef(&sreg,core, wData, sourceReg);
temp=sreg.x; /* Inhalt vom Source-Register zwischenspeichern */
i8086GetRegisterRef(&sreg,core, wData, destReg); /*Inhalt vom Dest-Register lesen*/
i8086SetRegister(core, sourceReg, wData, sreg.x); /* Source-Register schreiben */
i8086SetRegister(core, destReg, wData, temp); /* Dest-Register schreiben */
}
else /* XCHG REG, MEM || XCHG MEM,REG*/
{
disp=joinBytes(para.b[1],para.b[2]); //hier steht komischerweise die mem16 adresse
ea=decodeMemAdr(core, para.b[0], disp); //adresse mit der vertauscht wird
sourceReg=getBitSnipped(para.b[0], 5, 3); //das register mit dem vertauscht wird
i8086GetRegisterRef(&sreg,core, wData, sourceReg); //register
temp=sreg.x;//speichere inhalt des Registers zwischen
if(wData) //ist es eine 16bit operation?
{
i8086SetRegister(core, sourceReg, wData, memReadWord(core,ea,i8086_REG_DS));//16bit des registers mit speicherinhalt
memWriteWord(core,ea,temp,i8086_REG_DS);//fuelle speicher an adr.
}
else //8 Bit Operation
{
templo=sreg.b[0];
i8086SetRegister(core, sourceReg, wData, memReadByte(core,ea,i8086_REG_DS));//8bit des registers mit speicherinhalt
memWriteByte(core,ea,templo,i8086_REG_DS);//fuelle speicher an adr.
}
}
}
/* mov reg,mem */
void i8086MovReg(i8086core *core, unsigned char opcode, i8086Parameter para, i8086Parameter data)
{
unsigned char destReg=0, sourceReg=0, wData=0;
signed short disp;
i808616BitAdr ea;
i8086SingleRegister sreg;
wData = opcode & i8086_BIT_0; /* 1=wReg, 0=bReg */
if ((para.b[0] & i8086_BIT_6) && (para.b[0] & i8086_BIT_7)) /* Reg to Reg */
{
if(opcode & i8086_BIT_1) //Reg TO Reg
{
sourceReg = getBitSnipped(para.b[0], 2, 3);/* Register-Code für Source */
destReg = getBitSnipped(para.b[0], 5, 3);/* Register-Code für Dest */
}
else //Reg FROM Reg
{
destReg = getBitSnipped(para.b[0], 2, 3);/* Register-Code für Dest */
sourceReg = getBitSnipped(para.b[0], 5, 3);/* Register-Code für Source */
}
i8086GetRegisterRef(&sreg, core, wData, sourceReg);/* Source-Register lesen */
i8086SetRegister(core, destReg, wData, sreg.x); /* Dest-Register schreiben */
}
else
{
disp=joinBytes(para.b[1],para.b[2]);//komischerweise steht hier die sourceadr drin
ea=decodeMemAdr(core, para.b[0], disp);//berechne adresse
if(opcode & i8086_BIT_1) //mov mem TO reg
{
destReg = getBitSnipped(para.b[0], 5, 3);//destregister
if(wData) //16 Bit Operation
i8086SetRegister(core, destReg, wData, memReadWord(core,ea,i8086_REG_DS)); /* Destregister schreiben */
else //8 Bit Operation
i8086SetRegister(core, destReg, wData, memReadByte(core,ea,i8086_REG_DS)); /* Destregister schreiben */
}
else //mov mem FROM reg
{
sourceReg = getBitSnipped(para.b[0], 5, 3);//sourceregister
i8086GetRegisterRef(&sreg,core, wData, sourceReg);
if(wData) //16 Bit Operation
memWriteWord(core,ea,sreg.x,i8086_REG_DS);//schreibe inhalt von sourceregister in speicher
else //8 Bit Operation
memWriteByte(core,ea,sreg.b[0],i8086_REG_DS);//schreibe inhalt von sourceregister in speicher
}
}
}
// // stackPop() - Pop byte from stack
int stackPop() {
int value;
byte save_bank=current_bank;
banksel(0);
if( regSP < 0xff ) {
// value = memory[regSP+0x100];
regSP++;
value = memReadByte( regSP + 0x100 );
banksel(save_bank);
return(value);
}
else
{
banksel(save_bank);
return(0);
}
}
int memGetWord(int addr)
{
int val;
val= memReadByte( addr ) + (memReadByte( addr+1) << 8);
return val;
}
// popByte() - Pops a byte
int popByte()
{
int value = memReadByte(regPC);
regPC++;
return(value & 0xff);
}
word memReadWordWithBoundaryCross(byte addressLo, byte addressHi) {
word addressBase = addressHi << 8;
return(memReadByte(addressBase+addressLo) + (memReadByte(addressBase+((byte)(addressLo+1))) << 8));
}
word memReadWord(word address) {
return(memReadByte(address) + (memReadByte(address + 1) << 8));
}
