disassemble.c

国产CPU－龙芯（loongson)BIOS源代码

			NB=32;
		}
		pstr += sprintf (pstr, ", %d", NB);
		func &= ~Op_SR;
	}
	if (func & Op_IMM) {
		u_int IMM;
		IMM = extract_field(instr, 31 - 19, 4);
		pstr += sprintf (pstr, ", %d", IMM);
		func &= ~Op_SR;
	}
}

void
op_base(char *buf, instr_t instr, void *pc)
{
	dis_ppc(buf, opcodes,instr, pc);
}

void
op_cl_x13(char *buf, instr_t instr, void *pc)
{
	dis_ppc(buf, opcodes_13,instr, pc);
}

void
op_cl_x1e(char *buf, instr_t instr, void *pc)
{
	dis_ppc(buf, opcodes_1e,instr, pc);
}

void
op_cl_x1f(char *buf, instr_t instr, void *pc)
{
	dis_ppc(buf, opcodes_1f,instr, pc);
}

void
op_cl_x3a(char *buf, instr_t instr, void *pc)
{
	dis_ppc(buf, opcodes_3a,instr, pc);
}

void
op_cl_x3b(char *buf, instr_t instr, void *pc)
{
	dis_ppc(buf, opcodes_3b,instr, pc);
}

void
op_cl_x3e(char *buf, instr_t instr, void *pc)
{
	dis_ppc(buf, opcodes_3e,instr, pc);
}

void
op_cl_x3f(char *buf, instr_t instr, void *pc)
{
	dis_ppc(buf, opcodes_3f,instr, pc);
}

void
dis_ppc(char *buf, const struct opcode *opcodeset, instr_t instr, void *pc)
{
	const struct opcode *op;
	int found = 0;
	int i;

	for (   i=0, op = &opcodeset[0];
		found == 0 && op->mask != 0;
		i++, op= &opcodeset[i] )
	{
		if ((instr & op->mask) == op->code) {
			found = 1;
			buf += sprintf(buf, "%s", op->name);
			disasm_fields(op, instr, buf, pc);
			return;
		}
	}
	op_ill(buf, instr, pc);
}

/*----------------------------------------------------------------*/

const Optdesc l_opts[] =
{
    {"-b", "list only branches"},
    {"-c", "list only calls"},
    {"-t", "list trace buffer"},
    {"-r", "show register values with trace"},
    {0}
};

static void
dispchist(args, siz)
	int args, siz;
{
	int	i, l;
	u_int32_t adr;

	l = siz;
	for(i = 0;; i++) {
		adr = getpchist(i);
		if(adr == 0) {
			break;
		}
		md_disasm(prnbuf, (void *)adr);
		if(more(prnbuf, &l, (args > 1) ? 0 : siz)) {
			break;
		}
	}
}

void *
md_disasm(char *buf, void *loc)
{
	int class;
	instr_t opcode;
	opcode = (instr_t)load_word((u_int32_t *)loc);
	class = opcode >> 26;

	if(!adr2symoff(buf, (int)loc, 12)) {
		sprintf(buf, "%08x", loc);
	}
	buf += strlen(buf);
	buf += sprintf(buf, " %08x ", opcode);

	(opcodes_base[class])(buf, opcode, loc);

	return loc + 4;
}

int
md_disassemble(ac, av)
	int	ac;
	char	*av[];
{
	int	bflag, cflag, tflag, rflag;
	int	i, j, l, n;
	int	adr, siz;
static	int	last_adr, prev_adr;

	bflag = 0;
	cflag = 0;
	tflag = 0;
	rflag = 0;
	n = 0;
	siz = moresz;

	for (i = 1; i < ac; i++) {
		if (av[i][0] == '-') {
			for (j = 1; av[i][j] != 0; j++) {
				switch (av[i][j]) {
				case 'b':
					bflag = 1;
					break;
				case 'c':
					cflag = 1;
					break;
				case 't':
					tflag = 1;
					n++;
					break;
				case 'r':
					rflag = 1;
					break;
				default:
					printf ("%c: unknown option\n", av[i][j]);
					return (-1);
				}
			}
		} else {
			switch (n) {
			case 0:
				if (!get_rsa (&adr, av[i]))
					return (-1);
				break;
			case 1:
				if (!get_rsa (&siz, av[i]))
					return (-1);
				break;
			default:
				printf ("%s: unknown option\n", av[i]);
				return (-1);
			}
			n++;
		}
	} 
	if(repeating_cmd)
		adr = last_adr - 4;

#if 0
	if(matchenv("regstyle")) {
		regname = regs_sw;
		c0reg = regs_c0;
	}
	else {
		regname = regs_hw;
		c0reg = regs_hw;
	}
#endif

	ioctl(STDIN, CBREAK, NULL);

	if(tflag) {
		dispchist(n, siz);
		rflag = 0;
		return(0);
	}

	l = siz;

	if(cflag || bflag)
		printf("%s", searching);

	while(1) {
		if(cflag || bflag) {
			int match;
			char *s;
			if(cflag) {
				match = 0; /*XXX check if branch and link */
			}
			else {
				match = 0; /* XXX check if branch */
			}
			if(match) {
				dotik(128, 0);
				adr += 4;
				continue;
			}

			s = searching;
			while(*s++) {
				printf("\b \b");
			}
		}
		prev_adr = adr;
		adr = (int)md_disasm(prnbuf, (void *)adr);
		last_adr = adr;
		if(more(prnbuf, &l, (n > 1) ? 0 : siz)) {
			break;
		}
#if 0
		if(rflag && (is_bl(prev_adr))) {  /* Show call args */
		}
#endif
		if(cflag || bflag) {
			printf("%s", searching);
		}
	}
	rflag = 0;
	return(0);
}

/*----------------------------------------------------------------*/

int
md_stacktrace(ac, av)
	int ac;
	char **av;
{
extern int optind;
	int vflag = 0;
	int c, siz, cnt;
	void *addr;

	optind = 0;
	while((c = getopt (ac, av, "v")) != EOF) {
		switch(c) {
		case 'v':
			vflag++;
			break;

		default:
			return(-1);
		}
	}
	cnt = siz = moresz;
	if(optind < ac) {
		if(!get_rsa(&cnt, av[optind++])) {
			return(-1);
		}
		siz = 0;
	}
	if(optind != ac) {
		return(-1);
	}

	ioctl (STDIN, CBREAK, NULL);

	addr = (void *)DBGREG.fixreg[1];

	while(addr != NULL) {
		void *nextframe = (void *)load_word(addr);
		void *pc = (void *)load_word((void *)(int)addr + 4);
		char *p = prnbuf;
		int framesize = (int)nextframe - (int)addr;

		if(nextframe == 0) {
			framesize = 0;
		}

		if(!adr2symoff (p, (u_int32_t)pc, 24)) {
			sprintf(p, "              0x%08x", pc);
		}
		p += strlen(p);
		/* XXX Wind up saved arg regs and print ? */
		/* XXX Useful? Well most code is optimized... */

		if(vflag) {
			p += sprintf(p, " frame=0x%08x size=%-5d",
						nextframe, framesize);
		}
		if(more(prnbuf, &cnt, siz)) {
			break;
		}
		if(addr == nextframe) {
			more("end of stack or selfpointing!", &cnt, siz);
			break;
		}
		addr = nextframe;
	}
	return(0);
}

void *
md_dumpframe (void *pframe)
{
        int nextframe;
        int lr;
        int *access;

        access = (int *)(pframe);
        nextframe = *access;

        access = (int *)(nextframe+4);
        lr = *access;

        printf("lr %x fp %x nfp %x\n", lr, pframe, nextframe);

        return((void *)nextframe);
}
/*
 *      Frame tracing.
 */
void
md_do_stacktrace(addr, have_addr, count, modif)
	void *addr;
	int have_addr;
	int count;
	char *modif;
{
	void *xadr;

	__asm__ volatile(" mr %0, 1\n" : "=r"(xadr));

	if (have_addr == -1) {	/* Stacktrace ourself */
		addr = xadr;
	}
        else if(have_addr == 0) {
                addr = (void *)DBGREG.fixreg[1];
        }

        while (addr != 0) {
                addr = md_dumpframe(addr);
        }
} 

/*
 *  Command table registration
 *  ==========================
 */
extern const Optdesc md_r_opts[];

static const Cmd MDebugCmd[] =
{
	{"Debugger"},
	{"r",		"[reg* [val|field val]]",
			md_r_opts,
			"display/set register",
			md_registers, 1, 4, CMD_REPEAT},
	{"l",		"[-bct][adr [cnt]]",
			l_opts,
			"list (disassemble) memory",
			md_disassemble, 1, 5, CMD_REPEAT},
	{"bt",		"[-v] [cnt]",
			0,
			"stack backtrace",
			md_stacktrace, 1, 3, CMD_REPEAT},
	{0, 0}
};

static void init_cmd __P((void)) __attribute__ ((constructor));

static void
init_cmd()
{
	cmdlist_expand(MDebugCmd, 1);
}