readcpu.c

又一个游戏模拟器,著名ARC模拟器源码,包括多个平台

							continue;
						if (CPU_EMU_SIZE < 2 &&
							(srcmode == Areg || srcmode == Dreg || srcmode == Aind
							|| srcmode == Ad16 || srcmode == Ad8r || srcmode == Aipi
							|| srcmode == Apdi))
						{
							srcgather = 1; srcpos = bitpos[bitD];
						}
						if (opcstr[pos] == '[') {
							pos++;
							if (opcstr[pos] == '!') {
								/* exclusion */
								do {
									pos++;
									if (mode_from_str(opcstr+pos) == srcmode)
										goto nomatch;
									pos += 4;
								} while (opcstr[pos] == ',');
								pos++;
							} else {
								if (opcstr[pos+4] == '-') {
									/* replacement */
									if (mode_from_str(opcstr+pos) == srcmode)
										srcmode = mode_from_str(opcstr+pos+5);
									else
										goto nomatch;
									pos += 10;
								} else {
									/* normal */
									while(mode_from_str(opcstr+pos) != srcmode) {
										pos += 4;
										if (opcstr[pos] == ']')
											goto nomatch;
										pos++;
									}
									while(opcstr[pos] != ']') pos++;
									pos++;
									break;
								}
							}
						}
						/* Some addressing modes are invalid as destination */
						if (srcmode == imm || srcmode == PC16 || srcmode == PC8r)
							goto nomatch;
						break;
					case 's':
						srcreg = bitval[bitS];
						srcmode = mode_from_mr(bitval[bits],bitval[bitS]);
						
						if (srcmode == am_illg)
							continue;
						if (CPU_EMU_SIZE < 2 &&
							(srcmode == Areg || srcmode == Dreg || srcmode == Aind
							|| srcmode == Ad16 || srcmode == Ad8r || srcmode == Aipi
							|| srcmode == Apdi))
						{
							srcgather = 1; srcpos = bitpos[bitS];
						}
						if (opcstr[pos] == '[') {
							pos++;
							if (opcstr[pos] == '!') {
								/* exclusion */
								do {
									pos++;
									if (mode_from_str(opcstr+pos) == srcmode)
										goto nomatch;
									pos += 4;
								} while (opcstr[pos] == ',');
								pos++;
							} else {
								if (opcstr[pos+4] == '-') {
									/* replacement */
									if (mode_from_str(opcstr+pos) == srcmode)
										srcmode = mode_from_str(opcstr+pos+5);
									else
										goto nomatch;
									pos += 10;
								} else {
									/* normal */
									while(mode_from_str(opcstr+pos) != srcmode) {
										pos += 4;
										if (opcstr[pos] == ']')
											goto nomatch;
										pos++;
									}
									while(opcstr[pos] != ']') pos++;
									pos++;
								}
							}
						}
						break;
					default: u020_abort();
	}
	/* safety check - might have changed */
	if (srcmode != Areg && srcmode != Dreg && srcmode != Aind
		&& srcmode != Ad16 && srcmode != Ad8r && srcmode != Aipi
		&& srcmode != Apdi && srcmode != immi)
	{
		srcgather = 0;
	}
	if (srcmode == Areg && sz == sz_byte)
		goto nomatch;
	
	if (opcstr[pos] != ',')
		goto endofline;
	pos++;
	
	/* parse the destination address */
	usedst = 1;
	switch (opcstr[pos++]) {
	case 'D':
		destmode = Dreg;
		switch (opcstr[pos++]) {
		case 'r': destreg = bitval[bitr]; dstgather = 1; dstpos = bitpos[bitr]; break;
		case 'R': destreg = bitval[bitR]; dstgather = 1; dstpos = bitpos[bitR]; break;
		default: u020_abort();
		}
		break;
		case 'A':
			destmode = Areg;
			switch (opcstr[pos++]) {
			case 'r': destreg = bitval[bitr]; dstgather = 1; dstpos = bitpos[bitr]; break;
			case 'R': destreg = bitval[bitR]; dstgather = 1; dstpos = bitpos[bitR]; break;
			default: u020_abort();
			}
			switch (opcstr[pos]) {
			case 'p': destmode = Apdi; pos++; break;
			case 'P': destmode = Aipi; pos++; break;
			}
			break;
			case '#':
				switch (opcstr[pos++]) {
				case 'z': destmode = imm; break;
				case '0': destmode = imm0; break;
				case '1': destmode = imm1; break;
				case '2': destmode = imm2; break;
				case 'i': destmode = immi; destreg = (INT32)(INT8)bitval[biti]; break;
				case 'j': destmode = immi; destreg = bitval[bitj]; break;
				case 'J': destmode = immi; destreg = bitval[bitJ]; break;
				case 'k': destmode = immi; destreg = bitval[bitk]; break;
				case 'K': destmode = immi; destreg = bitval[bitK]; break;
				default: u020_abort();
				}
				break;
				case 'd':
					destreg = bitval[bitD];
					destmode = mode_from_mr(bitval[bitd],bitval[bitD]);
					if (destmode == am_illg)
						continue;
					if (CPU_EMU_SIZE < 1 &&
						(destmode == Areg || destmode == Dreg || destmode == Aind
						|| destmode == Ad16 || destmode == Ad8r || destmode == Aipi
						|| destmode == Apdi))
					{
						dstgather = 1; dstpos = bitpos[bitD];
					}
					
					if (opcstr[pos] == '[') {
						pos++;
						if (opcstr[pos] == '!') {
							/* exclusion */
							do {
								pos++;
								if (mode_from_str(opcstr+pos) == destmode)
									goto nomatch;
								pos += 4;
							} while (opcstr[pos] == ',');
							pos++;
						} else {
							if (opcstr[pos+4] == '-') {
								/* replacement */
								if (mode_from_str(opcstr+pos) == destmode)
									destmode = mode_from_str(opcstr+pos+5);
								else
									goto nomatch;
								pos += 10;
							} else {
								/* normal */
								while(mode_from_str(opcstr+pos) != destmode) {
									pos += 4;
									if (opcstr[pos] == ']')
										goto nomatch;
									pos++;
								}
								while(opcstr[pos] != ']') pos++;
								pos++;
								break;
							}
						}
					}
					/* Some addressing modes are invalid as destination */
					if (destmode == imm || destmode == PC16 || destmode == PC8r)
						goto nomatch;
					break;
				case 's':
					destreg = bitval[bitS];
					destmode = mode_from_mr(bitval[bits],bitval[bitS]);
					
					if (destmode == am_illg)
						continue;
					if (CPU_EMU_SIZE < 1 &&
						(destmode == Areg || destmode == Dreg || destmode == Aind
						|| destmode == Ad16 || destmode == Ad8r || destmode == Aipi
						|| destmode == Apdi))
					{
						dstgather = 1; dstpos = bitpos[bitS];
					}
					
					if (opcstr[pos] == '[') {
						pos++;
						if (opcstr[pos] == '!') {
							/* exclusion */
							do {
								pos++;
								if (mode_from_str(opcstr+pos) == destmode)
									goto nomatch;
								pos += 4;
							} while (opcstr[pos] == ',');
							pos++;
						} else {
							if (opcstr[pos+4] == '-') {
								/* replacement */
								if (mode_from_str(opcstr+pos) == destmode)
									destmode = mode_from_str(opcstr+pos+5);
								else
									goto nomatch;
								pos += 10;
							} else {
								/* normal */
								while(mode_from_str(opcstr+pos) != destmode) {
									pos += 4;
									if (opcstr[pos] == ']')
										goto nomatch;
									pos++;
								}
								while(opcstr[pos] != ']') pos++;
								pos++;
							}
						}
					}
					break;
				default: u020_abort();
	}
	/* safety check - might have changed */
	if (destmode != Areg && destmode != Dreg && destmode != Aind
		&& destmode != Ad16 && destmode != Ad8r && destmode != Aipi
		&& destmode != Apdi)
	{
		dstgather = 0;
	}
	
	if (destmode == Areg && sz == sz_byte)
		goto nomatch;
endofline:
	/* now, we have a match */
	if (find == -1) {
		for (find = 0;; find++) {
			if (strcmp(mnemonic, lookuptab[find].name) == 0) {
				table68k[opc].mnemo = lookuptab[find].mnemo;
				break;
			}
			if (strlen(lookuptab[find].name) == 0) u020_abort();
		}
	}
	else {
		table68k[opc].mnemo = lookuptab[find].mnemo;
	}
	table68k[opc].cc = bitval[bitc];
	if (table68k[opc].mnemo == i_BTST
		|| table68k[opc].mnemo == i_BSET
		|| table68k[opc].mnemo == i_BCLR
		|| table68k[opc].mnemo == i_BCHG)
	{
		sz = destmode == Dreg ? sz_long : sz_byte;
	}
	table68k[opc].size = sz;
	table68k[opc].sreg = srcreg;
	table68k[opc].dreg = destreg;
	table68k[opc].smode = srcmode;
	table68k[opc].dmode = destmode;
	table68k[opc].spos = srcgather ? srcpos : -1;
	table68k[opc].dpos = dstgather ? dstpos : -1;
	table68k[opc].suse = usesrc;
	table68k[opc].duse = usedst;
	table68k[opc].stype = srctype;
	table68k[opc].plev = id.plevel;
	table68k[opc].clev = id.cpulevel;
	table68k[opc].flagdead = flagdead;
	table68k[opc].flaglive = flaglive;
nomatch:
	/* FOO! */;
    }
}


void read_table68k (void)
{
    int i;
	
    table68k = (struct instr *) AllocateMem (65536 * sizeof (struct instr));
    for (i = 0; i < 65536; i++)
	{
		table68k[i].mnemo = i_ILLG;
		table68k[i].handler = -1;
    }
    for (i = 0; i < n_defs68k; i++)
	{
		build_insn (i);
    }
}

static int mismatch;

static void handle_merges (long int opcode)
{
    UINT16 smsk;
    UINT16 dmsk;
    int sbitdst, dstend;
    int srcreg, dstreg;
	
    if (table68k[opcode].spos == -1) {
		sbitdst = 1; smsk = 0;
    } else {
		switch (table68k[opcode].stype) {
		case 0:
			smsk = 7; sbitdst = 8; break;
		case 1:
			smsk = 255; sbitdst = 256; break;
		case 2:
			smsk = 15; sbitdst = 16; break;
		case 3:
			smsk = 7; sbitdst = 8; break;
		case 4:
			smsk = 7; sbitdst = 8; break;
		case 5:
			smsk = 63; sbitdst = 64; break;
		default:
			smsk = 0; sbitdst = 0;
			u020_abort();
			break;
		}
		smsk <<= table68k[opcode].spos;
    }
    if (table68k[opcode].dpos == -1) {
		dstend = 1; dmsk = 0;
    } else {
		dmsk = 7 << table68k[opcode].dpos;
		dstend = 8;
    }
    for (srcreg=0; srcreg < sbitdst; srcreg++) {
		for (dstreg=0; dstreg < dstend; dstreg++) {
			UINT16 code = opcode;
			
			code = (code & ~smsk) | (srcreg << table68k[opcode].spos);
			code = (code & ~dmsk) | (dstreg << table68k[opcode].dpos);
			
			/* Check whether this is in fact the same instruction.
			* The instructions should never differ, except for the
			* Bcc.(BW) case. */
			if (table68k[code].mnemo != table68k[opcode].mnemo
				|| table68k[code].size != table68k[opcode].size
				|| table68k[code].suse != table68k[opcode].suse
				|| table68k[code].duse != table68k[opcode].duse)
			{
				mismatch++; continue;
			}
			if (table68k[opcode].suse
				&& (table68k[opcode].spos != table68k[code].spos
				|| table68k[opcode].smode != table68k[code].smode
				|| table68k[opcode].stype != table68k[code].stype))
			{
				mismatch++; continue;
			}
			if (table68k[opcode].duse
				&& (table68k[opcode].dpos != table68k[code].dpos
				|| table68k[opcode].dmode != table68k[code].dmode))
			{
				mismatch++; continue;
			}
			
			if (code != opcode)
				table68k[code].handler = opcode;
		}
    }
}

void do_merges (void)
{
    long int opcode;
    int nr = 0;
    mismatch = 0;
    for (opcode = 0; opcode < 65536; opcode++) {
		if (table68k[opcode].handler != -1 || table68k[opcode].mnemo == i_ILLG)
			continue;
		nr++;
		handle_merges (opcode);
    }
    nr_cpuop_funcs = nr;
}

int get_no_mismatches (void)
{
    return mismatch;
}