inst2.c

m68k系列反汇编的C语言源码,供学习编译原理的同学使用。实用！

		return;
	if (getea(buf1, reg, mode, size))
		return;
	reglist(buf2, regmask, mode);
	if (to) {
		if (!ISCEAplusPOST(mode, reg))
			return;
		cp1 = buf1;
		cp2 = buf2;
	} else {
		if (!ISACEAplusPRE(mode, reg))
			return;
		cp1 = buf2;
		cp2 = buf1;
	}

	instprint(ops2f(2) | size2f(size), "MOVEM", cp1, cp2);

	valid = 1;
}

void
dbcc(m68kword inst)
{
	int		reg = inst & 7;
	int		condition = (inst >> 8) & 0xf;
	long		value;
	int		failure;
	char		sdbcc[5];
	m68kaddr	savedpc;
	short		f = ops2f(2);

	sprintf(sdbcc, "DB%s", condition == 1 ? "RA" : cc[condition]);
	sprintf(buf1, "D%d", reg);
	savedpc = pc;
	value = getval(WORD, &failure);
	if (failure)
		return;

	if (pass == FIRSTPASS && onepass != INCONSISTENT) {
		required[flags & 3] = value + savedpc;
		flags++;
	} else if (pass == LASTPASS && value + savedpc >= initialpc
	  && value + savedpc <= initialpc + maxoffset
	  && insts[value + savedpc - initialpc].labelnum)
		sprintf(buf2, "L%d",
		  insts[value + savedpc - initialpc].labelnum);
	else /* if (pass == DEBUGPASS
	  || value + savedpc > initialpc + maxoffset) */
		/* immsprintf(buf2, value); */
		sprintf(buf2, "%lx", (long)(value + savedpc));
	instprint(f, sdbcc, buf1, buf2);

	valid = 1;
}

void
trapcc(m68kword inst)
{
	int	mode = inst & 7;
	int	condition = (inst >> 8) & 0xf;
	long	value = 0;
	int	failure;
	int	lflags;

	sprintf(buf1, "TRAP%s", cc[condition]);
	switch (mode) {
	case 2:
		value = getval(WORD, &failure);
		if (failure)
			return;
		lflags = ops2f(1) | size2f(WORD) | sharp2f(1);
		break;
	case 3:
		value = getval(LONGWORD, &failure);
		if (failure)
			return;
		lflags = ops2f(1) | size2f(LONGWORD) | sharp2f(1);
		break;
	case 4:
		lflags = ops2f(0);
		break;
	default:
		return;
	}

	sprintf(buf2, "%ld", value);

	instprint(lflags, buf1, buf2);

	valid = 1;
}

void
scc(m68kword inst)
{
	int	reg = inst & 7;
	int	mode = (inst >> 3) & 7;
	int	condition = (inst >> 8) & 0xf;

	if (!ISADEA(mode, reg))
		return;
	sprintf(buf1, "S%s", cc[condition]);
	if (getea(buf2, reg, mode, BYTE))
		return;
	instprint(ops2f(1) | sharp2f(2), buf1, buf2);

	valid = 1;
}

void
pack_unpk(const char *name, m68kword inst)
{
	int	reg1 = inst & 7;
	int	reg2 = (inst >> 9) & 7;
	long	value;
	int	failure;

	if (inst & 8) {
		sprintf(buf1, "-(%2.2s)", Areg(reg1));
		sprintf(buf2, "-(%2.2s)", Areg(reg2));
	} else {
		sprintf(buf1, "D%d", reg1);
		sprintf(buf2, "D%d", reg2);
	}

	value = getval(WORD, &failure);
	if (failure)
		return;
	immsprintf(buf3, value);
	instprint(ops2f(3) | sharp2f(3), name, buf1, buf2, buf3);

	valid = 1;
}

void
addq_subq(m68kword inst)
{
	int	reg = inst & 7;
	int	mode = (inst >> 3) & 7;
	int	size = (inst >> 6) & 3;
	int	data;

	if (!ISAEA(mode, reg) || ISDIRECT(mode) && size == BYTE)
		return;

	if ((data = (inst >> 9) & 7) == 0)
		data = 8;
	sprintf(buf1, "%d", data);
	if (getea(buf2, reg, mode, size))
		return;
	instprint(ops2f(2) | size2f(size) | sharp2f(1),
	  (inst & 0x0100) ? "SUBQ" : "ADDQ", buf1, buf2);

	valid = 1;
}

void
op1(const char *name, m68kword inst)
{
	int	datareg = (inst >> 9) & 7;
	int	reg = inst & 7;
	int	mode = (inst >> 3) & 7;
	int	size = (inst >> 6) & 3;
	char	*cp1, *cp2;

	if (getea(buf1, reg, mode, size))
		return;
	sprintf(buf2, "D%d", datareg);
	if (inst & 0x0100) {
		if (name[0] == 'E') {
			/* EOR */
			if (!ISADEA(mode, reg))
				return;
		} else {
			/* ADD, AND, OR, SUB */
			if (!ISAMEA(mode, reg))
				return;
		}
		cp1 = buf2;
		cp2 = buf1;
	} else {
		if (name[0] == 'O' || name[1] == 'N') {
			/* AND, OR */
			if (!ISDEA(mode, reg))
				return;
		} else {
			/* ADD, CMP, SUB */
			if (ISDIRECT(mode) && size == BYTE)
				return;
		}
		cp1 = buf1;
		cp2 = buf2;
	}
	instprint(ops2f(2) | size2f(size), name, cp1, cp2);

	valid = 1;
}

void
op2(const char *name, m68kword inst)
{
	int	datareg = (inst >> 9) & 7;
	int	reg = inst & 7;
	int	mode = (inst >> 3) & 7;
	char	realname[10];

	if (!ISDEA(mode, reg))
		return;
	strcpy(realname, name);
	strcat(realname, ((inst >> 8) & 1) ? "S" : "U");
	if (getea(buf1, reg, mode, WORD))
		return;
	sprintf(buf2, "D%d", datareg);
	instprint(ops2f(2) | size2f(WORD), realname, buf1, buf2);

	valid = 1;
}

void
op2long(const char *name, m68kword inst)
{
	int	reg = inst & 7;
	int	mode = (inst >> 3) & 7;
	char	realname[10];
	long	value;
	int	failure;
	int	rreg;
	int	qreg;
	int	quadword_dividend;

	if (!ISDEA(mode, reg))
		return;
	value = getval(WORD, &failure);
	if (failure)
		return;
	if (value & 0x83f8)
		return;

	rreg = value & 7;
	qreg = (value >> 12) & 7;
	quadword_dividend = value & 0x0400;

	strcpy(realname, name);
	strcat(realname, (value & 0x0800) ? "S" : "U");
	if (realname[0] == 'D' && rreg != qreg && !quadword_dividend)
		strcat(realname, "L");
	if (rreg == qreg && !quadword_dividend)
		sprintf(buf2, "D%d", qreg);
	else
		sprintf(buf2, "D%d:D%d", rreg, qreg);

	if (getea(buf1, reg, mode, LONGWORD))
		return;
	instprint(ops2f(2) | size2f(LONGWORD), realname, buf1, buf2);

	valid = 1;
}

void
opa(const char *name, m68kword inst)
{
	int	addrreg = (inst >> 9) & 7;
	int	reg = inst & 7;
	int	mode = (inst >> 3) & 7;
	int	size = ((inst >> 8) & 1) ? LONGWORD : WORD;

	if (getea(buf1, reg, mode, size))
		return;
	sprintf(buf2, "%2.2s", Areg(addrreg));
	instprint(ops2f(2) | size2f(size), name, buf1, buf2);

	valid = 1;
}

void
opx(const char *name, m68kword inst, int mode, int printsize)
{
	int	destreg = (inst >> 9) & 7;
	int	srcreg = inst & 7;
	int	size = (inst >> 6) & 3;
	int	lflags = ops2f(2);

	if (printsize)
		lflags |= size2f(size);

	if (inst & 8) {
		if (getea(buf1, srcreg, mode, size))
			return;
		if (getea(buf2, destreg, mode, size))
			return;
	} else {
		sprintf(buf1, "D%d", srcreg);
		sprintf(buf2, "D%d", destreg);
	}
	instprint(lflags, name, buf1, buf2);

	valid = 1;
}

void
exg(m68kword inst, char c1, char c2)
{
	int	reg1 = (inst >> 9) & 7;
	int	reg2 = inst & 7;

	Areg2(buf1, c1, reg1);
	Areg2(buf2, c2, reg2);
	instprint(ops2f(2), "EXG", buf1, buf2);

	valid = 1;
}

void
bitfield(m68kword inst)
{
	int	reg = inst & 7;
	int	mode = (inst >> 3) & 7;
	int	type = (inst >> 8) & 3;
	long	value;
	int	failure;
	int	destreg;
	int	offset;
	int	width;
	char	name[10];
	int	n;

	value = getval(WORD, &failure);
	if (failure)
		return;
	if (value & 0x8000)
		return;
	if ((type & 1) == 0 && (value & 0xf000))
		return;
	destreg = (value >> 12) & 7;
	offset = (value >> 6) & 0x1f;
	width = value & 0x1f;
	sprintf(name, "BF%s", (type & 1) ? bitf[type] : bitd[type]);

	if (!ISDIRECT(mode))
		if (name[2] == 'C' || name[2] == 'I' || name[2] == 'S') {
			/* BFCHG, BFCLR, BFINS, BFSET */
			if (!ISACEA(mode, reg))
				return;
		} else {
			/* BFEXTS, BFEXTU, BFFFO, BFTST */
			if (!ISCEA(mode, reg))
				return;
		}

	if (getea(buf1, reg, mode, BYTE /* actually unsized */))
		return;
	strcpy(buf3, "{");
	n = 1;
	if (value & 0x0800) {
		if (offset & ~7)
			return;
		n += sprintf(buf3 + n, "D%d", offset & 7);
	} else
		n += sprintf(buf3 + n, "%d", offset);
	if (value & 0x0020) {
		if (width & ~7)
			return;
		n += sprintf(buf3 + n, "D%d", width & 7);
	} else
		n += sprintf(buf3 + n, "%d", width ? width : 32);
	strcat(buf3, "}");
	strcat(buf1, buf3);
	if (type & 1) {
		sprintf(buf2, "D%d", destreg);
		instprint(ops2f(2), name, buf1, buf2);
	} else
		instprint(ops2f(1), name, buf1);

	valid = 1;
}

void
getshiftname(char *name, int type, int direction)
{
	switch (type) {
	case 0:	strcpy(name, "AS");	break;
	case 1:	strcpy(name, "LS");	break;
	case 2:	strcpy(name, "ROX");	break;
	case 3:	strcpy(name, "RO");	break;
	}
	strcat(name, direction ? "L" : "R");
}

void
shift(m68kword inst)
{
	int	reg;
	int	mode;
	int	type;
	int	direction = (inst >> 8) & 1;
	int	data;
	int	size;
	char	name[10];

	reg = inst & 7;
	if ((size = ((inst >> 6) & 3)) == 3) {
		size = WORD;
		mode = (inst >> 3) & 7;

		if (inst & 0x0800)
			return;
		if (!ISAMEA(mode, reg))
			return;

		if (getea(buf1, reg, mode, size))
			return;
		type = (inst >> 9) & 3;
		getshiftname(name, type, direction);
		instprint(ops2f(1), name, buf1);
	} else {
		sprintf(buf2, "D%d", reg);
		type = (inst >> 3) & 3;
		if (inst & 0x0020)
			sprintf(buf1, "D%d", (inst >> 9) & 7);
		else {
			if ((data = (inst >> 9) & 7) == 0)
				data = 8;
			sprintf(buf1, "#%d", data);
		}
		getshiftname(name, type, direction);
		instprint(ops2f(2) | size2f(size), name, buf1, buf2);
	}

	valid = 1;
}

void
cpsave(const char *prefix, m68kword inst)
{
	int	reg = inst & 7;
	int	mode = (inst >> 3) & 7;

	if (!ISACEAplusPRE(mode, reg))
		return;
	if (getea(buf1, reg, mode, BYTE /* actually unsized */))
		return;
	sprintf(buf2, "%sSAVE", prefix);
	instprint(ops2f(1), buf2, buf1);

	valid = 1;
}

void
cprestore(const char *prefix, m68kword inst)
{
	int	reg = inst & 7;
	int	mode = (inst >> 3) & 7;

	if (!ISCEAplusPOST(mode, reg))
		return;
	if (getea(buf1, reg, mode, BYTE /* actually unsized */))
		return;
	sprintf(buf2, "%sRESTORE", prefix);
	instprint(ops2f(1), buf2, buf1);

	valid = 1;
}

void
cpdbcc(struct cp *cpptr, m68kword inst)
{
	int		reg = inst & 7;
	long		value;
	int		failure;
	char		sdbcc[6];
	m68kaddr	savedpc;
	short		f = ops2f(2);
	unsigned	condition;
	char		*condstr;

	savedpc = pc;
	condition = getval(WORD, &failure) & 0xffff;
	if (failure)
		return;
	if (condition & 0xffc0)
		return;
	if ((condstr = cpptr->cc(condition)) == NULL)
		return;
	sprintf(sdbcc, "%sDB%s", cpptr->prefix, condstr);
	sprintf(buf1, "D%d", reg);

	value = getval(WORD, &failure);
	if (failure)
		return;

	if (pass == FIRSTPASS && onepass != INCONSISTENT) {
		required[flags & 3] = value + savedpc;
		flags++;
	} else if (pass == LASTPASS && value + savedpc >= initialpc
	  && value + savedpc <= initialpc + maxoffset
	  && insts[value + savedpc - initialpc].labelnum)
		sprintf(buf2, "L%d",
		  insts[value + savedpc - initialpc].labelnum);
	else /* if (pass == DEBUGPASS
	  || value + savedpc > initialpc + maxoffset) */
		/* immsprintf(buf2, value); */
		sprintf(buf2, "%lx", (long)(value + savedpc));
	instprint(f, sdbcc, buf1, buf2);

	valid = 1;
}

void
cpbcc(struct cp *cpptr, m68kword inst)
{
	unsigned	condition = inst & 0x003f;
	long		value;
	int		failure;
	char		sbcc[5];
	m68kaddr	savedpc;
	int		size = (inst & 0x0040) ? LONGWORD : WORD;
	char		*condstr;

	if ((condstr = cpptr->cc(condition)) == NULL)
		return;
	sprintf(sbcc, "%sB%s", cpptr->prefix, condstr);

	savedpc = pc;
	value = getval(size, &failure);
	if (failure)
		return;

	if (cpptr->prefix[0] == 'F' && cpptr->prefix[1] == '\0'
	  && inst == 0xf280 && value == 0) {
		instprint(ops2f(0), "FNOP");
		valid = 1;
		return;
	}

	if (onepass != INCONSISTENT
	  && (value < 0 && -value > savedpc - initialpc
          || value > 0 && value + savedpc > initialpc + maxoffset
          || !odd && value & 1))
                return;

	if (pass == FIRSTPASS && onepass != INCONSISTENT) {
		required[flags & 3] = value + savedpc;
		flags++;
	} else if (pass == LASTPASS && value + savedpc >= initialpc
	  && value + savedpc <= initialpc + maxoffset
	  && insts[value + savedpc - initialpc].labelnum)
		sprintf(buf1, "L%d",
		  insts[value + savedpc - initialpc].labelnum);
	else /* if (pass == DEBUGPASS
	  || value + savedpc > initialpc + maxoffset) */
		/* immsprintf(buf1, value); */
		sprintf(buf1, "%lx", (long)(value + savedpc));
	instprint(ops2f(1), sbcc, buf1);

	valid = 1;
}

void
cptrapcc(struct cp *cpptr, m68kword inst)
{
	unsigned long	value;
	int		failure;
	int		lflags;
	int		mode = inst & 7;
	unsigned	condition;
	char		*condstr;

	condition = getval(WORD, &failure) & 0xffff;
	if (failure)
		return;
	if (condition & 0xffc0)
		return;
	if ((condstr = cpptr->cc(condition)) == NULL)
		return;
	sprintf(buf1, "%sTRAP%s", cpptr->prefix, condstr);

	switch (mode) {
	case 2:
		value = getval(WORD, &failure);
		if (failure)
			return;
		lflags = ops2f(1) | size2f(WORD) | sharp2f(1);
		break;
	case 3:
		value = getval(LONGWORD, &failure);
		if (failure)
			return;
		lflags = ops2f(1) | size2f(LONGWORD) | sharp2f(1);
		break;
	case 4:
		lflags = ops2f(0);
		break;
	default:
		return;
	}

	sprintf(buf2, "%ld", value);

	instprint(lflags, buf1, buf2);

	valid = 1;
}

void
cpscc(struct cp *cpptr, m68kword inst)
{
	int		reg = inst & 7;
	int		mode = (inst >> 3) & 7;
	int		failure;
	unsigned	condition;
	char		*condstr;

	if (!ISADEA(mode, reg))
		return;
	condition = getval(WORD, &failure) & 0xffff;
	if (failure)
		return;
	if ((condstr = cpptr->cc(condition)) == NULL)
		return;

	if (getea(buf2, reg, mode, BYTE))
		return;

	sprintf(buf1, "%sS%s", cpptr->prefix, condstr);
	instprint(ops2f(1) | sharp2f(2), buf1, buf2);

	valid = 1;
}