db_disasm.cxx

C++ 编写的EROS RTOS

			} else {
				addrp->disp = 0;
				addrp->base = db_index_reg_16[rm];
			}
			break;
		    case 1:
			get_value_inc(disp, loc, 1, true);
			addrp->disp = disp;
			addrp->base = db_index_reg_16[rm];
			break;
		    case 2:
			get_value_inc(disp, loc, 2, true);
			addrp->disp = disp;
			addrp->base = db_index_reg_16[rm];
			break;
		}
	} else {
		if (mod != 3 && rm == 4) {
			get_value_inc(sib, loc, 1, false);
			rm = sib_base(sib);
			index = sib_index(sib);
			if (index != 4)
				addrp->index = db_reg[LONG][index];
			addrp->ss = sib_ss(sib);
		}

		switch (mod) {
		    case 0:
			if (rm == 5) {
				get_value_inc(addrp->disp, loc, 4, false);
				addrp->base = 0;
			} else {
				addrp->disp = 0;
				addrp->base = db_reg[LONG][rm];
			}
			break;
		    case 1:
			get_value_inc(disp, loc, 1, true);
			addrp->disp = disp;
			addrp->base = db_reg[LONG][rm];
			break;
		    case 2:
			get_value_inc(disp, loc, 4, false);
			addrp->disp = disp;
			addrp->base = db_reg[LONG][rm];
			break;
		}
	}
	return (loc);
}

void
db_print_address(char *seg, int size, i_addr *addrp)
{
	if (addrp->is_reg) {
		db_printf("%s", db_reg[size][addrp->disp]);
		return;
	}

	if (seg)
		db_printf("%s:", seg);

	db_printsym((db_addr_t)addrp->disp, DB_STGY_ANY);
	if (addrp->base != 0 || addrp->index != 0) {
		db_printf("(");
		if (addrp->base)
			db_printf("%s", addrp->base);
		if (addrp->index)
			db_printf(",%s,%d", addrp->index, 1<<addrp->ss);
		db_printf(")");
	}
}

/*
 * Disassemble floating-point ("escape") instruction
 * and return updated location.
 */
db_addr_t
db_disasm_esc(db_addr_t loc, int inst, int short_addr,
	      int /* size */, char *seg)
{
	int		regmodrm;
	struct finst	*fp;
	int		mod;
	struct i_addr	address;
	char *		name;

	get_value_inc(regmodrm, loc, 1, false);
	fp = &db_Esc_inst[inst - 0xd8][f_reg(regmodrm)];
	mod = f_mod(regmodrm);
	if (mod != 3) {
		/*
		 * Normal address modes.
		 */
		loc = db_read_address(loc, short_addr, regmodrm, &address);
		db_printf(fp->f_name);
		switch(fp->f_size) {
		    case SNGL:
			db_printf("s");
			break;
		    case DBLR:
			db_printf("l");
			break;
		    case EXTR:
			db_printf("t");
			break;
		    case WORD:
			db_printf("s");
			break;
		    case LONG:
			db_printf("l");
			break;
		    case QUAD:
			db_printf("q");
			break;
		    default:
			break;
		}
		db_printf("\t");
		db_print_address(seg, BYTE, &address);
	} else {
		/*
		 * 'reg-reg' - special formats
		 */
		switch (fp->f_rrmode) {
		    case op2(ST,STI):
			name = (fp->f_rrname) ? fp->f_rrname : fp->f_name;
			db_printf("%s\t%%st,%%st(%d)",name,f_rm(regmodrm));
			break;
		    case op2(STI,ST):
			name = (fp->f_rrname) ? fp->f_rrname : fp->f_name;
			db_printf("%s\t%%st(%d),%%st",name, f_rm(regmodrm));
			break;
		    case op1(STI):
			name = (fp->f_rrname) ? fp->f_rrname : fp->f_name;
			db_printf("%s\t%%st(%d)",name, f_rm(regmodrm));
			break;
		    case op1(X):
			db_printf("%s", ((char **)fp->f_rrname)[f_rm(regmodrm)]);
			break;
		    case op1(XA):
			db_printf("%s\t%%ax",
				  ((char **)fp->f_rrname)[f_rm(regmodrm)]);
			break;
		    default:
			db_printf("<bad instruction>");
			break;
		}
	}

	return (loc);
}

/*
 * Disassemble instruction at 'loc'.  'altfmt' specifies an
 * (optional) alternate format.  Return address of start of
 * next instruction.
 */
db_addr_t
db_disasm(db_addr_t loc, bool altfmt)
{
	int	inst;
	int	size;
	int	short_addr;
	char *	seg;
	struct inst *	ip;
	char *	i_name;
	int	i_size;
	int	i_mode;
	int	regmodrm = 0;
	bool	first;
	int	displ;
	int	prefix;
	int	imm;
	int	imm2;
	int	len;
	struct i_addr	address;

	get_value_inc(inst, loc, 1, false);
	short_addr = false;
	size = LONG;
	seg = 0;

	/*
	 * Get prefixes
	 */
	prefix = true;
	do {
		switch (inst) {
		    case 0x66:		/* data16 */
			size = WORD;
			break;
		    case 0x67:
			short_addr = true;
			break;
		    case 0x26:
			seg = "%es";
			break;
		    case 0x36:
			seg = "%ss";
			break;
		    case 0x2e:
			seg = "%cs";
			break;
		    case 0x3e:
			seg = "%ds";
			break;
		    case 0x64:
			seg = "%fs";
			break;
		    case 0x65:
			seg = "%gs";
			break;
		    case 0xf0:
			db_printf("lock ");
			break;
		    case 0xf2:
			db_printf("repne ");
			break;
		    case 0xf3:
			db_printf("repe ");	/* XXX repe VS rep */
			break;
		    default:
			prefix = false;
			break;
		}
		if (prefix)
			get_value_inc(inst, loc, 1, false);
	} while (prefix);

	if (inst >= 0xd8 && inst <= 0xdf) {
		loc = db_disasm_esc(loc, inst, short_addr, size, seg);
		db_printf("\n");
		return (loc);
	}

	if (inst == 0x0f) {
		get_value_inc(inst, loc, 1, false);
		ip = db_inst_0f[inst>>4];
		if (ip == 0)
			ip = &db_bad_inst;
		else
			ip = &ip[inst&0xf];
	} else {
		ip = &db_inst_table[inst];
	}

	if (ip->i_has_modrm) {
		get_value_inc(regmodrm, loc, 1, false);
		loc = db_read_address(loc, short_addr, regmodrm, &address);
	}

	i_name = ip->i_name;
	i_size = ip->i_size;
	i_mode = ip->i_mode;

	if (ip->i_extra == (char *)db_Grp1 ||
	    ip->i_extra == (char *)db_Grp2 ||
	    ip->i_extra == (char *)db_Grp6 ||
	    ip->i_extra == (char *)db_Grp7 ||
	    ip->i_extra == (char *)db_Grp8) {
		i_name = ((char **)ip->i_extra)[f_reg(regmodrm)];
	} else if (ip->i_extra == (char *)db_Grp3) {
		ip = (struct inst *)ip->i_extra;
		ip = &ip[f_reg(regmodrm)];
		i_name = ip->i_name;
		i_mode = ip->i_mode;
	} else if (ip->i_extra == (char *)db_Grp4 ||
		   ip->i_extra == (char *)db_Grp5) {
		ip = (struct inst *)ip->i_extra;
		ip = &ip[f_reg(regmodrm)];
		i_name = ip->i_name;
		i_mode = ip->i_mode;
		i_size = ip->i_size;
	}

	if (i_size == SDEP) {
		if (size == WORD)
			db_printf(i_name);
		else
			db_printf(ip->i_extra);
	} else {
		db_printf(i_name);
		if (i_size != NONE) {
			if (i_size == BYTE) {
				db_printf("b");
				size = BYTE;
			} else if (i_size == WORD) {
				db_printf("w");
				size = WORD;
			} else if (size == WORD) {
				db_printf("w");
			} else {
				db_printf("l");
			}
		}
	}
	db_printf("\t");
	for (first = true;
	     i_mode != 0;
	     i_mode >>= 8, first = false) {
		if (!first)
			db_printf(",");

		switch (i_mode & 0xFF) {
		    case E:
			db_print_address(seg, size, &address);
			break;
		    case Eind:
			db_printf("*");
			db_print_address(seg, size, &address);
			break;
		    case Ew:
			db_print_address(seg, WORD, &address);
			break;
		    case Eb:
			db_print_address(seg, BYTE, &address);
			break;
		    case R:
			db_printf("%s", db_reg[size][f_reg(regmodrm)]);
			break;
		    case Rw:
			db_printf("%s", db_reg[WORD][f_reg(regmodrm)]);
			break;
		    case Ri:
			db_printf("%s", db_reg[size][f_rm(inst)]);
			break;
		    case S:
			db_printf("%s", db_seg_reg[f_reg(regmodrm)]);
			break;
		    case Si:
			db_printf("%s", db_seg_reg[f_reg(inst)]);
			break;
		    case A:
			db_printf("%s", db_reg[size][0]);	/* acc */
			break;
		    case BX:
			if (seg)
				db_printf("%s:", seg);
			db_printf("(%s)", short_addr ? "%bx" : "%ebx");
			break;
		    case CL:
			db_printf("%%cl");
			break;
		    case DX:
			db_printf("%%dx");
			break;
		    case SI:
			if (seg)
				db_printf("%s:", seg);
			db_printf("(%s)", short_addr ? "%si" : "%esi");
			break;
		    case DI:
			db_printf("%%es:(%s)", short_addr ? "%di" : "%edi");
			break;
		    case CR:
			db_printf("%%cr%d", f_reg(regmodrm));
			break;
		    case DR:
			db_printf("%%dr%d", f_reg(regmodrm));
			break;
		    case TR:
			db_printf("%%tr%d", f_reg(regmodrm));
			break;
		    case I:
			len = db_lengths[size];
			get_value_inc(imm, loc, len, false);/* unsigned */
			db_printf("$%#n", imm);
			break;
		    case Is:
			len = db_lengths[size];
			get_value_inc(imm, loc, len, true);	/* signed */
			db_printf("$%#r", imm);
			break;
		    case Ib:
			get_value_inc(imm, loc, 1, false);	/* unsigned */
			db_printf("$%#n", imm);
			break;
		    case Ibs:
			get_value_inc(imm, loc, 1, true);	/* signed */
			db_printf("$%#r", imm);
			break;
		    case Iw:
			get_value_inc(imm, loc, 2, false);	/* unsigned */
			db_printf("$%#n", imm);
			break;
		    case Il:
			get_value_inc(imm, loc, 4, false);
			db_printf("$%#n", imm);
			break;
		    case O:
			if (short_addr)
				get_value_inc(displ, loc, 2, true);
			else
				get_value_inc(displ, loc, 4, true);
			if (seg)
				db_printf("%s:%#r",seg, displ);
			else
				db_printsym((db_addr_t)displ, DB_STGY_ANY);
			break;
		    case Db:
			get_value_inc(displ, loc, 1, true);
			db_printsym((db_addr_t)(displ + loc), DB_STGY_XTRN);
			break;
		    case Dl:
			get_value_inc(displ, loc, 4, true);
			db_printsym((db_addr_t)(displ + loc), DB_STGY_XTRN);
			break;
		    case o1:
			db_printf("$1");
			break;
		    case o3:
			db_printf("$3");
			break;
		    case OS:
			get_value_inc(imm, loc, 4, false);	/* offset */
			get_value_inc(imm2, loc, 2, false);	/* segment */
			db_printf("$%#n,%#n", imm2, imm);
			break;
		}
	}

	if (altfmt == 0 && (inst == 0xe9 || inst == 0xeb)) {
		/*
		 * GAS pads to longword boundary after unconditional jumps.
		 */
		loc = (loc + (4-1)) & ~(4-1);
	}
	db_printf("\n");
	return (loc);
}