ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/cebix/BasiliskII/src/uae_cpu/readcpu.cpp

Comparing BasiliskII/src/uae_cpu/readcpu.cpp (file contents):
Revision 1.3 by gbeauche, 2001-03-19T13:11:40Z vs.
Revision 1.10 by gbeauche, 2007-06-29T16:32:05Z

#	Line 139 | Line 139 | struct mnemolookup lookuptab[] = {
139		{ i_CPUSHA, "CPUSHA" },
140		{ i_MOVE16, "MOVE16" },
141
142	+	{ i_EMULOP_RETURN, "EMULOP_RETURN" },
143	+	{ i_EMULOP, "EMULOP" },
144	+
145		{ i_MMUOP, "MMUOP" },
146		{ i_ILLG, "" },
147		};
#	Line 195 | Line 198 | static void build_insn (int insn)
198		int variants;
199		struct instr_def id;
200		const char *opcstr;
201	<	int i;
201	>	int i, n;
202
203		int flaglive = 0, flagdead = 0;
204	+	int cflow = 0;
205
206		id = defs68k[insn];
207
208	+	// Control flow information
209	+	cflow = id.cflow;
210	+
211	+	// Mask of flags set/used
212	+	unsigned char flags_set(0), flags_used(0);
213	+
214	+	for (i = 0, n = 4; i < 5; i++, n--) {
215	+	switch (id.flaginfo[i].flagset) {
216	+	case fa_unset: case fa_isjmp: break;
217	+	default: flags_set |= (1 << n);
218	+	}
219	+
220	+	switch (id.flaginfo[i].flaguse) {
221	+	case fu_unused: case fu_isjmp: break;
222	+	default: flags_used |= (1 << n);
223	+	}
224	+	}
225	+
226		for (i = 0; i < 5; i++) {
227		switch (id.flaginfo[i].flagset){
228		case fa_unset: break;
207	–	case fa_isjmp: break;
229		case fa_zero: flagdead |= 1 << i; break;
230		case fa_one: flagdead |= 1 << i; break;
231		case fa_dontcare: flagdead |= 1 << i; break;
#	Line 217 | Line 238 | static void build_insn (int insn)
238		for (i = 0; i < 5; i++) {
239		switch (id.flaginfo[i].flaguse) {
240		case fu_unused: break;
220	–	case fu_isjmp: flaglive |= 1 << i; break;
221	–	case fu_maybecc: flaglive |= 1 << i; break;
241		case fu_unknown: flaglive = -1; goto out2;
242		case fu_used: flaglive |= 1 << i; break;
243		}
#	Line 236 | Line 255 | static void build_insn (int insn)
255		int pos = 0;
256		int mnp = 0;
257		int bitno = 0;
258	<	char mnemonic[10];
258	>	char mnemonic[64];
259
260		wordsizes sz = sz_long;
261		int srcgather = 0, dstgather = 0;
#	Line 273 | Line 292 | static void build_insn (int insn)
292		continue;
293		if (bitcnt[bitI] && (bitval[bitI] == 0x00 || bitval[bitI] == 0xff))
294		continue;
295	+	if (bitcnt[bitE] && (bitval[bitE] == 0x00))
296	+	continue;
297
298		/* bitI and bitC get copied to biti and bitc */
299		if (bitcnt[bitI]) {
#	Line 311 | Line 332 | static void build_insn (int insn)
332		}
333		}
334		mnp++;
335	+	if ((unsigned)mnp >= sizeof(mnemonic) - 1) {
336	+	mnemonic[sizeof(mnemonic) - 1] = 0;
337	+	fprintf(stderr, "Instruction %s overflow\n", mnemonic);
338	+	abort();
339	+	}
340		}
341		pos++;
342		}
#	Line 339 | Line 365 | static void build_insn (int insn)
365		case 'A':
366		srcmode = Areg;
367		switch (opcstr[pos++]) {
342	–	case 'l': srcmode = absl; break;
368		case 'r': srcreg = bitval[bitr]; srcgather = 1; srcpos = bitpos[bitr]; break;
369		case 'R': srcreg = bitval[bitR]; srcgather = 1; srcpos = bitpos[bitR]; break;
370		default: abort();
#	Line 349 | Line 374 | static void build_insn (int insn)
374		case 'P': srcmode = Aipi; pos++; break;
375		}
376		break;
377	+	case 'L':
378	+	srcmode = absl;
379	+	break;
380		case '#':
381		switch (opcstr[pos++]) {
382		case 'z': srcmode = imm; break;
#	Line 394 | Line 422 | static void build_insn (int insn)
422		srcpos = bitpos[bitK];
423		}
424		break;
425	<	case 'p': srcmode = immi; srcreg = bitval[bitp];
425	>	case 'E': srcmode = immi; srcreg = bitval[bitE];
426		if (CPU_EMU_SIZE < 5) { // gb-- what is CPU_EMU_SIZE used for ??
427	+	/* 1..255 */
428	+	srcgather = 1;
429	+	srctype = 6;
430	+	srcpos = bitpos[bitE];
431	+	}
432	+	break;
433	+	case 'p': srcmode = immi; srcreg = bitval[bitp];
434	+	if (CPU_EMU_SIZE < 5) {
435		/* 0..3 */
436		srcgather = 1;
437		srctype = 7;
#	Line 526 | Line 562 | static void build_insn (int insn)
562		case 'R': destreg = bitval[bitR]; dstgather = 1; dstpos = bitpos[bitR]; break;
563		default: abort();
564		}
565	+	if (dstpos < 0 || dstpos >= 32)
566	+	abort();
567		break;
568		case 'A':
569		destmode = Areg;
570		switch (opcstr[pos++]) {
533	–	case 'l': destmode = absl; break;
571		case 'r': destreg = bitval[bitr]; dstgather = 1; dstpos = bitpos[bitr]; break;
572		case 'R': destreg = bitval[bitR]; dstgather = 1; dstpos = bitpos[bitR]; break;
573	+	case 'x': destreg = 0; dstgather = 0; dstpos = 0; break;
574		default: abort();
575		}
576	+	if (dstpos < 0 || dstpos >= 32)
577	+	abort();
578		switch (opcstr[pos]) {
579		case 'p': destmode = Apdi; pos++; break;
580		case 'P': destmode = Aipi; pos++; break;
581		}
582		break;
583	+	case 'L':
584	+	destmode = absl;
585	+	break;
586		case '#':
587		switch (opcstr[pos++]) {
588		case 'z': destmode = imm; break;
#	Line 710 | Line 753 | static void build_insn (int insn)
753		table68k[opc].flaginfo[i].flaguse = id.flaginfo[i].flaguse;
754		}
755		#endif
756	+
757	+	// Fix flags used information for Scc, Bcc, TRAPcc, DBcc instructions
758	+	if      (       table68k[opc].mnemo == i_Scc
759	+	||      table68k[opc].mnemo == i_Bcc
760	+	||      table68k[opc].mnemo == i_DBcc
761	+	||      table68k[opc].mnemo == i_TRAPcc
762	+	)       {
763	+	switch (table68k[opc].cc) {
764	+	// CC mask:     XNZVC
765	+	//                       8421
766	+	case 0: flags_used = 0x00; break;       /*  T */
767	+	case 1: flags_used = 0x00; break;       /*  F */
768	+	case 2: flags_used = 0x05; break;       /* HI */
769	+	case 3: flags_used = 0x05; break;       /* LS */
770	+	case 4: flags_used = 0x01; break;       /* CC */
771	+	case 5: flags_used = 0x01; break;       /* CS */
772	+	case 6: flags_used = 0x04; break;       /* NE */
773	+	case 7: flags_used = 0x04; break;       /* EQ */
774	+	case 8: flags_used = 0x02; break;       /* VC */
775	+	case 9: flags_used = 0x02; break;       /* VS */
776	+	case 10:flags_used = 0x08; break;       /* PL */
777	+	case 11:flags_used = 0x08; break;       /* MI */
778	+	case 12:flags_used = 0x0A; break;       /* GE */
779	+	case 13:flags_used = 0x0A; break;       /* LT */
780	+	case 14:flags_used = 0x0E; break;       /* GT */
781	+	case 15:flags_used = 0x0E; break;       /* LE */
782	+	}
783	+	}
784	+
785	+	#if 1
786	+	/* gb-- flagdead and flaglive would not have correct information */
787	+	table68k[opc].flagdead = flags_set;
788	+	table68k[opc].flaglive = flags_used;
789	+	#else
790		table68k[opc].flagdead = flagdead;
791		table68k[opc].flaglive = flaglive;
792	+	#endif
793	+	table68k[opc].cflow = cflow;
794		nomatch:
795		/* FOO! */;
796		}
#	Line 757 | Line 836 | static void handle_merges (long int opco
836		smsk = 7; sbitdst = 8; break;
837		case 5:
838		smsk = 63; sbitdst = 64; break;
839	+	case 6:
840	+	smsk = 255; sbitdst = 256; break;
841		case 7:
842		smsk = 3; sbitdst = 4; break;
843		default:
#	Line 827 | Line 908 | int get_no_mismatches (void)
908		{
909		return mismatch;
910		}
911	+
912	+	const char *get_instruction_name (unsigned int opcode)
913	+	{
914	+	struct instr *ins = &table68k[opcode];
915	+	for (int i = 0; lookuptab[i].name[0]; i++) {
916	+	if (ins->mnemo == lookuptab[i].mnemo)
917	+	return lookuptab[i].name;
918	+	}
919	+	abort();
920	+	return NULL;
921	+	}
922	+
923	+	static char *get_ea_string (amodes mode, wordsizes size)
924	+	{
925	+	static char buffer[80];
926	+
927	+	buffer[0] = 0;
928	+	switch (mode){
929	+	case Dreg:
930	+	strcpy (buffer,"Dn");
931	+	break;
932	+	case Areg:
933	+	strcpy (buffer,"An");
934	+	break;
935	+	case Aind:
936	+	strcpy (buffer,"(An)");
937	+	break;
938	+	case Aipi:
939	+	strcpy (buffer,"(An)+");
940	+	break;
941	+	case Apdi:
942	+	strcpy (buffer,"-(An)");
943	+	break;
944	+	case Ad16:
945	+	strcpy (buffer,"(d16,An)");
946	+	break;
947	+	case Ad8r:
948	+	strcpy (buffer,"(d8,An,Xn)");
949	+	break;
950	+	case PC16:
951	+	strcpy (buffer,"(d16,PC)");
952	+	break;
953	+	case PC8r:
954	+	strcpy (buffer,"(d8,PC,Xn)");
955	+	break;
956	+	case absw:
957	+	strcpy (buffer,"(xxx).W");
958	+	break;
959	+	case absl:
960	+	strcpy (buffer,"(xxx).L");
961	+	break;
962	+	case imm:
963	+	switch (size){
964	+	case sz_byte:
965	+	strcpy (buffer,"#<data>.B");
966	+	break;
967	+	case sz_word:
968	+	strcpy (buffer,"#<data>.W");
969	+	break;
970	+	case sz_long:
971	+	strcpy (buffer,"#<data>.L");
972	+	break;
973	+	default:
974	+	break;
975	+	}
976	+	break;
977	+	case imm0:
978	+	strcpy (buffer,"#<data>.B");
979	+	break;
980	+	case imm1:
981	+	strcpy (buffer,"#<data>.W");
982	+	break;
983	+	case imm2:
984	+	strcpy (buffer,"#<data>.L");
985	+	break;
986	+	case immi:
987	+	strcpy (buffer,"#<data>");
988	+	break;
989	+
990	+	default:
991	+	break;
992	+	}
993	+	return buffer;
994	+	}
995	+
996	+	const char *get_instruction_string (unsigned int opcode)
997	+	{
998	+	static char out[100];
999	+	struct instr *ins;
1000	+
1001	+	strcpy (out, get_instruction_name (opcode));
1002	+
1003	+	ins = &table68k[opcode];
1004	+	if (ins->size == sz_byte)
1005	+	strcat (out,".B");
1006	+	if (ins->size == sz_word)
1007	+	strcat (out,".W");
1008	+	if (ins->size == sz_long)
1009	+	strcat (out,".L");
1010	+	strcat (out," ");
1011	+	if (ins->suse)
1012	+	strcat (out, get_ea_string (ins->smode, ins->size));
1013	+	if (ins->duse) {
1014	+	if (ins->suse)
1015	+	strcat (out,",");
1016	+	strcat (out, get_ea_string (ins->dmode, ins->size));
1017	+	}
1018	+	return out;
1019	+	}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines