freebsd-dev/sys/ia64/disasm/disasm_format.c

/*-
 * Copyright (c) 2000-2003 Marcel Moolenaar
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/param.h>
#include <sys/systm.h>

#include <ia64/disasm/disasm_int.h>
#include <ia64/disasm/disasm.h>

/*
 * Mnemonics (keep in sync with enum asm_op).
 */
static const char *asm_mnemonics[] = {
	NULL,
	"add", "addl", "addp4", "adds", "alloc", "and", "andcm",
	"br", "break", "brl", "brp", "bsw",
	"chk", "clrrrb", "cmp", "cmp4", "cmp8xchg16", "cmpxchg1", "cmpxchg2",
	"cmpxchg4", "cmpxchg8", "cover", "czx1", "czx2",
	"dep",
	"epc", "extr",
	"famax", "famin", "fand", "fandcm", "fc", "fchkf", "fclass", "fclrf",
	"fcmp", "fcvt", "fetchadd4", "fetchadd8", "flushrs", "fma", "fmax",
	"fmerge", "fmin", "fmix", "fms", "fnma", "for", "fpack", "fpamax",
	"fpamin", "fpcmp", "fpcvt", "fpma", "fpmax", "fpmerge", "fpmin",
	"fpms", "fpnma", "fprcpa", "fprsqrta", "frcpa", "frsqrta", "fselect",
	"fsetc", "fswap", "fsxt", "fwb", "fxor",
	"getf",
	"invala", "itc", "itr",
	"ld1", "ld16", "ld2", "ld4", "ld8", "ldf", "ldf8", "ldfd", "ldfe",
	"ldfp8", "ldfpd", "ldfps", "ldfs", "lfetch", "loadrs",
	"mf", "mix1", "mix2", "mix4", "mov", "movl", "mux1", "mux2",
	"nop",
	"or",
	"pack2", "pack4", "padd1", "padd2", "padd4", "pavg1", "pavg2",
	"pavgsub1", "pavgsub2", "pcmp1", "pcmp2", "pcmp4", "pmax1", "pmax2",
	"pmin1", "pmin2", "pmpy2", "pmpyshr2", "popcnt", "probe", "psad1",
	"pshl2", "pshl4", "pshladd2", "pshr2", "pshr4", "pshradd2", "psub1",
	"psub2", "psub4", "ptc", "ptr",
	"rfi", "rsm", "rum",
	"setf", "shl", "shladd", "shladdp4", "shr", "shrp", "srlz", "ssm",
	"st1", "st16", "st2", "st4", "st8", "stf", "stf8", "stfd", "stfe",
	"stfs", "sub", "sum", "sxt1", "sxt2", "sxt4", "sync",
	"tak", "tbit", "thash", "tnat", "tpa", "ttag",
	"unpack1", "unpack2", "unpack4",
	"xchg1", "xchg2", "xchg4", "xchg8", "xma", "xor",
	"zxt1", "zxt2", "zxt4"
};

/*
 * Completers (keep in sync with enum asm_cmpltr_type).
 */
static const char *asm_completers[] = {
	"",
	".0", ".1",
	".a", ".acq", ".and",
	".b", ".bias",
	".c.clr", ".c.clr.acq", ".c.nc", ".call", ".cexit", ".cloop", ".clr",
	".ctop",
	".d", ".dc.dc", ".dc.nt", ".dpnt", ".dptk",
	".e", ".eq", ".excl", ".exit", ".exp",
	".f", ".fault", ".few", ".fill", ".fx", ".fxu",
	".g", ".ga", ".ge", ".gt",
	".h", ".hu",
	".i", ".ia", ".imp",
	".l", ".le", ".loop", ".lr", ".lt", ".ltu",
	".m", ".many",
	".nc", ".ne", ".neq", ".nl", ".nle", ".nlt", ".nm", ".nr", ".ns",
	".nt.dc", ".nt.nt", ".nt.tk", ".nt1", ".nt2", ".nta", ".nz",
	".or", ".or.andcm", ".ord",
	".pr",
	".r", ".raz", ".rel", ".ret", ".rw",
	".s", ".s0", ".s1", ".s2", ".s3", ".sa", ".se", ".sig", ".spill",
	".spnt", ".sptk", ".sss",
	".tk.dc", ".tk.nt", ".tk.tk", ".trunc",
	".u", ".unc", ".unord", ".uss", ".uus", ".uuu",
	".w", ".wexit", ".wtop",
	".x", ".xf",
	".z"
};

void
asm_completer(const struct asm_cmpltr *c, char *buf)
{
	strcpy(buf, asm_completers[c->c_type]);
}

void
asm_mnemonic(enum asm_op op, char *buf)
{
	strcpy(buf, asm_mnemonics[(op < ASM_OP_INTERNAL_OPCODES) ? op : 0]);
}

void
asm_operand(const struct asm_oper *o, char *buf, uint64_t ip)
{
	const char *n;

	n = NULL;
	switch (o->o_type) {
	case ASM_OPER_AREG:
		switch ((int)o->o_value) {
		case AR_K0: n = "k0"; break;
		case AR_K1: n = "k1"; break;
		case AR_K2: n = "k2"; break;
		case AR_K3: n = "k3"; break;
		case AR_K4: n = "k4"; break;
		case AR_K5: n = "k5"; break;
		case AR_K6: n = "k6"; break;
		case AR_K7: n = "k7"; break;
		case AR_RSC: n = "rsc"; break;
		case AR_BSP: n = "bsp"; break;
		case AR_BSPSTORE: n = "bspstore"; break;
		case AR_RNAT: n = "rnat"; break;
		case AR_FCR: n = "fcr"; break;
		case AR_EFLAG: n = "eflag"; break;
		case AR_CSD: n = "csd"; break;
		case AR_SSD: n = "ssd"; break;
		case AR_CFLG: n = "cflg"; break;
		case AR_FSR: n = "fsr"; break;
		case AR_FIR: n = "fir"; break;
		case AR_FDR: n = "fdr"; break;
		case AR_CCV: n = "ccv"; break;
		case AR_UNAT: n = "unat"; break;
		case AR_FPSR: n = "fpsr"; break;
		case AR_ITC: n = "itc"; break;
		case AR_PFS: n = "pfs"; break;
		case AR_LC: n = "lc"; break;
		case AR_EC: n = "ec"; break;
		default:
			sprintf(buf, "ar%d", (int)o->o_value);
			return;
		}
		sprintf(buf, "ar.%s", n);
		return;
	case ASM_OPER_BREG:
		if (o->o_value != 0)
			sprintf(buf, "b%d", (int)o->o_value);
		else
			strcpy(buf, "rp");
		return;
	case ASM_OPER_CPUID:
		n = "cpuid";
		break;
	case ASM_OPER_CREG:
		switch ((int)o->o_value) {
		case CR_DCR: n = "dcr"; break;
		case CR_ITM: n = "itm"; break;
		case CR_IVA: n = "iva"; break;
		case CR_PTA: n = "pta"; break;
		case CR_IPSR: n = "ipsr"; break;
		case CR_ISR: n = "isr"; break;
		case CR_IIP: n = "iip"; break;
		case CR_IFA: n = "ifa"; break;
		case CR_ITIR: n = "itir"; break;
		case CR_IIPA: n = "iipa"; break;
		case CR_IFS: n = "ifs"; break;
		case CR_IIM: n = "iim"; break;
		case CR_IHA: n = "iha"; break;
		case CR_LID: n = "lid"; break;
		case CR_IVR: n = "ivr"; break;
		case CR_TPR: n = "tpr"; break;
		case CR_EOI: n = "eoi"; break;
		case CR_IRR0: n = "irr0"; break;
		case CR_IRR1: n = "irr1"; break;
		case CR_IRR2: n = "irr2"; break;
		case CR_IRR3: n = "irr3"; break;
		case CR_ITV: n = "itv"; break;
		case CR_PMV: n = "pmv"; break;
		case CR_CMCV: n = "cmcv"; break;
		case CR_LRR0: n = "lrr0"; break;
		case CR_LRR1: n = "lrr1"; break;
		default:
			sprintf(buf, "cr%d", (int)o->o_value);
			return;
		}
		sprintf(buf, "cr.%s", n);
		return;
	case ASM_OPER_DBR:
		n = "dbr";
		break;
	case ASM_OPER_DISP:
		sprintf(buf, "%lx", ip + o->o_value);
		return;
	case ASM_OPER_DTR:
		n = "dtr";
		break;
	case ASM_OPER_FREG:
		sprintf(buf, "f%d", (int)o->o_value);
		return;
	case ASM_OPER_GREG:
		break;
	case ASM_OPER_IBR:
		n = "ibr";
		break;
	case ASM_OPER_IMM:
		sprintf(buf, "0x%lx", o->o_value);
		return;
	case ASM_OPER_IP:
		strcpy(buf, "ip");
		return;
	case ASM_OPER_ITR:
		n = "itr";
		break;
	case ASM_OPER_MEM:
		n = "";
		break;
	case ASM_OPER_MSR:
		n = "msr";
		break;
	case ASM_OPER_PKR:
		n = "pkr";
		break;
	case ASM_OPER_PMC:
		n = "pmc";
		break;
	case ASM_OPER_PMD:
		n = "pmd";
		break;
	case ASM_OPER_PR:
		strcpy(buf, "pr");
                return;
	case ASM_OPER_PR_ROT:
		strcpy(buf, "pr.rot");
		return;
	case ASM_OPER_PREG:
		sprintf(buf, "p%d", (int)o->o_value);
		return;
	case ASM_OPER_PSR:
		strcpy(buf, "psr");
		return;
	case ASM_OPER_PSR_L:
		strcpy(buf, "psr.l");
		return;
	case ASM_OPER_PSR_UM:
		strcpy(buf, "psr.um");
		return;
	case ASM_OPER_RR:
		n = "rr";
		break;
	case ASM_OPER_NONE:
		KASSERT(0, ("foo"));
		break;
	}
	if (n != NULL)
		buf += sprintf(buf, "%s[", n);
	switch ((int)o->o_value) {
	case 1:	strcpy(buf, "gp"); buf += 2; break;
	case 12: strcpy(buf, "sp"); buf += 2; break;
	case 13: strcpy(buf, "tp"); buf += 2; break;
	default: buf += sprintf(buf, "r%d", (int)o->o_value); break;
	}
	if (n != NULL)
		strcpy(buf, "]");
}

void
asm_print_bundle(const struct asm_bundle *b, uint64_t ip)
{
	asm_print_inst(b, 0, ip);
	asm_print_inst(b, 1, ip);
	asm_print_inst(b, 2, ip);
}

void
asm_print_inst(const struct asm_bundle *b, int slot, uint64_t ip)
{
	char buf[32];
	const struct asm_inst *i;
	const char *tmpl;
	int n, w;

	tmpl = b->b_templ + slot;
	if (*tmpl == ';' || (slot == 2 && b->b_templ[1] == ';'))
		tmpl++;
	i = b->b_inst + slot;
	if (*tmpl == 'L' || i->i_op == ASM_OP_NONE)
		return;

	/* Address + slot. */
	printf("%lx[%c] ", ip + slot, *tmpl);

	/* Predicate. */
	if (i->i_oper[0].o_value != 0) {
		asm_operand(i->i_oper+0, buf, ip);
		w = printf("(%s)", buf);
	} else
		w = 0;
	while (w++ < 8)
		printf(" ");

	/* Mnemonic & completers. */
	asm_mnemonic(i->i_op, buf);
	w = printf(buf);
	n = 0;
	while (n < i->i_ncmpltrs) {
		asm_completer(i->i_cmpltr + n, buf);
		w += printf(buf);
		n++;
	}
	while (w++ < 15)
		printf(" ");
	printf(" ");

	/* Operands. */
	n = 1;
	while (n < 7 && i->i_oper[n].o_type != ASM_OPER_NONE) {
		if (n > 1) {
			if (n == i->i_srcidx)
				printf(" = ");
			else
				printf(", ");
		}
		asm_operand(i->i_oper + n, buf, ip);
		printf(buf);
		n++;
	}
	printf("\n");
}