cpu.cpp

DVB-S的softcam源代码

			case 0xB3:
			case 0xC3:
			case 0xD3:
			case 0xE3:
			case 0xF3:
				sub(*ex,op,0); break;
			case 0xA4: // AND
			case 0xB4:
			case 0xC4:
			case 0xD4:
			case 0xE4:
			case 0xF4:
				a &= op; tst(a); break;
			case 0xAA: // ORA
			case 0xBA:
			case 0xCA:
			case 0xDA:
			case 0xEA:
			case 0xFA:
				a |= op; tst(a); break;
			case 0xA8: // EOR
			case 0xB8:
			case 0xC8:
			case 0xD8:
			case 0xE8:
			case 0xF8:
				a ^= op; tst(a); break;
			case 0xA5: // BIT
			case 0xB5:
			case 0xC5:
			case 0xD5:
			case 0xE5:
			case 0xF5:
				tst(a & op); break;
			case 0x38: // ASL
			case 0x48:
			case 0x58:
			case 0x68:
			case 0x78:
				op=rollL(op,0); break;
			case 0x39: // ROL
			case 0x49:
			case 0x59:
			case 0x69:
			case 0x79:
				op=rollL(op,cc.c); break;
			case 0x37: // ASR
			case 0x47:
			case 0x57:
			case 0x67:
			case 0x77:
				op=rollR(op,bitset(op,7)); break;
			case 0x34: // LSR
			case 0x44:
			case 0x54:
			case 0x64:
			case 0x74:
				op=rollR(op,0); break;
			case 0x36: // ROR
			case 0x46:
			case 0x56:
			case 0x66:
			case 0x76:
				op=rollR(op,cc.c); break;
			case 0x3E: // SWAP (ST7)
			case 0x4E:
			case 0x5E:
			case 0x6E:
			case 0x7E:
				op=(op<<4)|(op>>4); tst(op); break;
	  case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: case 0x06: case 0x07: case 0x08: case 0x09: case 0x0A: case 0x0B: case 0x0C: case 0x0D: case 0x0E: case 0x0F: // BRSET BRCLR
				{
				int bit=(ins&0x0F)>>1;
				sprintf(txt,",#%x,",bit); strcat(displaystr2, txt);
				if (pc80flag && Show_Diss==1) printf(txt);
				cc.c=bitset(op,bit);
				branch((ins&0x01) ? !cc.c:cc.c);
				break;
				}
	  case 0x10: case 0x11: case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17: case 0x18: case 0x19: case 0x1A: case 0x1B: case 0x1C: case 0x1D: case 0x1E: case 0x1F: // BSET BCLR
				{
				int bit=(ins&0x0F)>>1;
				sprintf(txt,",#%x",bit); strcat(displaystr2, txt);
				if (pc80flag && Show_Diss==1) printf(txt);
				if(ins&0x01) op &= ~(1<<bit);
				else         op |=  (1<<bit);
				break;
				}
			case 0x20: // BRA
				branch(true); break;
			case 0x21: // BRN
				branch(false); break;
			case 0x22: // BHI
				if(vbra) branch(!cc.z && ((cc.n && cc.v) || (!cc.n && !cc.v)));
				else branch(!cc.c && !cc.z);
				break;
			case 0x23: // BLS
				if(vbra) branch(cc.z || (cc.n && !cc.v) || (!cc.n && cc.v));
				else branch( cc.c ||  cc.z);
				break;
			case 0x24: // BCC BHS
				if(vbra) branch((cc.n && cc.v) || (!cc.n && !cc.v));
				else branch(!cc.c);
				break;
			case 0x25: // BCS BLO
				if(vbra) branch((cc.n && !cc.v) || (!cc.n && cc.v));
				else branch( cc.c);
				break;
			case 0x26: // BNE
				if(vbra) branch(!cc.v);
				else branch(!cc.z);
				break;
			case 0x27: // BEQ
				if(vbra) branch(cc.v);
				else branch( cc.z); break;
			case 0x28: // BHCC
				branch(!cc.h); break;
			case 0x29: // BHCS
				branch( cc.h); break;
			case 0x2A: // BPL
				branch(!cc.n); break;
			case 0x2B: // BMI
				branch( cc.n); break;
			case 0x2C: // BMC
				branch(!cc.i); break;
			case 0x2D: // BMS
				branch( cc.i); break;
			case 0xBC: // JMP
			case 0xCC:
			case 0xDC:
			case 0xEC:
			case 0xFC:
				pc=ea; break;
			case 0xAD: // BSR
				pc++; pushpc(); pc--; branch(true); break;
			case 0xBD: // JSR
			case 0xCD:
			case 0xDD:
			case 0xED:
			case 0xFD:
				pushpc(); pc=ea; break;
			case 0x81: // RTS
				poppc(); break;
			case 0x83: // SWI
				pushpc(); push(x); push(a); pushc();
				cc.i=1; pc=HILO(0x1ffc); break;
			case 0x80: // RTI
				popc(); a=pop(); x=pop(); poppc(); break;
			case 0x9C: // RSP
				sp=spHi; break;
			case 0x96: // TSX
				*ex=sp; break;
			case 0x94: // TXS (ST7)
				sp=*ex; break;
			case 0x9E: // TSA
				a=sp; break;
			case 0x95: // TAS (ST7)
				sp=a; break;
			case 0x84: // POPA (ST7)
				a=pop(); break;
			case 0x85: // POPX (ST7)
				*ex=pop(); break;
			case 0x86: // POPC (ST7)
				popc(); break;
			case 0x88: // PUSHA (ST7)
				push(a); break;
			case 0x89: // PUSHX (ST7)
				push(*ex); break;
			case 0x8A: // PUSHC (ST7)
				pushc(); break;
			case 0x98: // CLC
				cc.c=0; break;
			case 0x99: // SEC
				cc.c=1; break;
			case 0x9A: // CLI
				cc.i=0; break;
			case 0x9B: // SEI
				cc.i=1; break;
			case 0x9D: // NOP
				break;

			case 0x71: // LDD (ST19)
			case 0x72:
			case 0x75:
				dr=op; break;
			case 0x7B: // TAD (ST19)
				dr=a; break;
			case 0x8B: // TDA (ST19)
				a=dr; break;
			case 0x8C: // TCA (ST19)
				a=cr; break;
			case 0xAC: // PUSHD (ST19)
				push(dr); break;
			case 0xAF: // POPD (ST19)
				dr=pop(); break;
			case 0x87: // PRTS (ST19)
				cr=pop(); poppc(); break;
			case 0x8D: // PJSR (ST19)
				if (paged) {
					ea=HILO(pc); pc+=2;
					sprintf(txt,"[%s] -> ",PADDR(cr,ea)); strcat(displaystr2, txt);
					if (pc80flag && Show_Diss==1) printf(txt);
				} else {
					ea=pc; pc+=3;
				}
				sprintf(txt,"%s ",PADDR(pr,ea)); strcat(displaystr2, txt);
				if (pc80flag && Show_Diss==1) printf(txt);
				pr=Get(ea++);
				ea=HILO(ea);
				pushpc(); push(cr); cr=pr; pc=ea; 
				break;

			case 0x90: // pre-bytes
			case 0x91:
			case 0x92:
			case 0x31:
			case 0x32:
				printf("*** pre-byte %02x in command decoding (count=%d)\n",ins,LoopCount);
				return 3;
			default:
				printf("*** unsupported instruction 0x%02x (count=%d)\n",ins,LoopCount);
				return 3;
		}

		// write operant
		if(flags & 2) {
			switch(((flags&8) ? flags:ins)>>4) {
				case 0x2: // no or special address mode
				case 0x8:
				case 0x9:
					break;
				case 0xA: // immediate
				case 0x3: // short
				case 0xB:
				case 0xC: // long
				case 0xD: // long indexed
				case 0x6: // short indexed
				case 0xE:
				case 0x7: // indexed
				case 0xF:
				case 0x0: // bit
				case 0x1:
					if (ea==0x16) op = op & 0x7F; // This is new
					Set(ea,op); break;
				case 0x4: // inherent A
					a=op; break;
				case 0x5: // inherent X/Y
					*ex=op; break;
			}
		} 

		for (int i=numBp-1 ; i>=0 ; i--) {
			if (bp[i] == pc) {
				       if (bp[i]==0x9569 && Show_Diss==0 ) {
				//	printf("*** %s {next EMM_CMD}\n\n", displaystr2);
				} else if (bp[i]==0x9569 && Show_Diss==1 ) {
					printf(" {next EMM_CMD}\n\n");
				} else if (bp[i]==0x9569 && Show_Diss==2 ) {
					printf("%-18s ;%s {next EMM_CMD}\n\n", displaystr1, displaystr2);
				} else {
					printf("*** Breakpoint at: %04x (count=%d)\n\n",pc,LoopCount);
				}
				return 0;
			}
		}
		if (pc80flag && Show_Diss==1) printf("\n");

		if (LoopCount >= max_count) {
			printf("*** Max. instruction counter exceeded (count=%d)\n",LoopCount);
			return 2;
		}
		if (Show_Diss==2) printf("%-18s ;%s\n", displaystr1, displaystr2);
	}
}

void c6805::branch(bool branch)
{
	if (pc80flag) {
		unsigned char off=Get(pc);
		if (indirect) {
			sprintf(txt,"[%02x] -> ",off); strcat(displaystr2, txt);
			if (pc80flag && Show_Diss==1) printf(txt);
			off=Get(off);
		}
		unsigned short npc=pc+off+1;
		if (off&0x80) npc-=0x100; // gcc fixup. take care of sign
		sprintf(txt,"%s ",PADDR(cr,npc)); strcat(displaystr2, txt);
		if (pc80flag && Show_Diss==1) printf(txt);
		if (branch) {
			sprintf(txt,"(taken) "); strcat(displaystr2, txt);
			if (pc80flag && Show_Diss==1) printf(txt);
		}
	}
	pc++;
	if(branch) {
		unsigned char offset=Get(pc-1);
		if(indirect) offset=Get(offset);
		pc+=offset;
		if(offset&0x80) pc-=0x100; // gcc fixup. take care of sign
		}
}

void c6805::push(unsigned char c)
{
	Set(sp--,c);
}

unsigned char c6805::pop(void)
{
	return Get(++sp);
}

void c6805::pushpc(void)
{
	push(pc & 0xff);
	push(pc >> 8);
}

void c6805::poppc(void)
{
	pc=(pop()<<8) | pop();
}

void c6805::pushc(void)
{
	unsigned char c=0xC0+(cc.v?32:0)+(cc.h?16:0)+(cc.i?8:0)+(cc.n?4:0)+(cc.z?2:0)+(cc.c?1:0);
	push(c);
}

void c6805::popc(void)
{
	unsigned char c=pop();
	cc.v=(c&32) ? 1:0;
	cc.h=(c&16) ? 1:0;
	cc.i=(c& 8) ? 1:0;
	cc.n=(c& 4) ? 1:0;
	cc.z=(c& 2) ? 1:0;
	cc.c=(c& 1) ? 1:0;
}

void c6805::tst(unsigned char c)
{
	cc.z=!c;
	cc.n=bitset(c,7);
}

unsigned char c6805::add(unsigned char op, unsigned char c)
{
	unsigned short res_half=(a&0x0f) + (op&0x0f) + c;
	unsigned short res=(unsigned short)a + (unsigned short)op + (unsigned short)c;
	cc.h=res_half > 0x0f;
	cc.c=res > 0xff;
	res&=0xff;
	tst(res);
	return res;
}

unsigned char c6805::sub(unsigned char op1, unsigned char op2, unsigned char c)
{
	short res=(short)op1 - (short)op2 - (short)c;
	cc.c=res < 0;
	res&=0xff;
	tst(res);
	return res;
}

unsigned char c6805::rollR(unsigned char op, unsigned char c)
{
	cc.c=bitset(op,0);
	op >>= 1;
	op |= c << 7;
	tst(op);
	return op;
}

unsigned char c6805::rollL(unsigned char op, unsigned char c)
{
	cc.c=bitset(op,7);
	op <<= 1;
	op |= c;
	tst(op);
	return op;
}