/************************************************************************** * DSemu: ARM7 assembly core, x86 (arm7x86.c) * * Released under the terms of the BSD Public Licence * * Imran Nazar (tf@oopsilon.com), 2004 * **************************************************************************/ #include #include "err.h" #include "arm7.h" #include "arm7func.h" #include "cache.h" #include "vtbl.h" #include "dbgout.h" #include "bkpt.h" //#define ARM7REGDUMP extern void emuPause(); u32 *dbuf7; FILE *ARM7regdump=NULL; int cpuHalted; u16 intrBitmask; intfptr ARM7execforPtr; int ARM7waitstate; BREAKPOINT ARM7bkpts[16]; int ARM7execforThumb(u32), ARM7execforARM(u32); int ARM7init(char *file, u32 *dbgbuf) { char str[8192]; sprintf(str,"ARM7: ROM file: %s",file); logvt->append(str); MMUinit(file); dbuf7=dbgbuf; // if(ARM7reset()) RETFAIL("FAIL: ARM7: Reset."); RETPASS("ARM7: Initialised."); } void ARM7fini() { MMUfini(); #ifdef ARM7REGDUMP fclose(ARM7regdump); #endif logvt->append("ARM7: Shutdown."); } int ARM7reset() { int a; #ifdef ARM7REGDUMP if(ARM7regdump){fclose(ARM7regdump);ARM7regdump=NULL;} ARM7regdump=fopen("C:\\Devel\\regdump.arm7.dat","wb"); #endif arm7reg.r0=0; arm7reg.r1=0; arm7reg.r2=0; arm7reg.r3=0; arm7reg.r4=0; arm7reg.r5=0; arm7reg.r6=0; arm7reg.r7=0; arm7reg.r8=0; arm7reg.r9=0; arm7reg.r10=0; arm7reg.r11=0; arm7reg.r12=0; arm7reg.r13=0x03007F00; arm7reg.r14=0; arm7reg.r15=0x08000000; arm7reg.r[0]=arm7reg.r0; arm7reg.r[1]=arm7reg.r1; arm7reg.r[2]=arm7reg.r2; arm7reg.r[3]=arm7reg.r3; arm7reg.r[4]=arm7reg.r4; arm7reg.r[5]=arm7reg.r5; arm7reg.r[6]=arm7reg.r6; arm7reg.r[7]=arm7reg.r7; arm7reg.r[8]=arm7reg.r8; arm7reg.r[9]=arm7reg.r9; arm7reg.r[10]=arm7reg.r10; arm7reg.r[11]=arm7reg.r11; arm7reg.r[12]=arm7reg.r12; arm7reg.r[13]=arm7reg.r13; arm7reg.r[14]=arm7reg.r14; arm7reg.r[15]=arm7reg.r15; arm7reg.cpsr=ARMS_M_SYS|ARMS_F; arm7reg.clock=0; for(a=0;a<7;a++) arm7reg.spsr[a]=0; arm7reg.r8fiq=0; arm7reg.r9fiq=0; arm7reg.r10fiq=0; arm7reg.r11fiq=0; arm7reg.r12fiq=0; arm7reg.r13fiq=0; arm7reg.r14fiq=0; arm7reg.r13irq=0x03007FA0; arm7reg.r14irq=0; arm7reg.r13abt=0; arm7reg.r14abt=0; arm7reg.r13svc=0x03007FE0; arm7reg.r14svc=0; arm7reg.r13und=0; arm7reg.r14und=0; cpuHalted=0; intrBitmask=0xFFFF; ARM7execforPtr=ARM7execforARM; ARM7waitstate=0; arm7reg.curmode=ARMMD_SYS; for(a=0;a<8;a++) arm7reg.flags[a]=0; if(MMUreset()) RETFAIL("FAIL: MMU: Reset."); RETPASS("ARM7: Reset."); } __int64 ARM7getClock() { return arm7reg.clock; } void ARM7addClock(int clk) { arm7reg.clock+=clk; ARM7waitstate+=clk; } #define ARM7DUMP() \ ARM7updateCPSR(); \ fwrite((&arm7reg),4,15,ARM7regdump); \ r15=arm7reg.r[15]+((arm7reg.cpsr&ARMS_T)?2:4); \ fwrite((&r15),4,1,ARM7regdump); \ fwrite((&arm7reg.cpsr),4,1,ARM7regdump); \ fwrite((&arm7reg.curop),4,1,ARM7regdump); int ARM7exec() { //int idx,cond; char str[512], opstr[128]; //__int64 clk=arm7reg.clock,clkend; u32 r15=arm7reg.r[15]; RAMWORD op; if(cpuHalted) return 8; op=MMUrdS(0,r15); ARM7waitstate=0; #ifdef ARM7DEBUG // sprintf(str,"%08X: Encountered opcode %08X (%s)", arm7reg.r[15], op.data, ARM7DASM(op.data)); // logvt->append(str); #endif if(arm7reg.flags[ARMFLAG_T]) { switch(r15&2) { case 0: arm7reg.curop=op.data&65535; sprintf(opstr,"%s", Thumb7DASM(arm7reg.curop)); // logvt->append(opstr); arm7reg.r[15]+=2; return /*arm7reg.clock+=*/thumb7ops[arm7reg.curop>>8]()+ARM7waitstate; // arm7reg.clock+=thumb7ops[arm7reg.curop>>8].cyc; break; case 2: arm7reg.curop=op.data>>16; sprintf(opstr,"%s", Thumb7DASM(arm7reg.curop)); // logvt->append(opstr); arm7reg.r[15]+=2; return /*arm7reg.clock+=*/thumb7ops[arm7reg.curop>>8]()+ARM7waitstate; // arm7reg.clock+=thumb7ops[arm7reg.curop>>8].cyc; break; } return 0; } else { sprintf(opstr,"%s", ARM7DASM(op.data)); // logvt->append(opstr); arm7reg.r[15]+=4; if(op.cond()) { arm7reg.curop=op.data; return /*arm7reg.clock+=*/op.op()+ARM7waitstate; // arm7reg.clock+=op.cyc; } else return 1; //arm7reg.clock++; } #ifdef ARM7REGDUMP ARM7DUMP(); #endif // clkend=arm7reg.clock; // return clkend-clk; } int ARM7execforThumb(u32 count) { u32 clk=0,opclk; u32 r15; RAMWORD op; if(cpuHalted) return count; do { op=MMUrdS(0,arm7reg.r[15]); ARM7waitstate=0; arm7reg.curop=(arm7reg.r[15]&2)?op.h[1]:op.h[0]; arm7reg.r[15]+=2; clk+=thumb7ops[arm7reg.curop>>8]()+ARM7waitstate; #ifdef ARM7REGDUMP ARM7DUMP(); #endif } while((clkappend(str); if(op.cond()) { arm7reg.curop=op.data; opclk=op.op(); if(opclk) clk+=opclk+ARM7waitstate; else return clk; } #ifdef ARM7REGDUMP ARM7DUMP(); #endif } while((clk>8]()+ARM7waitstate; } else { arm7reg.r[15]+=4; if(op.cond()) { arm7reg.curop=op.data; opclk=op.op(); if(opclk) clk+=opclk+ARM7waitstate; else return clk; } } #ifdef ARM7REGDUMP ARM7DUMP(); #endif } while(clk>31)&1; arm7reg.flags[1]=(arm7reg.cpsr>>30)&1; arm7reg.flags[2]=(arm7reg.cpsr>>29)&1; arm7reg.flags[3]=(arm7reg.cpsr>>28)&1; arm7reg.flags[4]=(arm7reg.cpsr>>5)&1; arm7reg.flags[5]=(arm7reg.cpsr>>27)&1; ARM7execforPtr=(arm7reg.flags[ARMFLAG_T]?ARM7execforThumb:ARM7execforARM); } void ARM7modesw(int mdin, int mdout) { ARM7updateCPSR(); arm7reg.r0=arm7reg.r[0]; arm7reg.r1=arm7reg.r[1]; arm7reg.r2=arm7reg.r[2]; arm7reg.r3=arm7reg.r[3]; arm7reg.r4=arm7reg.r[4]; arm7reg.r5=arm7reg.r[5]; arm7reg.r6=arm7reg.r[6]; arm7reg.r7=arm7reg.r[7]; arm7reg.r15=arm7reg.r[15]; switch(mdin) { case ARMMD_USR: case ARMMD_SYS: arm7reg.r8=arm7reg.r[8]; arm7reg.r9=arm7reg.r[9]; arm7reg.r10=arm7reg.r[10]; arm7reg.r11=arm7reg.r[11]; arm7reg.r12=arm7reg.r[12]; arm7reg.r13=arm7reg.r[13]; arm7reg.r14=arm7reg.r[14]; break; case ARMMD_IRQ: arm7reg.r8=arm7reg.r[8]; arm7reg.r9=arm7reg.r[9]; arm7reg.r10=arm7reg.r[10]; arm7reg.r11=arm7reg.r[11]; arm7reg.r12=arm7reg.r[12]; arm7reg.r13irq=arm7reg.r[13]; arm7reg.r14irq=arm7reg.r[14]; break; case ARMMD_SVC: arm7reg.r8=arm7reg.r[8]; arm7reg.r9=arm7reg.r[9]; arm7reg.r10=arm7reg.r[10]; arm7reg.r11=arm7reg.r[11]; arm7reg.r12=arm7reg.r[12]; arm7reg.r13svc=arm7reg.r[13]; arm7reg.r14svc=arm7reg.r[14]; break; case ARMMD_ABT: arm7reg.r8=arm7reg.r[8]; arm7reg.r9=arm7reg.r[9]; arm7reg.r10=arm7reg.r[10]; arm7reg.r11=arm7reg.r[11]; arm7reg.r12=arm7reg.r[12]; arm7reg.r13abt=arm7reg.r[13]; arm7reg.r14abt=arm7reg.r[14]; break; case ARMMD_UND: arm7reg.r8=arm7reg.r[8]; arm7reg.r9=arm7reg.r[9]; arm7reg.r10=arm7reg.r[10]; arm7reg.r11=arm7reg.r[11]; arm7reg.r12=arm7reg.r[12]; arm7reg.r13und=arm7reg.r[13]; arm7reg.r14und=arm7reg.r[14]; break; case ARMMD_FIQ: arm7reg.r8fiq=arm7reg.r[8]; arm7reg.r9fiq=arm7reg.r[9]; arm7reg.r10fiq=arm7reg.r[10]; arm7reg.r11fiq=arm7reg.r[11]; arm7reg.r12fiq=arm7reg.r[12]; arm7reg.r13fiq=arm7reg.r[13]; arm7reg.r14fiq=arm7reg.r[14]; break; } arm7reg.cpsr&=(0xFFFFFFFF-ARMS_M); switch(mdout) { case ARMMD_USR: arm7reg.r[8]=arm7reg.r8; arm7reg.r[9]=arm7reg.r9; arm7reg.r[10]=arm7reg.r10; arm7reg.r[11]=arm7reg.r11; arm7reg.r[12]=arm7reg.r12; arm7reg.r[13]=arm7reg.r13; arm7reg.r[14]=arm7reg.r14; break; case ARMMD_SYS: arm7reg.r[8]=arm7reg.r8; arm7reg.r[9]=arm7reg.r9; arm7reg.r[10]=arm7reg.r10; arm7reg.r[11]=arm7reg.r11; arm7reg.r[12]=arm7reg.r12; arm7reg.r[13]=arm7reg.r13; arm7reg.r[14]=arm7reg.r14; break; case ARMMD_IRQ: arm7reg.r[8]=arm7reg.r8; arm7reg.r[9]=arm7reg.r9; arm7reg.r[10]=arm7reg.r10; arm7reg.r[11]=arm7reg.r11; arm7reg.r[12]=arm7reg.r12; arm7reg.r[13]=arm7reg.r13irq; arm7reg.r[14]=arm7reg.r14irq; break; case ARMMD_SVC: arm7reg.r[8]=arm7reg.r8; arm7reg.r[9]=arm7reg.r9; arm7reg.r[10]=arm7reg.r10; arm7reg.r[11]=arm7reg.r11; arm7reg.r[12]=arm7reg.r12; arm7reg.r[13]=arm7reg.r13svc; arm7reg.r[14]=arm7reg.r14svc; break; case ARMMD_ABT: arm7reg.r[8]=arm7reg.r8; arm7reg.r[9]=arm7reg.r9; arm7reg.r[10]=arm7reg.r10; arm7reg.r[11]=arm7reg.r11; arm7reg.r[12]=arm7reg.r12; arm7reg.r[13]=arm7reg.r13abt; arm7reg.r[14]=arm7reg.r14abt; break; case ARMMD_UND: arm7reg.r[8]=arm7reg.r8; arm7reg.r[9]=arm7reg.r9; arm7reg.r[10]=arm7reg.r10; arm7reg.r[11]=arm7reg.r11; arm7reg.r[12]=arm7reg.r12; arm7reg.r[13]=arm7reg.r13und; arm7reg.r14und=arm7reg.r[14]; break; case ARMMD_FIQ: arm7reg.r[8]=arm7reg.r8fiq; arm7reg.r[9]=arm7reg.r9fiq; arm7reg.r[10]=arm7reg.r10fiq; arm7reg.r[11]=arm7reg.r11fiq; arm7reg.r[12]=arm7reg.r12fiq; arm7reg.r[13]=arm7reg.r13fiq; arm7reg.r[14]=arm7reg.r14fiq; break; } arm7reg.cpsr|=ARM7modetocpsr[mdout]; arm7reg.curmode=mdout; } void ARM7status(int offset, int mode) { char str[512]; int a; u16 oph; u32 r15=arm7reg.r[15],r15orig=r15; static u32 r15old; static u32 dbgoldr[16],rchanged[16],dbgoldf[6],fchanged[6]; RAMWORD op; u32 col; u16 *outbuf=(u16*)dbuf7; ARM7updateCPSR(); dbgOutClear(outbuf,468,144); if((mode==3&&arm7reg.cpsr&ARMS_T)||(mode==2)) r15-=(16-offset*2); else r15-=(32-offset*4); for(a=0;a<16;a++) { if(r15==r15orig) col=0x7E10; else col=0x7FFF; if((r15&0x0F000000)==(r15orig&0x0F000000)) op=MMUrdS(0,r15); switch(mode) { case 1: if((r15&0x0F000000)==(r15orig&0x0F000000)) sprintf(str,"%08X: %08X | %s",r15,op.data,ARM7DASM(op.data)); else sprintf(str,"%08X",r15); r15+=4; break; case 2: if((r15&0x0F000000)==(r15orig&0x0F000000)) { if(r15&2) oph=op.data>>16; else oph=op.data&65535; sprintf(str,"%08X: %04X | %s",r15,oph,Thumb7DASM(oph)); } else sprintf(str,"%08X",r15); r15+=2; break; case 3: switch(arm7reg.cpsr&ARMS_T) { case 0: if((r15&0x0F000000)==(r15orig&0x0F000000)) sprintf(str,"%08X: %08X | %s",r15,op.data,ARM7DASM(op.data)); else sprintf(str,"%08X",r15); r15+=4; break; case ARMS_T: if((r15&0x0F000000)==(r15orig&0x0F000000)) { if(r15&2) oph=op.data>>16; else oph=op.data&65535; sprintf(str,"%08X: %04X | %s",r15,oph,Thumb7DASM(oph)); } else sprintf(str,"%08X",r15); r15+=2; break; } break; } dbgOut(outbuf,468,144,str,0,16+a*8,col); } for(a=0;a<=15;a++) { sprintf(str,"r%02d: %08X",a,arm7reg.r[a]); if(r15old!=r15orig) { if(arm7reg.r[a]!=dbgoldr[a]) { dbgoldr[a]=arm7reg.r[a]; rchanged[a]=1; } else rchanged[a]=0; } if(rchanged[a]) dbgOut(outbuf,468,144,str,56*6,16+a*8,0x001F); else dbgOut(outbuf,468,144,str,56*6,16+a*8,0x7FFF); } sprintf(str,"%s",ARM7modes[arm7reg.curmode]); dbgOut(outbuf, 468,144, str, 72*6,72,0x7FFF); a=(arm7reg.cpsr&ARMS_N)>>31; sprintf(str,"N: %d",a); if(r15old!=r15orig) if(a!=dbgoldf[0]) { dbgoldf[0]=a; fchanged[0]=1; } else fchanged[0]=0; if(fchanged[0]) dbgOut(outbuf,468,144,str,72*6,16,0x001F); else dbgOut(outbuf,468,144,str,72*6,16,0x7FFF); a=(arm7reg.cpsr&ARMS_Z)>>30; sprintf(str,"Z: %d",a); if(r15old!=r15orig) if(a!=dbgoldf[1]) { dbgoldf[1]=a; fchanged[1]=1; } else fchanged[1]=0; if(fchanged[1]) dbgOut(outbuf,468,144,str,72*6,24,0x001F); else dbgOut(outbuf,468,144,str,72*6,24,0x7FFF); a=(arm7reg.cpsr&ARMS_C)>>29; sprintf(str,"C: %d",a); if(r15old!=r15orig) if(a!=dbgoldf[2]) { dbgoldf[2]=a; fchanged[2]=1; } else fchanged[2]=0; if(fchanged[2]) dbgOut(outbuf,468,144,str,72*6,32,0x001F); else dbgOut(outbuf,468,144,str,72*6,32,0x7FFF); a=(arm7reg.cpsr&ARMS_V)>>28; sprintf(str,"V: %d",a); if(r15old!=r15orig) if(a!=dbgoldf[3]) { dbgoldf[3]=a; fchanged[3]=1; } else fchanged[3]=0; if(fchanged[3]) dbgOut(outbuf,468,144,str,72*6,40,0x001F); else dbgOut(outbuf,468,144,str,72*6,40,0x7FFF); /* a=(arm7reg.cpsr&ARMS_Q)>>27; sprintf(str,"Q: %d",a); if(r15old!=r15orig) if(a!=dbgoldf[4]) { dbgoldf[4]=a; fchanged[4]=1; } else fchanged[4]=0; if(fchanged[4]) dbgOut(outbuf,468,144,str,72*6,48,0x001F); else dbgOut(outbuf,468,144,str,72*6,48,0x7FFF); */ a=(arm7reg.cpsr&ARMS_T)>>5; sprintf(str,"T: %d",a); if(r15old!=r15orig) if(a!=dbgoldf[5]) { dbgoldf[5]=a; fchanged[5]=1; } else fchanged[5]=0; if(fchanged[5]) dbgOut(outbuf,468,144,str,72*6,56,0x001F); else dbgOut(outbuf,468,144,str,72*6,56,0x7FFF); if(r15old!=r15orig) r15old=r15orig; } //---Undefined/unimplemented opcode messaging------------------------------ OPCODE ARM7opUND() { char str[80]; sprintf(str,"Undefined opcode encountered: %08X.",arm7reg.curop); logvt->append(str); return 1; } OPCODE ARM7opUNP() { char str[80]; sprintf(str,"Unpredictable opcode encountered: %08X.",arm7reg.curop); logvt->append(str); return 1; } OPCODE ARM7opUNI() { char str[80]; sprintf(str,"Unimplemented opcode encountered: %08X.",arm7reg.curop); logvt->append(str); return 1; } OPCODE ARM7opUNL() { RAMWORD op; u32 idx=((arm7reg.curop&0x0FF00000)>>16)|((arm7reg.curop&0x000000F0)>>4); u16 cond=(arm7reg.curop&0xF0000000)>>28; op.data=arm7reg.curop; op.op=arm7ops[idx]; op.tidxlo=(arm7reg.curop>>8)&255; op.tidxhi=(arm7reg.curop>>24); op.cond=ARM7cond[cond]; // op.cyc=arm7ops[idx].cyc; op.flags=0; if(arm7reg.flags[ARMFLAG_T]) { MMUwrS(0,arm7reg.r[15]-2,op); switch(arm7reg.r[15]&2) { case 0: arm7reg.curop=op.data>>16; return thumb7ops[arm7reg.curop>>8](); // arm7reg.clock+=thumb7ops[arm7reg.curop>>8].cyc; break; case 2: arm7reg.curop=op.data&65535; return thumb7ops[arm7reg.curop>>8](); // arm7reg.clock+=thumb7ops[arm7reg.curop>>8].cyc; break; } return 0; } else { MMUwrS(0,arm7reg.r[15]-4,op); if(op.cond()) { arm7reg.curop=op.data; return op.op(); // arm7reg.clock+=op.cyc; } return 1; } } RAMWORD ARM7opDecode(u32 input) { RAMWORD op; u32 idx=((input&0x0FF00000)>>16)|((input&0x000000F0)>>4); u16 cond=(input&0xF0000000)>>28; op.data=input; op.op=arm7ops[idx]; op.tidxlo=(input>>8)&255; op.tidxhi=(input>>24); op.cond=ARM7cond[cond]; op.flags=0; return op; } //---Conditional execution implementation---------------------------------- int ARM7condEQ(){return arm7reg.flags[ARMFLAG_Z];} int ARM7condNE(){return !arm7reg.flags[ARMFLAG_Z];} int ARM7condCS(){return arm7reg.flags[ARMFLAG_C];} int ARM7condCC(){return !arm7reg.flags[ARMFLAG_C];} int ARM7condMI(){return arm7reg.flags[ARMFLAG_N];} int ARM7condPL(){return !arm7reg.flags[ARMFLAG_N];} int ARM7condVS(){return arm7reg.flags[ARMFLAG_V];} int ARM7condVC(){return !arm7reg.flags[ARMFLAG_V];} int ARM7condHI(){return (!arm7reg.flags[ARMFLAG_Z])&arm7reg.flags[ARMFLAG_C];} int ARM7condLS(){return arm7reg.flags[ARMFLAG_Z]|(!arm7reg.flags[ARMFLAG_C]);} int ARM7condGE(){return !(arm7reg.flags[ARMFLAG_N]^arm7reg.flags[ARMFLAG_V]);} int ARM7condLT(){return (arm7reg.flags[ARMFLAG_N]^arm7reg.flags[ARMFLAG_V]);} int ARM7condGT(){return (!arm7reg.flags[ARMFLAG_Z])&(!(arm7reg.flags[ARMFLAG_N]^arm7reg.flags[ARMFLAG_V]));} int ARM7condLE(){return arm7reg.flags[ARMFLAG_Z]|(arm7reg.flags[ARMFLAG_N]^arm7reg.flags[ARMFLAG_V]);} int ARM7condAL(){return 1;} int ARM7condNV(){return 0;} //---Branching------------------------------------------------------------- OPCODE ARM7opB() { __asm { mov eax,[arm7reg+ARMREG_OP*4] /* Get opcode */ shl eax,8 /* Extract branch address */ sar eax,6 /* addr*4, with sign extend */ add eax,4 /* Add 4 to new pc */ add [arm7reg+ARMREG_R15*4],eax /* and write to r15 */ mov eax,3 } } OPCODE ARM7opBL() { __asm { mov ecx,[arm7reg+ARMREG_R15*4] /* Get r15 */ mov [arm7reg+ARMREG_R14*4],ecx /* r14=r15 */ mov eax,[arm7reg+ARMREG_OP*4] /* Get opcode */ shl eax,8 /* Extract branch address */ sar eax,6 /* addr*4, with sign extend */ add eax,4 /* Add 4 to new pc */ add [arm7reg+ARMREG_R15*4],eax /* and write to r15 */ mov eax,3 } } OPCODE ARM7opBX() { __asm { mov eax,[arm7reg+ARMREG_OP*4] /* Read opcode */ and eax,15 /* Mask Rm */ mov eax,[arm7reg+eax*4] /* Read Rm's value */ mov ebx,eax /* Make a copy */ and eax,0FFFFFFFEh /* Mask out T bit */ mov [arm7reg+15*4],eax /* and write r15 */ and ebx,1 /* Mask in T bit */ cmp ebx,1 /* Is it 1? */ sbb ecx,ecx /* (==0)?-1:0 */ not ecx /* (==0)?0:-1 */ // and ecx,ARMS_T /* Mask cpsr T bit */ // and [arm7reg+ARMREG_CPSR*4],0FFFFFFFFh-ARMS_T // or [arm7reg+ARMREG_CPSR*4],ecx /* Add T */ and ecx,1 mov [arm7reg+ARMREG_FT*4],ecx call ARM7updateCPSR mov eax,3 } } OPCODE ARM7opBLX() { // Implemented in ARM5 return 1; } OPCODE ARM7opBLXr() { __asm { mov eax,[arm7reg+15*4] mov [arm7reg+14*4],eax mov eax,[arm7reg+ARMREG_OP*4] /* Read opcode */ and eax,15 /* Mask Rm */ mov eax,[arm7reg+eax*4] /* Read Rm's value */ mov ebx,eax /* Make a copy */ and eax,0FFFFFFFEh /* Mask out T bit */ mov [arm7reg+15*4],eax /* and write r15 */ and ebx,1 /* Mask in T bit */ cmp ebx,1 /* Is it 1? */ sbb ecx,ecx /* (==0)?-1:0 */ not ecx /* (==0)?0:-1 */ // and ecx,ARMS_T /* Mask cpsr T bit */ // and [arm7reg+ARMREG_CPSR*4],0FFFFFFFFh-ARMS_T // or [arm7reg+ARMREG_CPSR*4],ecx /* Add T */ and ecx,1 mov [arm7reg+ARMREG_FT*4],ecx call ARM7updateCPSR mov eax,3 } } //---Data Processing addressing modes, opcodes----------------------------- #define ARM7addrDPops() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask to range */ \ __asm mov eax,[arm7reg+ecx*4] /* Read value of Rn */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt2 /* If not, skip next */ \ __asm add eax,4 /* Hack r15 */ \ __asm pt2: /* OPERAND2 set */ \ \ __asm mov ecx,edx /* Make a copy */ \ __asm and ecx,15 /* Mask to Rm */ \ __asm mov ebx,[arm7reg+ecx*4] /* Read value of Rm */ \ __asm cmp ecx,15 /* Is Rm 15? */ \ __asm jl pt1 /* If not, skip next */ \ __asm add ebx,4 /* Hack r15 value */ \ __asm pt1: /* OPERAND1 set */ \ } #define ARM7addrDPreg() \ ARM7addrDPops(); \ __asm { \ __asm shr edx,12 /* Extract Rd */ \ __asm and edx,15 /* Limit to 15 */ \ __asm mov ecx,[arm7reg+ARMREG_FC*4] /* Read saved carry */ \ __asm shr ecx,1 /* Shift into x86 c */ \ __asm setc [arm7reg+ARMREG_TC*4] \ } #define ARM7addrDPimm() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask to range */ \ __asm mov eax,[arm7reg+ecx*4] /* Read value of Rn */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt2 /* If not, skip next */ \ __asm add eax,4 /* Hack r15 */ \ __asm pt2: /* OPERAND2 set */ \ \ __asm mov ecx,edx /* Make op copy */ \ __asm mov ebx,edx /* and another */ \ __asm shr edx,12 /* Extract Rd */ \ __asm and edx,15 /* Limit to 15 */ \ \ __asm and ebx,255 /* Get the low byte */ \ __asm shr ecx,7 /* Shift in rotamnt */ \ __asm and ecx,30 /* and mask to 31 */ \ __asm ror ebx,cl /* Rotate constant */ \ __asm or ecx,ecx /* Check rotamnt */ \ __asm jz noshft /* Skip if no rot */ \ __asm mov ecx,eax /* Copy operand1 */ \ __asm shl ecx,1 /* Carry = high bit */ \ __asm jmp shftdone /* And skip carry read */ \ __asm noshft: /* Done shifting */ \ __asm mov ecx,[arm7reg+ARMREG_FC*4] /* Read saved carry */ \ __asm shr ecx,1 /* Shift into x86 c */ \ \ __asm shftdone: /* all done! */ \ __asm setc [arm7reg+ARMREG_TC*4] \ } #define ARM7addrDPlli() \ ARM7addrDPops(); \ __asm { \ __asm mov ecx,edx /* Make op copy */ \ __asm shr edx,12 /* Extract Rd */ \ __asm and edx,15 /* Limit to 15 */ \ \ __asm shr ecx,7 /* Shift in shftamount */ \ __asm and ecx,31 /* Mask off amount */ \ __asm jz noshft /* Skip if no shift */ \ __asm shl ebx,cl /* Shift operand1 */ \ __asm jmp shftdone /* And skip carry read */ \ __asm noshft: /* Done shifting */ \ \ __asm mov ecx,[arm7reg+ARMREG_FC*4] /* Read saved carry */ \ __asm shr ecx,1 /* Shift into x86 c */ \ __asm shftdone: /* all done! */ \ __asm setc [arm7reg+ARMREG_TC*4] \ } #define ARM7addrDPllr() \ ARM7addrDPops(); \ __asm { \ __asm cmp ecx,15 \ __asm jl pt3 \ __asm add ebx,4 \ __asm pt3: \ \ __asm mov ecx,edx /* Make op copy */ \ __asm shr edx,12 /* Extract Rd */ \ __asm and edx,15 /* Limit to 15 */ \ \ __asm shr ecx,8 /* Shift in Rs */ \ __asm and ecx,15 /* Mask off Rs */ \ __asm mov ecx,[arm7reg+ecx*4] /* Read Rs's value */ \ __asm and ecx,255 /* Get the low byte */ \ __asm jz noshft /* Skip if no shift */ \ __asm shl ebx,cl /* Shift operand1 */ \ __asm jmp shftdone /* And skip carry read */ \ __asm noshft: /* Done shifting */ \ \ __asm mov ecx,[arm7reg+ARMREG_FC*4] /* Read saved carry */ \ __asm shr ecx,1 /* Shift into x86 c */ \ __asm shftdone: /* all done! */ \ __asm setc [arm7reg+ARMREG_TC*4] \ } #define ARM7addrDPlri() \ ARM7addrDPops(); \ __asm { \ __asm mov ecx,edx /* Make op copy */ \ __asm shr edx,12 /* Extract Rd */ \ __asm and edx,15 /* Limit to 15 */ \ \ __asm shr ecx,7 /* Shift in shftamount */ \ __asm and ecx,31 /* Mask off amount */ \ __asm jz noshft /* Skip if no shift */ \ __asm shr ebx,cl /* Shift operand1 */ \ __asm jmp shftdone /* And skip carry read */ \ __asm noshft: /* Done shifting */ \ \ __asm mov ecx,ebx /* Make a copy */ \ __asm xor ebx,ebx /* Rm=0 */ \ __asm shl ecx,1 /* Carry = Rm[31] */ \ __asm shftdone: /* all done! */ \ __asm setc [arm7reg+ARMREG_TC*4] \ } #define ARM7addrDPlrr() \ ARM7addrDPops(); \ __asm { \ __asm cmp ecx,15 \ __asm jl pt3 \ __asm add ebx,4 \ __asm pt3: \ \ __asm mov ecx,edx /* Make op copy */ \ __asm shr edx,12 /* Extract Rd */ \ __asm and edx,15 /* Limit to 15 */ \ \ __asm shr ecx,8 /* Shift in Rs */ \ __asm and ecx,15 /* Mask off Rs */ \ __asm mov ecx,[arm7reg+ecx*4] /* Read Rs's value */ \ __asm and ecx,255 /* Get the low byte */ \ __asm jz noshft /* Skip if no shift */ \ __asm cmp cl,32 /* If greater than 32 */ \ __asm jg overshft /* Shift all the way */ \ __asm je fullshft /* If equal, shift to carry */ \ __asm shr ebx,cl /* Shift operand1 */ \ __asm jmp shftdone /* And skip carry read */ \ __asm noshft: /* Done shifting */ \ \ __asm mov ecx,[arm7reg+ARMREG_FC*4] /* Read saved carry */ \ __asm shr ecx,1 /* Shift into x86 c */ \ __asm jmp shftdone /* Skip over */ \ __asm fullshft: /* Shift by 32 */ \ __asm mov ecx,ebx /* Make a copy */ \ __asm xor ebx,ebx /* Rm=0 */ \ __asm shl ecx,1 /* Carry = Rm[31] */ \ __asm jmp shftdone /* Skip over */ \ __asm overshft: /* Shift over 32 */ \ __asm xor ebx,ebx /* Rm=0 */ \ __asm shr ebx,1 /* And carry=0 */ \ __asm shftdone: /* all done! */ \ __asm setc [arm7reg+ARMREG_TC*4] \ } #define ARM7addrDPari() \ ARM7addrDPops(); \ __asm { \ __asm mov ecx,edx /* Make op copy */ \ __asm shr edx,12 /* Extract Rd */ \ __asm and edx,15 /* Limit to 15 */ \ \ __asm shr ecx,7 /* Shift in shftamount */ \ __asm and ecx,31 /* Mask off amount */ \ __asm jz noshft /* Skip if no shift */ \ __asm sar ebx,cl /* Shift operand1 */ \ __asm jmp shftdone /* And skip carry read */ \ __asm noshft: /* Done shifting */ \ \ __asm mov ecx,ebx /* Make a copy */ \ __asm sar ebx,31 /* Fill with hi bit */ \ __asm shl ecx,1 /* Carry = Rm[31] */ \ __asm shftdone: /* all done! */ \ __asm setc [arm7reg+ARMREG_TC*4] \ } #define ARM7addrDParr() \ ARM7addrDPops(); \ __asm { \ __asm cmp ecx,15 \ __asm jl pt3 \ __asm add ebx,4 \ __asm pt3: \ \ __asm mov ecx,edx /* Make op copy */ \ __asm shr edx,12 /* Extract Rd */ \ __asm and edx,15 /* Limit to 15 */ \ \ __asm shr ecx,8 /* Shift in Rs */ \ __asm and ecx,15 /* Mask off Rs */ \ __asm mov ecx,[arm7reg+ecx*4] /* Read Rs's value */ \ __asm and ecx,255 /* Get the low byte */ \ __asm jz noshft /* Skip if no shift */ \ __asm cmp cl,32 /* If greater than 32 */ \ __asm jge fullshft /* Shift all the way */ \ __asm sar ebx,cl /* Shift operand1 */ \ __asm jmp shftdone /* And skip carry read */ \ __asm noshft: /* Done shifting */ \ \ __asm mov ecx,[arm7reg+ARMREG_FC*4] /* Read saved carry */ \ __asm shr ecx,1 /* Shift into x86 c */ \ __asm jmp shftdone /* and skip over */ \ __asm fullshft: /* shift over 31 */ \ __asm mov ecx,ebx /* Make a copy */ \ __asm sar ebx,31 /* Fill with hi bit */ \ __asm shl ecx,1 /* Carry = Rm[31] */ \ __asm shftdone: /* all done! */ \ __asm setc [arm7reg+ARMREG_TC*4] \ } #define ARM7addrDPrri() \ ARM7addrDPops(); \ __asm { \ __asm mov ecx,edx /* Make op copy */ \ __asm shr edx,12 /* Extract Rd */ \ __asm and edx,15 /* Limit to 15 */ \ \ __asm shr ecx,7 /* Shift in shftamount */ \ __asm and ecx,31 /* Mask off amount */ \ __asm jz noshft /* Skip if no shift */ \ __asm ror ebx,cl /* Shift operand1 */ \ /* __asm mov ecx,ebx */ \ /* __asm shr ecx,1 */ \ __asm jmp shftdone /* And skip carry read */ \ __asm noshft: /* Done shifting */ \ \ __asm push ebx /* Keep orig value */ \ __asm mov ecx,[arm7reg+ARMREG_FC*4] /* Read saved carry */ \ __asm shl ecx,31 /* Shift to high */ \ __asm shr ebx,1 /* 33-bit shift */ \ __asm or ebx,ecx /* Add together */ \ __asm pop ecx /* Get orig back */ \ __asm shr ecx,1 /* Carry = Rm[0] */ \ __asm shftdone: /* all done! */ \ __asm setc [arm7reg+ARMREG_TC*4] \ } #define ARM7addrDPrrr() \ ARM7addrDPops(); \ __asm { \ __asm cmp ecx,15 \ __asm jl pt3 \ __asm add ebx,4 \ __asm pt3: \ \ __asm mov ecx,edx /* Make op copy */ \ __asm shr edx,12 /* Extract Rd */ \ __asm and edx,15 /* Limit to 15 */ \ \ __asm shr ecx,8 /* Shift in Rs */ \ __asm and ecx,15 /* Mask off Rs */ \ __asm mov ecx,[arm7reg+ecx*4] /* Read Rs's value */ \ __asm and ecx,255 /* Get the low byte */ \ __asm jz noshft /* Skip if no shift */ \ __asm and cl,31 /* Check [4:0] */ \ __asm jz fullshft /* And skip if full */ \ __asm ror ebx,cl /* Shift operand1 */ \ /* __asm mov ecx,ebx*/ \ /* __asm shr ecx,1*/ \ __asm jmp shftdone /* And skip carry read */ \ __asm noshft: /* Done shifting */ \ \ __asm mov ecx,[arm7reg+ARMREG_FC*4] /* Read saved carry */ \ __asm shr ecx,1 /* Shift into x86 c */ \ __asm jmp shftdone /* Skip over */ \ __asm fullshft: /* Shifting by full */ \ __asm mov ecx,ebx /* Make a copy of Rm */ \ __asm shl ecx,1 /* Carry = hi bit */ \ __asm shftdone: /* all done! */ \ __asm setc [arm7reg+ARMREG_TC*4] \ } /*---eax=operand1, ebx=operand2, edx=destreg----*/ #define ARM7opAND() \ __asm { \ __asm and eax,ebx \ __asm mov [arm7reg+edx*4],eax \ } #define ARM7opEOR() \ __asm { \ __asm xor eax,ebx \ __asm mov [arm7reg+edx*4],eax \ } #define ARM7opSUB() \ __asm { \ __asm sub eax,ebx \ __asm mov [arm7reg+edx*4],eax \ } #define ARM7opRSB() \ __asm { \ __asm mov ecx,[arm7reg+ARMREG_TC*4] \ __asm not ecx \ __asm shr ecx,1 \ __asm sub ebx,eax \ __asm mov [arm7reg+edx*4],ebx \ } #define ARM7opADD() \ __asm { \ __asm add eax,ebx \ __asm mov [arm7reg+edx*4],eax \ } #define ARM7opADC() \ __asm { \ __asm adc eax,ebx \ __asm mov [arm7reg+edx*4],eax \ } #define ARM7opSBC() \ __asm { \ __asm mov ecx,[arm7reg+ARMREG_TC*4] \ __asm not ecx \ __asm shr ecx,1 \ __asm sbb eax,ebx \ __asm mov [arm7reg+edx*4],eax \ } #define ARM7opRSC() \ __asm { \ __asm mov ecx,[arm7reg+ARMREG_TC*4] \ __asm not ecx \ __asm shr ecx,1 \ __asm sbb ebx,eax \ __asm mov [arm7reg+edx*4],ebx \ } #define ARM7opTST() \ __asm { \ __asm and eax,ebx \ } #define ARM7opTEQ() \ __asm { \ __asm xor eax,ebx \ } #define ARM7opCMP() \ __asm { \ __asm sub eax,ebx \ } #define ARM7opCMN() \ __asm { \ __asm add eax,ebx \ } #define ARM7opORR() \ __asm { \ __asm or eax,ebx \ __asm mov [arm7reg+edx*4],eax \ } #define ARM7opMOV() \ __asm { \ __asm or ebx,ebx \ __asm mov [arm7reg+edx*4],ebx \ } #define ARM7opBIC() \ __asm { \ __asm not ebx \ __asm and ebx,eax \ __asm mov [arm7reg+edx*4],ebx \ } #define ARM7opMVN() \ __asm { \ __asm not ebx \ __asm mov [arm7reg+edx*4],ebx \ } #define ARM7addrDPflagR15() \ __asm { \ __asm cmp edx,15 /* Is Rd 15? */ \ __asm jl flagdone /* If not, skip */ \ __asm mov eax,[arm7reg+ARMREG_MODE*4] /* Get current mode */ \ __asm mov eax,[arm7reg+17*4+eax*4] /* Read mode's SPSR */ \ __asm mov ecx,eax /* Make a copy of it */ \ __asm mov ebx,[arm7reg+ARMREG_CPSR*4] /* Read CPSR */ \ __asm and ecx,15 /* Mask spsr mode */ \ __asm and ebx,15 /* and cpsr mode */ \ __asm cmp ecx,ebx /* They the same? */ \ __asm je flageq /* If so, skip */ \ __asm push eax /* modesw mods eax */ \ __asm push [ARM7cpsrtomode+ecx*4] /* New mode */ \ __asm push [ARM7cpsrtomode+ebx*4] /* Old mode */ \ __asm call ARM7modesw /* Switch modes */ \ __asm pop eax /* Pull param2 */ \ __asm pop eax /* and param1 */ \ __asm pop eax /* Get eax back */ \ __asm flageq: /* Modes unchanged */ \ __asm mov [arm7reg+ARMREG_CPSR*4],eax /* CPSR=SPSR */ \ __asm call ARM7splitCPSR /* Redo flags */ \ __asm flagdone: /* All done! */ \ } #define ARM7addrDPflagBIT() \ __asm { \ __asm sets [arm7reg+ARMREG_FN*4] /* Copy N flag */ \ __asm setz [arm7reg+ARMREG_FZ*4] /* and Z flag */ \ __asm mov ecx,[arm7reg+ARMREG_TC*4] \ __asm mov [arm7reg+ARMREG_FC*4],ecx \ } \ ARM7addrDPflagR15() #define ARM7addrDPflagADD() \ __asm { \ __asm sets [arm7reg+ARMREG_FN*4] /* Copy N flag */ \ __asm setz [arm7reg+ARMREG_FZ*4] /* and Z flag */ \ __asm seto [arm7reg+ARMREG_FV*4] /* V too */ \ __asm setc [arm7reg+ARMREG_FC*4] /* REVERSE C flag */ \ } \ ARM7addrDPflagR15() #define ARM7addrDPflagADC() \ __asm { \ __asm sets [arm7reg+ARMREG_FN*4] /* Copy N flag */ \ __asm setz [arm7reg+ARMREG_FZ*4] /* and Z flag */ \ __asm seto [arm7reg+ARMREG_FV*4] /* V too */ \ __asm setc [arm7reg+ARMREG_FC*4] /* REVERSE C flag */ \ } \ ARM7addrDPflagR15() #define ARM7addrDPflagSUB() \ __asm { \ __asm sets [arm7reg+ARMREG_FN*4] /* Copy N flag */ \ __asm setz [arm7reg+ARMREG_FZ*4] /* and Z flag */ \ __asm seto [arm7reg+ARMREG_FV*4] /* V too */ \ __asm setnc [arm7reg+ARMREG_FC*4] /* REVERSE C flag */ \ } \ ARM7addrDPflagR15() #define ARM7addrDPflagSBC() \ __asm { \ __asm sets [arm7reg+ARMREG_FN*4] /* Copy N flag */ \ __asm setz [arm7reg+ARMREG_FZ*4] /* and Z flag */ \ __asm seto [arm7reg+ARMREG_FV*4] /* V too */ \ __asm setnc [arm7reg+ARMREG_FC*4] /* REVERSE C flag */ \ } \ ARM7addrDPflagR15() #define ARM7addrDPflagRSB() \ __asm { \ __asm sets [arm7reg+ARMREG_FN*4] /* Copy N flag */ \ __asm setz [arm7reg+ARMREG_FZ*4] /* and Z flag */ \ __asm seto [arm7reg+ARMREG_FV*4] /* V too */ \ __asm setnc [arm7reg+ARMREG_FC*4] /* REVERSE C flag */ \ } \ ARM7addrDPflagR15() #define ARM7addrDPflagRSC() \ __asm { \ __asm sets [arm7reg+ARMREG_FN*4] /* Copy N flag */ \ __asm setz [arm7reg+ARMREG_FZ*4] /* and Z flag */ \ __asm seto [arm7reg+ARMREG_FV*4] /* V too */ \ __asm setnc [arm7reg+ARMREG_FC*4] /* REVERSE C flag */ \ } \ ARM7addrDPflagR15() #define ARM7addrDPflagCMN() \ __asm { \ __asm sets [arm7reg+ARMREG_FN*4] /* Copy N flag */ \ __asm setz [arm7reg+ARMREG_FZ*4] /* and Z flag */ \ __asm seto [arm7reg+ARMREG_FV*4] /* V too */ \ __asm setc [arm7reg+ARMREG_FC*4] /* REVERSE C flag */ \ } \ ARM7addrDPflagR15() #define ARM7addrDPflagCMP() \ __asm { \ __asm sets [arm7reg+ARMREG_FN*4] /* Copy N flag */ \ __asm setz [arm7reg+ARMREG_FZ*4] /* and Z flag */ \ __asm seto [arm7reg+ARMREG_FV*4] /* V too */ \ __asm setnc [arm7reg+ARMREG_FC*4] /* REVERSE C flag */ \ } \ ARM7addrDPflagR15() OPCODE ARM7opANDreg() { ARM7addrDPreg(); ARM7opAND(); return 2; } OPCODE ARM7opANDimm() { ARM7addrDPimm(); ARM7opAND(); return 1; } OPCODE ARM7opANDlli() { ARM7addrDPlli(); ARM7opAND(); return 2; } OPCODE ARM7opANDllr() { ARM7addrDPllr(); ARM7opAND(); return 2; } OPCODE ARM7opANDlri() { ARM7addrDPlri(); ARM7opAND(); return 2; } OPCODE ARM7opANDlrr() { ARM7addrDPlrr(); ARM7opAND(); return 2; } OPCODE ARM7opANDari() { ARM7addrDPari(); ARM7opAND(); return 2; } OPCODE ARM7opANDarr() { ARM7addrDParr(); ARM7opAND(); return 2; } OPCODE ARM7opANDrri() { ARM7addrDPrri(); ARM7opAND(); return 2; } OPCODE ARM7opANDrrr() { ARM7addrDPrrr(); ARM7opAND(); return 2; } OPCODE ARM7opEORreg() { ARM7addrDPreg(); ARM7opEOR(); return 2; } OPCODE ARM7opEORimm() { ARM7addrDPimm(); ARM7opEOR(); return 1; } OPCODE ARM7opEORlli() { ARM7addrDPlli(); ARM7opEOR(); return 2; } OPCODE ARM7opEORllr() { ARM7addrDPllr(); ARM7opEOR(); return 2; } OPCODE ARM7opEORlri() { ARM7addrDPlri(); ARM7opEOR(); return 2; } OPCODE ARM7opEORlrr() { ARM7addrDPlrr(); ARM7opEOR(); return 2; } OPCODE ARM7opEORari() { ARM7addrDPari(); ARM7opEOR(); return 2; } OPCODE ARM7opEORarr() { ARM7addrDParr(); ARM7opEOR(); return 2; } OPCODE ARM7opEORrri() { ARM7addrDPrri(); ARM7opEOR(); return 2; } OPCODE ARM7opEORrrr() { ARM7addrDPrrr(); ARM7opEOR(); return 2; } OPCODE ARM7opSUBreg() { ARM7addrDPreg(); ARM7opSUB(); return 2; } OPCODE ARM7opSUBimm() { ARM7addrDPimm(); ARM7opSUB(); return 1; } OPCODE ARM7opSUBlli() { ARM7addrDPlli(); ARM7opSUB(); return 2; } OPCODE ARM7opSUBllr() { ARM7addrDPllr(); ARM7opSUB(); return 2; } OPCODE ARM7opSUBlri() { ARM7addrDPlri(); ARM7opSUB(); return 2; } OPCODE ARM7opSUBlrr() { ARM7addrDPlrr(); ARM7opSUB(); return 2; } OPCODE ARM7opSUBari() { ARM7addrDPari(); ARM7opSUB(); return 2; } OPCODE ARM7opSUBarr() { ARM7addrDParr(); ARM7opSUB(); return 2; } OPCODE ARM7opSUBrri() { ARM7addrDPrri(); ARM7opSUB(); return 2; } OPCODE ARM7opSUBrrr() { ARM7addrDPrrr(); ARM7opSUB(); return 2; } OPCODE ARM7opRSBreg() { ARM7addrDPreg(); ARM7opRSB(); return 2; } OPCODE ARM7opRSBimm() { ARM7addrDPimm(); ARM7opRSB(); return 1; } OPCODE ARM7opRSBlli() { ARM7addrDPlli(); ARM7opRSB(); return 2; } OPCODE ARM7opRSBllr() { ARM7addrDPllr(); ARM7opRSB(); return 2; } OPCODE ARM7opRSBlri() { ARM7addrDPlri(); ARM7opRSB(); return 2; } OPCODE ARM7opRSBlrr() { ARM7addrDPlrr(); ARM7opRSB(); return 2; } OPCODE ARM7opRSBari() { ARM7addrDPari(); ARM7opRSB(); return 2; } OPCODE ARM7opRSBarr() { ARM7addrDParr(); ARM7opRSB(); return 2; } OPCODE ARM7opRSBrri() { ARM7addrDPrri(); ARM7opRSB(); return 2; } OPCODE ARM7opRSBrrr() { ARM7addrDPrrr(); ARM7opRSB(); return 2; } OPCODE ARM7opADDreg() { ARM7addrDPreg(); ARM7opADD(); return 2; } OPCODE ARM7opADDimm() { ARM7addrDPimm(); ARM7opADD(); return 1; } OPCODE ARM7opADDlli() { ARM7addrDPlli(); ARM7opADD(); return 2; } OPCODE ARM7opADDllr() { ARM7addrDPllr(); ARM7opADD(); return 2; } OPCODE ARM7opADDlri() { ARM7addrDPlri(); ARM7opADD(); return 2; } OPCODE ARM7opADDlrr() { ARM7addrDPlrr(); ARM7opADD(); return 2; } OPCODE ARM7opADDari() { ARM7addrDPari(); ARM7opADD(); return 2; } OPCODE ARM7opADDarr() { ARM7addrDParr(); ARM7opADD(); return 2; } OPCODE ARM7opADDrri() { ARM7addrDPrri(); ARM7opADD(); return 2; } OPCODE ARM7opADDrrr() { ARM7addrDPrrr(); ARM7opADD(); return 2; } OPCODE ARM7opADCreg() { ARM7addrDPreg(); ARM7opADC(); return 2; } OPCODE ARM7opADCimm() { ARM7addrDPimm(); ARM7opADC(); return 1; } OPCODE ARM7opADClli() { ARM7addrDPlli(); ARM7opADC(); return 2; } OPCODE ARM7opADCllr() { ARM7addrDPllr(); ARM7opADC(); return 2; } OPCODE ARM7opADClri() { ARM7addrDPlri(); ARM7opADC(); return 2; } OPCODE ARM7opADClrr() { ARM7addrDPlrr(); ARM7opADC(); return 2; } OPCODE ARM7opADCari() { ARM7addrDPari(); ARM7opADC(); return 2; } OPCODE ARM7opADCarr() { ARM7addrDParr(); ARM7opADC(); return 2; } OPCODE ARM7opADCrri() { ARM7addrDPrri(); ARM7opADC(); return 2; } OPCODE ARM7opADCrrr() { ARM7addrDPrrr(); ARM7opADC(); return 2; } OPCODE ARM7opSBCreg() { ARM7addrDPreg(); ARM7opSBC(); return 2; } OPCODE ARM7opSBCimm() { ARM7addrDPimm(); ARM7opSBC(); return 1; } OPCODE ARM7opSBClli() { ARM7addrDPlli(); ARM7opSBC(); return 2; } OPCODE ARM7opSBCllr() { ARM7addrDPllr(); ARM7opSBC(); return 2; } OPCODE ARM7opSBClri() { ARM7addrDPlri(); ARM7opSBC(); return 2; } OPCODE ARM7opSBClrr() { ARM7addrDPlrr(); ARM7opSBC(); return 2; } OPCODE ARM7opSBCari() { ARM7addrDPari(); ARM7opSBC(); return 2; } OPCODE ARM7opSBCarr() { ARM7addrDParr(); ARM7opSBC(); return 2; } OPCODE ARM7opSBCrri() { ARM7addrDPrri(); ARM7opSBC(); return 2; } OPCODE ARM7opSBCrrr() { ARM7addrDPrrr(); ARM7opSBC(); return 2; } OPCODE ARM7opRSCreg() { ARM7addrDPreg(); ARM7opRSC(); return 2; } OPCODE ARM7opRSCimm() { ARM7addrDPimm(); ARM7opRSC(); return 1; } OPCODE ARM7opRSClli() { ARM7addrDPlli(); ARM7opRSC(); return 2; } OPCODE ARM7opRSCllr() { ARM7addrDPllr(); ARM7opRSC(); return 2; } OPCODE ARM7opRSClri() { ARM7addrDPlri(); ARM7opRSC(); return 2; } OPCODE ARM7opRSClrr() { ARM7addrDPlrr(); ARM7opRSC(); return 2; } OPCODE ARM7opRSCari() { ARM7addrDPari(); ARM7opRSC(); return 2; } OPCODE ARM7opRSCarr() { ARM7addrDParr(); ARM7opRSC(); return 2; } OPCODE ARM7opRSCrri() { ARM7addrDPrri(); ARM7opRSC(); return 2; } OPCODE ARM7opRSCrrr() { ARM7addrDPrrr(); ARM7opRSC(); return 2; } OPCODE ARM7opTSTreg() { ARM7addrDPreg(); ARM7opTST(); return 2; } OPCODE ARM7opTSTimm() { ARM7addrDPimm(); ARM7opTST(); return 1; } OPCODE ARM7opTSTlli() { ARM7addrDPlli(); ARM7opTST(); return 2; } OPCODE ARM7opTSTllr() { ARM7addrDPllr(); ARM7opTST(); return 2; } OPCODE ARM7opTSTlri() { ARM7addrDPlri(); ARM7opTST(); return 2; } OPCODE ARM7opTSTlrr() { ARM7addrDPlrr(); ARM7opTST(); return 2; } OPCODE ARM7opTSTari() { ARM7addrDPari(); ARM7opTST(); return 2; } OPCODE ARM7opTSTarr() { ARM7addrDParr(); ARM7opTST(); return 2; } OPCODE ARM7opTSTrri() { ARM7addrDPrri(); ARM7opTST(); return 2; } OPCODE ARM7opTSTrrr() { ARM7addrDPrrr(); ARM7opTST(); return 2; } OPCODE ARM7opTEQreg() { ARM7addrDPreg(); ARM7opTEQ(); return 2; } OPCODE ARM7opTEQimm() { ARM7addrDPimm(); ARM7opTEQ(); return 1; } OPCODE ARM7opTEQlli() { ARM7addrDPlli(); ARM7opTEQ(); return 2; } OPCODE ARM7opTEQllr() { ARM7addrDPllr(); ARM7opTEQ(); return 2; } OPCODE ARM7opTEQlri() { ARM7addrDPlri(); ARM7opTEQ(); return 2; } OPCODE ARM7opTEQlrr() { ARM7addrDPlrr(); ARM7opTEQ(); return 2; } OPCODE ARM7opTEQari() { ARM7addrDPari(); ARM7opTEQ(); return 2; } OPCODE ARM7opTEQarr() { ARM7addrDParr(); ARM7opTEQ(); return 2; } OPCODE ARM7opTEQrri() { ARM7addrDPrri(); ARM7opTEQ(); return 2; } OPCODE ARM7opTEQrrr() { ARM7addrDPrrr(); ARM7opTEQ(); return 2; } OPCODE ARM7opCMPreg() { ARM7addrDPreg(); ARM7opCMP(); return 2; } OPCODE ARM7opCMPimm() { ARM7addrDPimm(); ARM7opCMP(); return 1; } OPCODE ARM7opCMPlli() { ARM7addrDPlli(); ARM7opCMP(); return 2; } OPCODE ARM7opCMPllr() { ARM7addrDPllr(); ARM7opCMP(); return 2; } OPCODE ARM7opCMPlri() { ARM7addrDPlri(); ARM7opCMP(); return 2; } OPCODE ARM7opCMPlrr() { ARM7addrDPlrr(); ARM7opCMP(); return 2; } OPCODE ARM7opCMPari() { ARM7addrDPari(); ARM7opCMP(); return 2; } OPCODE ARM7opCMParr() { ARM7addrDParr(); ARM7opCMP(); return 2; } OPCODE ARM7opCMPrri() { ARM7addrDPrri(); ARM7opCMP(); return 2; } OPCODE ARM7opCMPrrr() { ARM7addrDPrrr(); ARM7opCMP(); return 2; } OPCODE ARM7opCMNreg() { ARM7addrDPreg(); ARM7opCMN(); return 2; } OPCODE ARM7opCMNimm() { ARM7addrDPimm(); ARM7opCMN(); return 1; } OPCODE ARM7opCMNlli() { ARM7addrDPlli(); ARM7opCMN(); return 2; } OPCODE ARM7opCMNllr() { ARM7addrDPllr(); ARM7opCMN(); return 2; } OPCODE ARM7opCMNlri() { ARM7addrDPlri(); ARM7opCMN(); return 2; } OPCODE ARM7opCMNlrr() { ARM7addrDPlrr(); ARM7opCMN(); return 2; } OPCODE ARM7opCMNari() { ARM7addrDPari(); ARM7opCMN(); return 2; } OPCODE ARM7opCMNarr() { ARM7addrDParr(); ARM7opCMN(); return 2; } OPCODE ARM7opCMNrri() { ARM7addrDPrri(); ARM7opCMN(); return 2; } OPCODE ARM7opCMNrrr() { ARM7addrDPrrr(); ARM7opCMN(); return 2; } OPCODE ARM7opORRreg() { ARM7addrDPreg(); ARM7opORR(); return 2; } OPCODE ARM7opORRimm() { ARM7addrDPimm(); ARM7opORR(); return 1; } OPCODE ARM7opORRlli() { ARM7addrDPlli(); ARM7opORR(); return 2; } OPCODE ARM7opORRllr() { ARM7addrDPllr(); ARM7opORR(); return 2; } OPCODE ARM7opORRlri() { ARM7addrDPlri(); ARM7opORR(); return 2; } OPCODE ARM7opORRlrr() { ARM7addrDPlrr(); ARM7opORR(); return 2; } OPCODE ARM7opORRari() { ARM7addrDPari(); ARM7opORR(); return 2; } OPCODE ARM7opORRarr() { ARM7addrDParr(); ARM7opORR(); return 2; } OPCODE ARM7opORRrri() { ARM7addrDPrri(); ARM7opORR(); return 2; } OPCODE ARM7opORRrrr() { ARM7addrDPrrr(); ARM7opORR(); return 2; } OPCODE ARM7opMOVreg() { ARM7addrDPreg(); ARM7opMOV(); return 2; } OPCODE ARM7opMOVimm() { ARM7addrDPimm(); ARM7opMOV(); return 1; } OPCODE ARM7opMOVlli() { ARM7addrDPlli(); ARM7opMOV(); return 2; } OPCODE ARM7opMOVllr() { ARM7addrDPllr(); ARM7opMOV(); return 2; } OPCODE ARM7opMOVlri() { ARM7addrDPlri(); ARM7opMOV(); return 2; } OPCODE ARM7opMOVlrr() { ARM7addrDPlrr(); ARM7opMOV(); return 2; } OPCODE ARM7opMOVari() { ARM7addrDPari(); ARM7opMOV(); return 2; } OPCODE ARM7opMOVarr() { ARM7addrDParr(); ARM7opMOV(); return 2; } OPCODE ARM7opMOVrri() { ARM7addrDPrri(); ARM7opMOV(); return 2; } OPCODE ARM7opMOVrrr() { ARM7addrDPrrr(); ARM7opMOV(); return 2; } OPCODE ARM7opBICreg() { ARM7addrDPreg(); ARM7opBIC(); return 2; } OPCODE ARM7opBICimm() { ARM7addrDPimm(); ARM7opBIC(); return 1; } OPCODE ARM7opBIClli() { ARM7addrDPlli(); ARM7opBIC(); return 2; } OPCODE ARM7opBICllr() { ARM7addrDPllr(); ARM7opBIC(); return 2; } OPCODE ARM7opBIClri() { ARM7addrDPlri(); ARM7opBIC(); return 2; } OPCODE ARM7opBIClrr() { ARM7addrDPlrr(); ARM7opBIC(); return 2; } OPCODE ARM7opBICari() { ARM7addrDPari(); ARM7opBIC(); return 2; } OPCODE ARM7opBICarr() { ARM7addrDParr(); ARM7opBIC(); return 2; } OPCODE ARM7opBICrri() { ARM7addrDPrri(); ARM7opBIC(); return 2; } OPCODE ARM7opBICrrr() { ARM7addrDPrrr(); ARM7opBIC(); return 2; } OPCODE ARM7opMVNreg() { ARM7addrDPreg(); ARM7opMVN(); return 2; } OPCODE ARM7opMVNimm() { ARM7addrDPimm(); ARM7opMVN(); return 1; } OPCODE ARM7opMVNlli() { ARM7addrDPlli(); ARM7opMVN(); return 2; } OPCODE ARM7opMVNllr() { ARM7addrDPllr(); ARM7opMVN(); return 2; } OPCODE ARM7opMVNlri() { ARM7addrDPlri(); ARM7opMVN(); return 2; } OPCODE ARM7opMVNlrr() { ARM7addrDPlrr(); ARM7opMVN(); return 2; } OPCODE ARM7opMVNari() { ARM7addrDPari(); ARM7opMVN(); return 2; } OPCODE ARM7opMVNarr() { ARM7addrDParr(); ARM7opMVN(); return 2; } OPCODE ARM7opMVNrri() { ARM7addrDPrri(); ARM7opMVN(); return 2; } OPCODE ARM7opMVNrrr() { ARM7addrDPrrr(); ARM7opMVN(); return 2; } OPCODE ARM7opANDSreg() { ARM7addrDPreg(); ARM7opAND(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opANDSimm() { ARM7addrDPimm(); ARM7opAND(); ARM7addrDPflagBIT(); return 1; } OPCODE ARM7opANDSlli() { ARM7addrDPlli(); ARM7opAND(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opANDSllr() { ARM7addrDPllr(); ARM7opAND(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opANDSlri() { ARM7addrDPlri(); ARM7opAND(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opANDSlrr() { ARM7addrDPlrr(); ARM7opAND(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opANDSari() { ARM7addrDPari(); ARM7opAND(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opANDSarr() { ARM7addrDParr(); ARM7opAND(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opANDSrri() { ARM7addrDPrri(); ARM7opAND(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opANDSrrr() { ARM7addrDPrrr(); ARM7opAND(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opEORSreg() { ARM7addrDPreg(); ARM7opEOR(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opEORSimm() { ARM7addrDPimm(); ARM7opEOR(); ARM7addrDPflagBIT(); return 1; } OPCODE ARM7opEORSlli() { ARM7addrDPlli(); ARM7opEOR(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opEORSllr() { ARM7addrDPllr(); ARM7opEOR(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opEORSlri() { ARM7addrDPlri(); ARM7opEOR(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opEORSlrr() { ARM7addrDPlrr(); ARM7opEOR(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opEORSari() { ARM7addrDPari(); ARM7opEOR(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opEORSarr() { ARM7addrDParr(); ARM7opEOR(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opEORSrri() { ARM7addrDPrri(); ARM7opEOR(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opEORSrrr() { ARM7addrDPrrr(); ARM7opEOR(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opSUBSreg() { ARM7addrDPreg(); ARM7opSUB(); ARM7addrDPflagSUB(); return 2; } OPCODE ARM7opSUBSimm() { ARM7addrDPimm(); ARM7opSUB(); ARM7addrDPflagSUB(); return 1; } OPCODE ARM7opSUBSlli() { ARM7addrDPlli(); ARM7opSUB(); ARM7addrDPflagSUB(); return 2; } OPCODE ARM7opSUBSllr() { ARM7addrDPllr(); ARM7opSUB(); ARM7addrDPflagSUB(); return 2; } OPCODE ARM7opSUBSlri() { ARM7addrDPlri(); ARM7opSUB(); ARM7addrDPflagSUB(); return 2; } OPCODE ARM7opSUBSlrr() { ARM7addrDPlrr(); ARM7opSUB(); ARM7addrDPflagSUB(); return 2; } OPCODE ARM7opSUBSari() { ARM7addrDPari(); ARM7opSUB(); ARM7addrDPflagSUB(); return 2; } OPCODE ARM7opSUBSarr() { ARM7addrDParr(); ARM7opSUB(); ARM7addrDPflagSUB(); return 2; } OPCODE ARM7opSUBSrri() { ARM7addrDPrri(); ARM7opSUB(); ARM7addrDPflagSUB(); return 2; } OPCODE ARM7opSUBSrrr() { ARM7addrDPrrr(); ARM7opSUB(); ARM7addrDPflagSUB(); return 2; } OPCODE ARM7opRSBSreg() { ARM7addrDPreg(); ARM7opRSB(); ARM7addrDPflagRSB(); return 2; } OPCODE ARM7opRSBSimm() { ARM7addrDPimm(); ARM7opRSB(); ARM7addrDPflagRSB(); return 1; } OPCODE ARM7opRSBSlli() { ARM7addrDPlli(); ARM7opRSB(); ARM7addrDPflagRSB(); return 2; } OPCODE ARM7opRSBSllr() { ARM7addrDPllr(); ARM7opRSB(); ARM7addrDPflagRSB(); return 2; } OPCODE ARM7opRSBSlri() { ARM7addrDPlri(); ARM7opRSB(); ARM7addrDPflagRSB(); return 2; } OPCODE ARM7opRSBSlrr() { ARM7addrDPlrr(); ARM7opRSB(); ARM7addrDPflagRSB(); return 2; } OPCODE ARM7opRSBSari() { ARM7addrDPari(); ARM7opRSB(); ARM7addrDPflagRSB(); return 2; } OPCODE ARM7opRSBSarr() { ARM7addrDParr(); ARM7opRSB(); ARM7addrDPflagRSB(); return 2; } OPCODE ARM7opRSBSrri() { ARM7addrDPrri(); ARM7opRSB(); ARM7addrDPflagRSB(); return 2; } OPCODE ARM7opRSBSrrr() { ARM7addrDPrrr(); ARM7opRSB(); ARM7addrDPflagRSB(); return 2; } OPCODE ARM7opADDSreg() { ARM7addrDPreg(); ARM7opADD(); ARM7addrDPflagADD(); return 2; } OPCODE ARM7opADDSimm() { ARM7addrDPimm(); ARM7opADD(); ARM7addrDPflagADD(); return 1; } OPCODE ARM7opADDSlli() { ARM7addrDPlli(); ARM7opADD(); ARM7addrDPflagADD(); return 2; } OPCODE ARM7opADDSllr() { ARM7addrDPllr(); ARM7opADD(); ARM7addrDPflagADD(); return 2; } OPCODE ARM7opADDSlri() { ARM7addrDPlri(); ARM7opADD(); ARM7addrDPflagADD(); return 2; } OPCODE ARM7opADDSlrr() { ARM7addrDPlrr(); ARM7opADD(); ARM7addrDPflagADD(); return 2; } OPCODE ARM7opADDSari() { ARM7addrDPari(); ARM7opADD(); ARM7addrDPflagADD(); return 2; } OPCODE ARM7opADDSarr() { ARM7addrDParr(); ARM7opADD(); ARM7addrDPflagADD(); return 2; } OPCODE ARM7opADDSrri() { ARM7addrDPrri(); ARM7opADD(); ARM7addrDPflagADD(); return 2; } OPCODE ARM7opADDSrrr() { ARM7addrDPrrr(); ARM7opADD(); ARM7addrDPflagADD(); return 2; } OPCODE ARM7opADCSreg() { ARM7addrDPreg(); ARM7opADC(); ARM7addrDPflagADC(); return 2; } OPCODE ARM7opADCSimm() { ARM7addrDPimm(); ARM7opADC(); ARM7addrDPflagADC(); return 1; } OPCODE ARM7opADCSlli() { ARM7addrDPlli(); ARM7opADC(); ARM7addrDPflagADC(); return 2; } OPCODE ARM7opADCSllr() { ARM7addrDPllr(); ARM7opADC(); ARM7addrDPflagADC(); return 2; } OPCODE ARM7opADCSlri() { ARM7addrDPlri(); ARM7opADC(); ARM7addrDPflagADC(); return 2; } OPCODE ARM7opADCSlrr() { ARM7addrDPlrr(); ARM7opADC(); ARM7addrDPflagADC(); return 2; } OPCODE ARM7opADCSari() { ARM7addrDPari(); ARM7opADC(); ARM7addrDPflagADC(); return 2; } OPCODE ARM7opADCSarr() { ARM7addrDParr(); ARM7opADC(); ARM7addrDPflagADC(); return 2; } OPCODE ARM7opADCSrri() { ARM7addrDPrri(); ARM7opADC(); ARM7addrDPflagADC(); return 2; } OPCODE ARM7opADCSrrr() { ARM7addrDPrrr(); ARM7opADC(); ARM7addrDPflagADC(); return 2; } OPCODE ARM7opSBCSreg() { ARM7addrDPreg(); ARM7opSBC(); ARM7addrDPflagSBC(); return 2; } OPCODE ARM7opSBCSimm() { ARM7addrDPimm(); ARM7opSBC(); ARM7addrDPflagSBC(); return 1; } OPCODE ARM7opSBCSlli() { ARM7addrDPlli(); ARM7opSBC(); ARM7addrDPflagSBC(); return 2; } OPCODE ARM7opSBCSllr() { ARM7addrDPllr(); ARM7opSBC(); ARM7addrDPflagSBC(); return 2; } OPCODE ARM7opSBCSlri() { ARM7addrDPlri(); ARM7opSBC(); ARM7addrDPflagSBC(); return 2; } OPCODE ARM7opSBCSlrr() { ARM7addrDPlrr(); ARM7opSBC(); ARM7addrDPflagSBC(); return 2; } OPCODE ARM7opSBCSari() { ARM7addrDPari(); ARM7opSBC(); ARM7addrDPflagSBC(); return 2; } OPCODE ARM7opSBCSarr() { ARM7addrDParr(); ARM7opSBC(); ARM7addrDPflagSBC(); return 2; } OPCODE ARM7opSBCSrri() { ARM7addrDPrri(); ARM7opSBC(); ARM7addrDPflagSBC(); return 2; } OPCODE ARM7opSBCSrrr() { ARM7addrDPrrr(); ARM7opSBC(); ARM7addrDPflagSBC(); return 2; } OPCODE ARM7opRSCSreg() { ARM7addrDPreg(); ARM7opRSC(); ARM7addrDPflagRSC(); return 2; } OPCODE ARM7opRSCSimm() { ARM7addrDPimm(); ARM7opRSC(); ARM7addrDPflagRSC(); return 1; } OPCODE ARM7opRSCSlli() { ARM7addrDPlli(); ARM7opRSC(); ARM7addrDPflagRSC(); return 2; } OPCODE ARM7opRSCSllr() { ARM7addrDPllr(); ARM7opRSC(); ARM7addrDPflagRSC(); return 2; } OPCODE ARM7opRSCSlri() { ARM7addrDPlri(); ARM7opRSC(); ARM7addrDPflagRSC(); return 2; } OPCODE ARM7opRSCSlrr() { ARM7addrDPlrr(); ARM7opRSC(); ARM7addrDPflagRSC(); return 2; } OPCODE ARM7opRSCSari() { ARM7addrDPari(); ARM7opRSC(); ARM7addrDPflagRSC(); return 2; } OPCODE ARM7opRSCSarr() { ARM7addrDParr(); ARM7opRSC(); ARM7addrDPflagRSC(); return 2; } OPCODE ARM7opRSCSrri() { ARM7addrDPrri(); ARM7opRSC(); ARM7addrDPflagRSC(); return 2; } OPCODE ARM7opRSCSrrr() { ARM7addrDPrrr(); ARM7opRSC(); ARM7addrDPflagRSC(); return 2; } OPCODE ARM7opTSTSreg() { ARM7addrDPreg(); ARM7opTST(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opTSTSimm() { ARM7addrDPimm(); ARM7opTST(); ARM7addrDPflagBIT(); return 1; } OPCODE ARM7opTSTSlli() { ARM7addrDPlli(); ARM7opTST(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opTSTSllr() { ARM7addrDPllr(); ARM7opTST(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opTSTSlri() { ARM7addrDPlri(); ARM7opTST(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opTSTSlrr() { ARM7addrDPlrr(); ARM7opTST(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opTSTSari() { ARM7addrDPari(); ARM7opTST(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opTSTSarr() { ARM7addrDParr(); ARM7opTST(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opTSTSrri() { ARM7addrDPrri(); ARM7opTST(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opTSTSrrr() { ARM7addrDPrrr(); ARM7opTST(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opTEQSreg() { ARM7addrDPreg(); ARM7opTEQ(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opTEQSimm() { ARM7addrDPimm(); ARM7opTEQ(); ARM7addrDPflagBIT(); return 1; } OPCODE ARM7opTEQSlli() { ARM7addrDPlli(); ARM7opTEQ(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opTEQSllr() { ARM7addrDPllr(); ARM7opTEQ(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opTEQSlri() { ARM7addrDPlri(); ARM7opTEQ(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opTEQSlrr() { ARM7addrDPlrr(); ARM7opTEQ(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opTEQSari() { ARM7addrDPari(); ARM7opTEQ(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opTEQSarr() { ARM7addrDParr(); ARM7opTEQ(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opTEQSrri() { ARM7addrDPrri(); ARM7opTEQ(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opTEQSrrr() { ARM7addrDPrrr(); ARM7opTEQ(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opCMPSreg() { ARM7addrDPreg(); ARM7opCMP(); ARM7addrDPflagCMP(); return 2; } OPCODE ARM7opCMPSimm() { ARM7addrDPimm(); ARM7opCMP(); ARM7addrDPflagCMP(); return 1; } OPCODE ARM7opCMPSlli() { ARM7addrDPlli(); ARM7opCMP(); ARM7addrDPflagCMP(); return 2; } OPCODE ARM7opCMPSllr() { ARM7addrDPllr(); ARM7opCMP(); ARM7addrDPflagCMP(); return 2; } OPCODE ARM7opCMPSlri() { ARM7addrDPlri(); ARM7opCMP(); ARM7addrDPflagCMP(); return 2; } OPCODE ARM7opCMPSlrr() { ARM7addrDPlrr(); ARM7opCMP(); ARM7addrDPflagCMP(); return 2; } OPCODE ARM7opCMPSari() { ARM7addrDPari(); ARM7opCMP(); ARM7addrDPflagCMP(); return 2; } OPCODE ARM7opCMPSarr() { ARM7addrDParr(); ARM7opCMP(); ARM7addrDPflagCMP(); return 2; } OPCODE ARM7opCMPSrri() { ARM7addrDPrri(); ARM7opCMP(); ARM7addrDPflagCMP(); return 2; } OPCODE ARM7opCMPSrrr() { ARM7addrDPrrr(); ARM7opCMP(); ARM7addrDPflagCMP(); return 2; } OPCODE ARM7opCMNSreg() { ARM7addrDPreg(); ARM7opCMN(); ARM7addrDPflagCMN(); return 2; } OPCODE ARM7opCMNSimm() { ARM7addrDPimm(); ARM7opCMN(); ARM7addrDPflagCMN(); return 1; } OPCODE ARM7opCMNSlli() { ARM7addrDPlli(); ARM7opCMN(); ARM7addrDPflagCMN(); return 2; } OPCODE ARM7opCMNSllr() { ARM7addrDPllr(); ARM7opCMN(); ARM7addrDPflagCMN(); return 2; } OPCODE ARM7opCMNSlri() { ARM7addrDPlri(); ARM7opCMN(); ARM7addrDPflagCMN(); return 2; } OPCODE ARM7opCMNSlrr() { ARM7addrDPlrr(); ARM7opCMN(); ARM7addrDPflagCMN(); return 2; } OPCODE ARM7opCMNSari() { ARM7addrDPari(); ARM7opCMN(); ARM7addrDPflagCMN(); return 2; } OPCODE ARM7opCMNSarr() { ARM7addrDParr(); ARM7opCMN(); ARM7addrDPflagCMN(); return 2; } OPCODE ARM7opCMNSrri() { ARM7addrDPrri(); ARM7opCMN(); ARM7addrDPflagCMN(); return 2; } OPCODE ARM7opCMNSrrr() { ARM7addrDPrrr(); ARM7opCMN(); ARM7addrDPflagCMN(); return 2; } OPCODE ARM7opORRSreg() { ARM7addrDPreg(); ARM7opORR(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opORRSimm() { ARM7addrDPimm(); ARM7opORR(); ARM7addrDPflagBIT(); return 1; } OPCODE ARM7opORRSlli() { ARM7addrDPlli(); ARM7opORR(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opORRSllr() { ARM7addrDPllr(); ARM7opORR(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opORRSlri() { ARM7addrDPlri(); ARM7opORR(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opORRSlrr() { ARM7addrDPlrr(); ARM7opORR(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opORRSari() { ARM7addrDPari(); ARM7opORR(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opORRSarr() { ARM7addrDParr(); ARM7opORR(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opORRSrri() { ARM7addrDPrri(); ARM7opORR(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opORRSrrr() { ARM7addrDPrrr(); ARM7opORR(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opMOVSreg() { ARM7addrDPreg(); ARM7opMOV(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opMOVSimm() { ARM7addrDPimm(); ARM7opMOV(); ARM7addrDPflagBIT(); return 1; } OPCODE ARM7opMOVSlli() { ARM7addrDPlli(); ARM7opMOV(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opMOVSllr() { ARM7addrDPllr(); ARM7opMOV(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opMOVSlri() { ARM7addrDPlri(); ARM7opMOV(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opMOVSlrr() { ARM7addrDPlrr(); ARM7opMOV(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opMOVSari() { ARM7addrDPari(); ARM7opMOV(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opMOVSarr() { ARM7addrDParr(); ARM7opMOV(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opMOVSrri() { ARM7addrDPrri(); ARM7opMOV(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opMOVSrrr() { ARM7addrDPrrr(); ARM7opMOV(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opBICSreg() { ARM7addrDPreg(); ARM7opBIC(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opBICSimm() { ARM7addrDPimm(); ARM7opBIC(); ARM7addrDPflagBIT(); return 1; } OPCODE ARM7opBICSlli() { ARM7addrDPlli(); ARM7opBIC(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opBICSllr() { ARM7addrDPllr(); ARM7opBIC(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opBICSlri() { ARM7addrDPlri(); ARM7opBIC(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opBICSlrr() { ARM7addrDPlrr(); ARM7opBIC(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opBICSari() { ARM7addrDPari(); ARM7opBIC(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opBICSarr() { ARM7addrDParr(); ARM7opBIC(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opBICSrri() { ARM7addrDPrri(); ARM7opBIC(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opBICSrrr() { ARM7addrDPrrr(); ARM7opBIC(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opMVNSreg() { ARM7addrDPreg(); ARM7opMVN(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opMVNSimm() { ARM7addrDPimm(); ARM7opMVN(); ARM7addrDPflagBIT(); return 1; } OPCODE ARM7opMVNSlli() { ARM7addrDPlli(); ARM7opMVN(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opMVNSllr() { ARM7addrDPllr(); ARM7opMVN(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opMVNSlri() { ARM7addrDPlri(); ARM7opMVN(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opMVNSlrr() { ARM7addrDPlrr(); ARM7opMVN(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opMVNSari() { ARM7addrDPari(); ARM7opMVN(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opMVNSarr() { ARM7addrDParr(); ARM7opMVN(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opMVNSrri() { ARM7addrDPrri(); ARM7opMVN(); ARM7addrDPflagBIT(); return 2; } OPCODE ARM7opMVNSrrr() { ARM7addrDPrrr(); ARM7opMVN(); ARM7addrDPflagBIT(); return 2; } //---Load/Store addressing modes, opcodes---------------------------------- #define ARM7addrLSofim() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov ebx,edx /* and another */ \ __asm and ebx,00000FFFh /* Mask offset */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm sub eax,ebx /* Subtract offset */ \ } #define ARM7addrLSofip() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov ebx,edx /* and another */ \ __asm and ebx,00000FFFh /* Mask offset */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm add eax,ebx /* Subtract offset */ \ } #define ARM7addrLSlmofim() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov ebx,edx /* and another */ \ __asm mov eax,edx /* yet another */ \ __asm shr eax,4 /* Shift top nybble */ \ __asm and ebx,15 /* Mask low nybble */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm and eax,240 /* Mask high nyb */ \ __asm or ebx,eax /* Add nybbles */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm sub eax,ebx /* Subtract offset */ \ } #define ARM7addrLSlmofip() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov ebx,edx /* and another */ \ __asm mov eax,edx /* yet another */ \ __asm shr eax,4 /* Shift top nybble */ \ __asm and ebx,15 /* Mask low nybble */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm and eax,240 /* Mask high nyb */ \ __asm or ebx,eax /* Add nybbles */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm add eax,ebx /* Add offset */ \ } #define ARM7addrLSofrm() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov eax,edx /* and another */ \ __asm and eax,15 /* Mask Rm off */ \ __asm mov ebx,[arm7reg+eax*4] /* Get Rm's value */ \ __asm mov ecx,edx /* Opcode copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm sub eax,ebx /* val=Rn-(Rm#shft) */ \ } #define ARM7addrLSofrmll() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov eax,edx /* and another */ \ __asm shr ecx,7 /* Shift in shftamnt */ \ __asm and ecx,31 /* And to 31 */ \ __asm and eax,15 /* Mask Rm off */ \ __asm mov ebx,[arm7reg+eax*4] /* Get Rm's value */ \ __asm shl ebx,cl /* Shift Rm */ \ __asm mov ecx,edx /* Opcode copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm sub eax,ebx /* val=Rn-(Rm#shft) */ \ } #define ARM7addrLSofrmlr() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov eax,edx /* and another */ \ __asm and eax,15 /* Mask Rm off */ \ __asm mov ebx,[arm7reg+eax*4] /* Get Rm's value */ \ __asm shr ecx,7 /* Shift in shftamnt */ \ __asm and ecx,31 /* And to 31 */ \ __asm jnz shft1 /* If amnt is 0 */ \ __asm shl ebx,1 /* Set carry */ \ __asm xor ebx,ebx /* Operand=0 */ \ __asm jmp shftend /* and skip over */\ __asm shft1: /* Otherwise.. */ \ __asm shr ebx,cl /* Shift Rm */ \ __asm shftend: /* Good to go */ \ __asm mov ecx,edx /* Opcode copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm sub eax,ebx /* val=Rn-(Rm#shft) */ \ } #define ARM7addrLSofrmar() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov eax,edx /* and another */ \ __asm shr ecx,7 /* Shift in shftamnt */ \ __asm and ecx,31 /* And to 31 */ \ __asm jnz shft1 /* If amnt is 0 */ \ __asm mov ecx,31 /* Set to 32 */ \ __asm shft1: /* Otherwise.. */ \ __asm and eax,15 /* Mask Rm off */ \ __asm mov ebx,[arm7reg+eax*4] /* Get Rm's value */ \ __asm sar ebx,cl /* Shift Rm */ \ __asm mov ecx,edx /* Opcode copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm sub eax,ebx /* val=Rn-(Rm#shft) */ \ } #define ARM7addrLSofrmrr() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov eax,edx /* and another */ \ __asm and eax,15 /* Mask Rm off */ \ __asm mov ebx,[arm7reg+eax*4] /* Get Rm's value */ \ __asm shr ecx,7 /* Shift in shftamnt */ \ __asm and ecx,31 /* And to 31 */ \ __asm jnz shft1 /* If amnt is 0 */ \ __asm mov ecx,[arm7reg+ARMREG_FC*4] /* Read saved carry */ \ __asm shr ecx,1 /* Shift into x86 c */ \ __asm rcr ebx,1 /* 33-bit shift */ \ __asm jmp shftend \ __asm shft1: /* Otherwise.. */ \ __asm ror ebx,cl /* Shift Rm */ \ __asm shftend: \ __asm mov ecx,edx /* Opcode copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm sub eax,ebx /* val=Rn-(Rm#shft) */ \ } #define ARM7addrLSofrp() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov eax,edx /* and another */ \ __asm and eax,15 /* Mask Rm off */ \ __asm mov ebx,[arm7reg+eax*4] /* Get Rm's value */ \ __asm mov ecx,edx /* Opcode copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm add eax,ebx /* val=Rn-(Rm#shft) */ \ } #define ARM7addrLSofrpll() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov eax,edx /* and another */ \ __asm shr ecx,7 /* Shift in shftamnt */ \ __asm and ecx,31 /* And to 31 */ \ __asm and eax,15 /* Mask Rm off */ \ __asm mov ebx,[arm7reg+eax*4] /* Get Rm's value */ \ __asm shl ebx,cl /* Shift Rm */ \ __asm mov ecx,edx /* Opcode copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm add eax,ebx /* val=Rn-(Rm#shft) */ \ } #define ARM7addrLSofrplr() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov eax,edx /* and another */ \ __asm and eax,15 /* Mask Rm off */ \ __asm mov ebx,[arm7reg+eax*4] /* Get Rm's value */ \ __asm shr ecx,7 /* Shift in shftamnt */ \ __asm and ecx,31 /* And to 31 */ \ __asm jnz shft1 /* If amnt is 0 */ \ __asm shl ebx,1 /* Set carry */ \ __asm xor ebx,ebx /* Operand=0 */ \ __asm jmp shftend /* and skip over */\ __asm shft1: /* Otherwise.. */ \ __asm shr ebx,cl /* Shift Rm */ \ __asm shftend: /* Good to go */ \ __asm mov ecx,edx /* Opcode copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm add eax,ebx /* val=Rn-(Rm#shft) */ \ } #define ARM7addrLSofrpar() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov eax,edx /* and another */ \ __asm shr ecx,7 /* Shift in shftamnt */ \ __asm and ecx,31 /* And to 31 */ \ __asm jnz shft1 /* If amnt is 0 */ \ __asm mov ecx,31 /* Set to 32 */ \ __asm shft1: /* Otherwise.. */ \ __asm and eax,15 /* Mask Rm off */ \ __asm mov ebx,[arm7reg+eax*4] /* Get Rm's value */ \ __asm sar ebx,cl /* Shift Rm */ \ __asm mov ecx,edx /* Opcode copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm add eax,ebx /* val=Rn-(Rm#shft) */ \ } #define ARM7addrLSofrprr() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov eax,edx /* and another */ \ __asm and eax,15 /* Mask Rm off */ \ __asm mov ebx,[arm7reg+eax*4] /* Get Rm's value */ \ __asm shr ecx,7 /* Shift in shftamnt */ \ __asm and ecx,31 /* And to 31 */ \ __asm jnz shft1 /* If amnt is 0 */ \ __asm mov ecx,[arm7reg+ARMREG_FC*4] /* Read saved carry */ \ __asm shr ecx,1 /* Shift into x86 c */ \ __asm rcr ebx,1 /* 33-bit shift */ \ __asm jmp shftend /* And skip over this */ \ __asm shft1: /* Otherwise.. */ \ __asm ror ebx,cl /* Shift Rm */ \ __asm shftend: \ __asm mov ecx,edx /* Opcode copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm add eax,ebx /* val=Rn-(Rm#shft) */ \ } #define ARM7addrLSprim() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov ebx,edx /* and another */ \ __asm and ebx,00000FFFh /* Mask offset */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm sub eax,ebx /* Subtract offset */ \ __asm mov [arm7reg+ecx*4],eax /* Write back */ \ } #define ARM7addrLSprip() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov ebx,edx /* and another */ \ __asm and ebx,00000FFFh /* Mask offset */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm add eax,ebx /* Add offset */ \ __asm mov [arm7reg+ecx*4],eax /* Write back */ \ } #define ARM7addrLSlmprim() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov ebx,edx /* and another */ \ __asm mov eax,edx /* yet another */ \ __asm shr eax,4 /* Shift top nybble */ \ __asm and ebx,15 /* Mask low nybble */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm and eax,240 /* Mask high nyb */ \ __asm or ebx,eax /* Add nybbles */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm sub eax,ebx /* Subtract offset */ \ __asm mov [arm7reg+ecx*4],eax /* Write back */ \ } #define ARM7addrLSlmprip() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov ebx,edx /* and another */ \ __asm mov eax,edx /* yet another */ \ __asm shr eax,4 /* Shift top nybble */ \ __asm and ebx,15 /* Mask low nybble */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm and eax,240 /* Mask high nyb */ \ __asm or ebx,eax /* Add nybbles */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm add eax,ebx /* Add offset */ \ __asm mov [arm7reg+ecx*4],eax /* Write back */ \ } #define ARM7addrLSprrm() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov eax,edx /* and another */ \ __asm and eax,15 /* Mask Rm off */ \ __asm mov ebx,[arm7reg+eax*4] /* Get Rm's value */ \ __asm mov ecx,edx /* Opcode copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm sub eax,ebx /* val=Rn-(Rm#shft) */ \ __asm mov [arm7reg+ecx*4],eax /* Write back */ \ } #define ARM7addrLSprrmll() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov eax,edx /* and another */ \ __asm shr ecx,7 /* Shift in shftamnt */ \ __asm and ecx,31 /* And to 31 */ \ __asm and eax,15 /* Mask Rm off */ \ __asm mov ebx,[arm7reg+eax*4] /* Get Rm's value */ \ __asm shl ebx,cl /* Shift Rm */ \ __asm mov ecx,edx /* Opcode copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm sub eax,ebx /* val=Rn-(Rm#shft) */ \ __asm mov [arm7reg+ecx*4],eax /* Write back */ \ } #define ARM7addrLSprrmlr() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov eax,edx /* and another */ \ __asm and eax,15 /* Mask Rm off */ \ __asm mov ebx,[arm7reg+eax*4] /* Get Rm's value */ \ __asm shr ecx,7 /* Shift in shftamnt */ \ __asm and ecx,31 /* And to 31 */ \ __asm jnz shft1 /* If amnt is 0 */ \ __asm shl ebx,1 /* Set carry */ \ __asm xor ebx,ebx /* Operand=0 */ \ __asm jmp shftend /* and skip over */\ __asm shft1: /* Otherwise.. */ \ __asm shr ebx,cl /* Shift Rm */ \ __asm shftend: /* Good to go */ \ __asm mov ecx,edx /* Opcode copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm sub eax,ebx /* val=Rn-(Rm#shft) */ \ __asm mov [arm7reg+ecx*4],eax /* Write back */ \ } #define ARM7addrLSprrmar() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov eax,edx /* and another */ \ __asm shr ecx,7 /* Shift in shftamnt */ \ __asm and ecx,31 /* And to 31 */ \ __asm jnz shft1 /* If amnt is 0 */ \ __asm mov ecx,31 /* Set to 32 */ \ __asm shft1: /* Otherwise.. */ \ __asm and eax,15 /* Mask Rm off */ \ __asm mov ebx,[arm7reg+eax*4] /* Get Rm's value */ \ __asm sar ebx,cl /* Shift Rm */ \ __asm mov ecx,edx /* Opcode copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm sub eax,ebx /* val=Rn-(Rm#shft) */ \ __asm mov [arm7reg+ecx*4],eax /* Write back */ \ } #define ARM7addrLSprrmrr() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov eax,edx /* and another */ \ __asm and eax,15 /* Mask Rm off */ \ __asm mov ebx,[arm7reg+eax*4] /* Get Rm's value */ \ __asm shr ecx,7 /* Shift in shftamnt */ \ __asm and ecx,31 /* And to 31 */ \ __asm jnz shft1 /* If amnt is 0 */ \ __asm mov ecx,[arm7reg+ARMREG_FC*4] /* Read saved carry */ \ __asm shr ecx,1 /* Shift into x86 c */ \ __asm rcr ebx,1 /* 33-bit shift */ \ __asm jmp shftend /* And skip over this */ \ __asm shft1: /* Otherwise.. */ \ __asm ror ebx,cl /* Shift Rm */ \ __asm shftend: \ __asm mov ecx,edx /* Opcode copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm sub eax,ebx /* val=Rn-(Rm#shft) */ \ __asm mov [arm7reg+ecx*4],eax /* Write back */ \ } #define ARM7addrLSprrp() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov eax,edx /* and another */ \ __asm and eax,15 /* Mask Rm off */ \ __asm mov ebx,[arm7reg+eax*4] /* Get Rm's value */ \ __asm mov ecx,edx /* Opcode copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm add eax,ebx /* val=Rn-(Rm#shft) */ \ __asm mov [arm7reg+ecx*4],eax /* Write back */ \ } #define ARM7addrLSprrpll() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov eax,edx /* and another */ \ __asm shr ecx,7 /* Shift in shftamnt */ \ __asm and ecx,31 /* And to 31 */ \ __asm and eax,15 /* Mask Rm off */ \ __asm mov ebx,[arm7reg+eax*4] /* Get Rm's value */ \ __asm shl ebx,cl /* Shift Rm */ \ __asm mov ecx,edx /* Opcode copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm add eax,ebx /* val=Rn-(Rm#shft) */ \ __asm mov [arm7reg+ecx*4],eax /* Write back */ \ } #define ARM7addrLSprrplr() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov eax,edx /* and another */ \ __asm and eax,15 /* Mask Rm off */ \ __asm mov ebx,[arm7reg+eax*4] /* Get Rm's value */ \ __asm shr ecx,7 /* Shift in shftamnt */ \ __asm and ecx,31 /* And to 31 */ \ __asm jnz shft1 /* If amnt is 0 */ \ __asm shl ebx,1 /* Set carry */ \ __asm xor ebx,ebx /* Operand=0 */ \ __asm jmp shftend /* and skip over */\ __asm shft1: /* Otherwise.. */ \ __asm shr ebx,cl /* Shift Rm */ \ __asm shftend: /* Good to go */ \ __asm mov ecx,edx /* Opcode copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm add eax,ebx /* val=Rn-(Rm#shft) */ \ __asm mov [arm7reg+ecx*4],eax /* Write back */ \ } #define ARM7addrLSprrpar() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov eax,edx /* and another */ \ __asm shr ecx,7 /* Shift in shftamnt */ \ __asm and ecx,31 /* And to 31 */ \ __asm jnz shft1 /* If amnt is 0 */ \ __asm mov ecx,31 /* Set to 32 */ \ __asm shft1: /* Otherwise.. */ \ __asm and eax,15 /* Mask Rm off */ \ __asm mov ebx,[arm7reg+eax*4] /* Get Rm's value */ \ __asm sar ebx,cl /* Shift Rm */ \ __asm mov ecx,edx /* Opcode copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm add eax,ebx /* val=Rn-(Rm#shft) */ \ __asm mov [arm7reg+ecx*4],eax /* Write back */ \ } #define ARM7addrLSprrprr() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov eax,edx /* and another */ \ __asm and eax,15 /* Mask Rm off */ \ __asm mov ebx,[arm7reg+eax*4] /* Get Rm's value */ \ __asm shr ecx,7 /* Shift in shftamnt */ \ __asm and ecx,31 /* And to 31 */ \ __asm jnz shft1 /* If amnt is 0 */ \ __asm mov ecx,[arm7reg+ARMREG_FC*4] /* Read saved carry */ \ __asm shr ecx,1 /* Shift into x86 c */ \ __asm rcr ebx,1 /* 33-bit shift */ \ __asm jmp shftend /* And skip over this */ \ __asm shft1: /* Otherwise.. */ \ __asm ror ebx,cl /* Shift Rm */ \ __asm shftend: \ __asm mov ecx,edx /* Opcode copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm add eax,ebx /* val=Rn-(Rm#shft) */ \ __asm mov [arm7reg+ecx*4],eax /* Write back */ \ } #define ARM7addrLSptim() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov ebx,edx /* and another */ \ __asm and ebx,00000FFFh /* Mask offset */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm sub [arm7reg+ecx*4],ebx /* Don't touch eax */ \ } #define ARM7addrLSptip() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov ebx,edx /* and another */ \ __asm and ebx,00000FFFh /* Mask offset */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm add [arm7reg+ecx*4],ebx /* Don't touch eax */ \ } #define ARM7addrLSlmptim() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov ebx,edx /* and another */ \ __asm mov eax,edx /* yet another */ \ __asm shr eax,4 /* Shift top nybble */ \ __asm and ebx,15 /* Mask low nybble */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm and eax,240 /* Mask high nyb */ \ __asm or ebx,eax /* Add nybbles */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm sub [arm7reg+ecx*4],ebx /* Write back */ \ } #define ARM7addrLSlmptip() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov ebx,edx /* and another */ \ __asm mov eax,edx /* yet another */ \ __asm shr eax,4 /* Shift top nybble */ \ __asm and ebx,15 /* Mask low nybble */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm and eax,240 /* Mask high nyb */ \ __asm or ebx,eax /* Add nybbles */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm add [arm7reg+ecx*4],ebx /* Write back */ \ } #define ARM7addrLSptrm() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov eax,edx /* and another */ \ __asm and eax,15 /* Mask Rm off */ \ __asm mov ebx,[arm7reg+eax*4] /* Get Rm's value */ \ __asm mov ecx,edx /* Opcode copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm sub [arm7reg+ecx*4],ebx /* Write back */ \ } #define ARM7addrLSptrmll() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov eax,edx /* and another */ \ __asm shr ecx,7 /* Shift in shftamnt */ \ __asm and ecx,31 /* And to 31 */ \ __asm and eax,15 /* Mask Rm off */ \ __asm mov ebx,[arm7reg+eax*4] /* Get Rm's value */ \ __asm shl ebx,cl /* Shift Rm */ \ __asm mov ecx,edx /* Opcode copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm sub [arm7reg+ecx*4],ebx /* Write back */ \ } #define ARM7addrLSptrmlr() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov eax,edx /* and another */ \ __asm and eax,15 /* Mask Rm off */ \ __asm mov ebx,[arm7reg+eax*4] /* Get Rm's value */ \ __asm shr ecx,7 /* Shift in shftamnt */ \ __asm and ecx,31 /* And to 31 */ \ __asm jnz shft1 /* If amnt is 0 */ \ __asm shl ebx,1 /* Set carry */ \ __asm xor ebx,ebx /* Operand=0 */ \ __asm jmp shftend /* and skip over */\ __asm shft1: /* Otherwise.. */ \ __asm shr ebx,cl /* Shift Rm */ \ __asm shftend: /* Good to go */ \ __asm mov ecx,edx /* Opcode copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm sub [arm7reg+ecx*4],ebx /* Write back */ \ } #define ARM7addrLSptrmar() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov eax,edx /* and another */ \ __asm shr ecx,7 /* Shift in shftamnt */ \ __asm and ecx,31 /* And to 31 */ \ __asm jnz shft1 /* If amnt is 0 */ \ __asm mov ecx,31 /* Set to 32 */ \ __asm shft1: /* Otherwise.. */ \ __asm and eax,15 /* Mask Rm off */ \ __asm mov ebx,[arm7reg+eax*4] /* Get Rm's value */ \ __asm sar ebx,cl /* Shift Rm */ \ __asm mov ecx,edx /* Opcode copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm sub [arm7reg+ecx*4],ebx /* Write back */ \ } #define ARM7addrLSptrmrr() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov eax,edx /* and another */ \ __asm and eax,15 /* Mask Rm off */ \ __asm mov ebx,[arm7reg+eax*4] /* Get Rm's value */ \ __asm shr ecx,7 /* Shift in shftamnt */ \ __asm and ecx,31 /* And to 31 */ \ __asm jnz shft1 /* If amnt is 0 */ \ __asm mov ecx,[arm7reg+ARMREG_FC*4] /* Read saved carry */ \ __asm shr ecx,1 /* Shift into x86 c */ \ __asm rcr ebx,1 /* 33-bit shift */ \ __asm jmp shftend /* And skip over this */ \ __asm shft1: /* Otherwise.. */ \ __asm ror ebx,cl /* Shift Rm */ \ __asm shftend: \ __asm mov ecx,edx /* Opcode copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm sub [arm7reg+ecx*4],ebx /* Write back */ \ } #define ARM7addrLSptrp() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov eax,edx /* and another */ \ __asm and eax,15 /* Mask Rm off */ \ __asm mov ebx,[arm7reg+eax*4] /* Get Rm's value */ \ __asm mov ecx,edx /* Opcode copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm add [arm7reg+ecx*4],ebx /* Write back */ \ } #define ARM7addrLSptrpll() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov eax,edx /* and another */ \ __asm shr ecx,7 /* Shift in shftamnt */ \ __asm and ecx,31 /* And to 31 */ \ __asm and eax,15 /* Mask Rm off */ \ __asm mov ebx,[arm7reg+eax*4] /* Get Rm's value */ \ __asm shl ebx,cl /* Shift Rm */ \ __asm mov ecx,edx /* Opcode copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm add [arm7reg+ecx*4],ebx /* Write back */ \ } #define ARM7addrLSptrplr() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov eax,edx /* and another */ \ __asm and eax,15 /* Mask Rm off */ \ __asm mov ebx,[arm7reg+eax*4] /* Get Rm's value */ \ __asm shr ecx,7 /* Shift in shftamnt */ \ __asm and ecx,31 /* And to 31 */ \ __asm jnz shft1 /* If amnt is 0 */ \ __asm shl ebx,1 /* Set carry */ \ __asm xor ebx,ebx /* Operand=0 */ \ __asm jmp shftend /* and skip over */\ __asm shft1: /* Otherwise.. */ \ __asm shr ebx,cl /* Shift Rm */ \ __asm shftend: /* Good to go */ \ __asm mov ecx,edx /* Opcode copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm add [arm7reg+ecx*4],ebx /* Write back */ \ } #define ARM7addrLSptrpar() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov eax,edx /* and another */ \ __asm shr ecx,7 /* Shift in shftamnt */ \ __asm and ecx,31 /* And to 31 */ \ __asm jnz shft1 /* If amnt is 0 */ \ __asm mov ecx,31 /* Set to 32 */ \ __asm shft1: /* Otherwise.. */ \ __asm and eax,15 /* Mask Rm off */ \ __asm mov ebx,[arm7reg+eax*4] /* Get Rm's value */ \ __asm sar ebx,cl /* Shift Rm */ \ __asm mov ecx,edx /* Opcode copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm add [arm7reg+ecx*4],ebx /* Write back */ \ } #define ARM7addrLSptrprr() \ __asm { \ __asm mov edx,[arm7reg+ARMREG_OP*4] /* Read opcode */ \ __asm mov ecx,edx /* Make a copy */ \ __asm mov eax,edx /* and another */ \ __asm and eax,15 /* Mask Rm off */ \ __asm mov ebx,[arm7reg+eax*4] /* Get Rm's value */ \ __asm shr ecx,7 /* Shift in shftamnt */ \ __asm and ecx,31 /* And to 31 */ \ __asm jnz shft1 /* If amnt is 0 */ \ __asm mov ecx,[arm7reg+ARMREG_FC*4] /* Read saved carry */ \ __asm shr ecx,1 /* Shift into x86 c */ \ __asm rcr ebx,1 /* 33-bit shift */ \ __asm jmp shftend /* And skip over this */ \ __asm shft1: /* Otherwise.. */ \ __asm ror ebx,cl /* Shift Rm */ \ __asm shftend: \ __asm mov ecx,edx /* Opcode copy */ \ __asm shr ecx,16 /* Shift in Rn */ \ __asm and ecx,15 /* Mask it off */ \ __asm mov eax,[arm7reg+ecx*4] /* Get Rn's value */ \ __asm cmp ecx,15 /* Is Rn 15? */ \ __asm jl pt1 /* If so.. */ \ __asm add eax,4 /* Hack value+4 */ \ __asm pt1: /* Otherwise skip */ \ __asm add [arm7reg+ecx*4],ebx /* Write back */ \ } #define ARM7opLDR() \ __asm { \ __asm shr edx,12 /* Shift in Rd */ \ __asm and edx,15 /* Mask to 15 */ \ __asm cmp edx,15 /* Is Rd 15? */ \ __asm jl ldr1 /* If not, skip */ \ __asm and eax,0FFFFFFFCh /* Discount low 2 bits */ \ __asm ldr1: /* Otherwise.. */ \ __asm push edx /* Save Rd */ \ __asm push eax /* Address */ \ __asm xor ecx,ecx /* Bus = 0 */ \ __asm push ecx /* Push "bus number" */ \ __asm call MMUrdW /* Read a word */ \ __asm pop ecx /* Clear stack */ \ __asm pop ecx /* of params */ \ __asm pop edx /* Get Rd back */\ __asm mov [arm7reg+edx*4],eax /* Write value to Rd */ \ __asm mov eax,3 \ } #define ARM7opLDRH() \ __asm { \ __asm push edx /* Save opcode */ \ __asm push eax /* Push address */ \ __asm xor ecx,ecx /* Bus = 0 */ \ __asm push ecx /* Push "bus number" */ \ __asm call MMUrdH /* Read a hword */ \ __asm pop ecx /* Pop param1 */ \ __asm pop ecx /* Pop param2 */ \ __asm pop edx /* Get opcode back */ \ __asm shr edx,12 /* Shift in Rd */ \ __asm and edx,15 /* Mask to 15 */ \ __asm movzx ebx,ax /* Extend to 32b */ \ __asm mov [arm7reg+edx*4],ebx /* and write */ \ __asm mov eax,3 \ } #define ARM7opLDRB() \ __asm { \ __asm push edx /* Save opcode */ \ __asm push eax /* Push address */ \ __asm xor ecx,ecx /* Bus = 0 */ \ __asm push ecx /* Push "bus number" */ \ __asm call MMUrdB /* Read a byte */ \ __asm pop ecx /* Pop param1 */ \ __asm pop ecx /* Pop param2 */ \ __asm pop edx /* Get opcode back */ \ __asm shr edx,12 /* Shift in Rd */ \ __asm and edx,15 /* Mask to 15 */ \ __asm movzx ebx,al /* Extend to 32b */ \ __asm mov [arm7reg+edx*4],ebx /* and write */ \ __asm mov eax,3 \ } #define ARM7opLDRSH() \ __asm { \ __asm push edx /* Save opcode */ \ __asm push eax /* Push address */ \ __asm xor ecx,ecx /* Bus = 0 */ \ __asm push ecx /* Push "bus number" */ \ __asm call MMUrdH /* Read a byte */ \ __asm pop ecx /* Pop param1 */ \ __asm pop ecx /* Pop param2 */ \ __asm pop edx /* Get opcode back */ \ __asm shr edx,12 /* Shift in Rd */ \ __asm and edx,15 /* Mask to 15 */ \ __asm movsx ebx,ax /* Extend to 32b */ \ __asm mov [arm7reg+edx*4],ebx /* and write */ \ __asm mov eax,3 \ } #define ARM7opLDRSB() \ __asm { \ __asm push edx /* Save opcode */ \ __asm push eax /* Push address */ \ __asm xor ecx,ecx /* Bus = 0 */ \ __asm push ecx /* Push "bus number" */ \ __asm call MMUrdB /* Read a byte */ \ __asm pop ecx /* Pop param1 */ \ __asm pop ecx /* Pop param2 */ \ __asm pop edx /* Get opcode back */ \ __asm shr edx,12 /* Shift in Rd */ \ __asm and edx,15 /* Mask to 15 */ \ __asm movsx ebx,al /* Extend to 32b */ \ __asm mov [arm7reg+edx*4],ebx /* and write */ \ __asm mov eax,3 \ } #define ARM7opLDRT() \ __asm { \ __asm mov ecx,eax /* Make copy of addr */ \ __asm and ecx,3 /* Get low 2 bits */ \ __asm shl ecx,3 /* Multiples of 8 */ \ __asm ror eax,cl /* Rotate addr */ \ __asm shr edx,12 /* Shift in Rd */ \ __asm and edx,15 /* Mask to 15 */ \ __asm push edx /* Save Rd */ \ __asm push eax /* Address */ \ __asm xor ecx,ecx /* Bus = 0 */ \ __asm push ecx /* Push "bus number" */ \ __asm call MMUrdW /* Read a word */ \ __asm pop ecx /* Clear stack */ \ __asm pop ecx /* of params */ \ __asm pop edx /* Get Rd back */\ /*__asm mov ecx,[arm7reg+ARMREG_MODE*4] \ __asm cmp ecx,ARMMD_SYS // Set flags on mode \ __asm jle usrmode // If USR or SYS, skip \ __asm mov [arm7reg+ARMREG_USER*4+edx*4],eax \ __asm jmp modedone // Read usr-reg, end \ __asm usrmode: // Skip here if USR \ __asm mov [arm7reg+edx*4],eax // Read normal reg \ __asm modedone: // Done */ \ __asm mov [arm7reg+edx*4],eax \ __asm mov eax,3 \ } #define ARM7opLDRBT() \ __asm { \ __asm shr edx,12 /* Shift in Rd */ \ __asm and edx,15 /* Mask to 15 */ \ __asm push edx /* Save Rd */ \ __asm push eax /* Address */ \ __asm xor ecx,ecx /* Bus = 0 */ \ __asm push ecx /* Push "bus number" */ \ __asm call MMUrdB /* Read a word */ \ __asm pop ecx /* Clear stack */ \ __asm pop ecx /* of params */ \ __asm pop edx /* Get Rd back */\ __asm movzx ebx,al /* Extend to 32b */ \ __asm mov ecx,[arm7reg+ARMREG_MODE*4] \ __asm cmp ecx,ARMMD_SYS /* Set flags on mode */ \ __asm jle usrmode /* If USR or SYS, skip */ \ __asm mov [arm7reg+ARMREG_USER*4+edx*4],ebx \ __asm jmp modedone /* Read usr-reg, end */ \ __asm usrmode: /* Skip here if USR */ \ __asm mov [arm7reg+edx*4],ebx /* Read normal reg */ \ __asm modedone: /* Done */ \ __asm mov eax,3 \ } #define ARM7opSTR() \ __asm { \ __asm shr edx,12 /* Shift in Rd */ \ __asm and edx,15 /* Mask to 15 */ \ __asm mov ebx,[arm7reg+edx*4] /* Get Rd value */ \ __asm push ebx /* Push Rd */ \ __asm push eax /* Push address */ \ __asm xor ecx,ecx /* Bus = 0 */ \ __asm push ecx /* Push "bus number" */ \ __asm call MMUwrW /* Write thru MMU */ \ __asm pop eax /* Clear stack */ \ __asm pop eax /* of pushed */ \ __asm pop eax /* parameters */ \ __asm mov eax,2 \ } #define ARM7opSTRH() \ __asm { \ __asm shr edx,12 /* Shift in Rd */ \ __asm and edx,15 /* Mask to 15 */ \ __asm mov ebx,[arm7reg+edx*4] /* Get Rd value */ \ __asm and ebx,0000FFFFh /* Mask low hword */ \ __asm push ebx /* Push Rd */ \ __asm push eax /* Push address */ \ __asm xor ecx,ecx /* Bus = 0 */ \ __asm push ecx /* Push "bus number" */ \ __asm call MMUwrH /* Write thru MMU */ \ __asm pop eax /* Clear stack */ \ __asm pop eax /* of pushed */ \ __asm pop eax /* parameters */ \ __asm mov eax,2 \ } #define ARM7opSTRB() \ __asm { \ __asm shr edx,12 /* Shift in Rd */ \ __asm and edx,15 /* Mask to 15 */ \ __asm mov ebx,[arm7reg+edx*4] /* Get Rd value */ \ __asm and ebx,000000FFh /* Mask low byte */ \ __asm push ebx /* Push Rd */ \ __asm push eax /* Push address */ \ __asm xor ecx,ecx /* Bus = 0 */ \ __asm push ecx /* Push "bus number" */ \