[unix-history] / usr / src / old / adb / adb.vax / print.c

static	char sccsid[] = "@(#)print.c 4.5 %G%";
/*
 *
 *	UNIX debugger
 *
 */
#include "defs.h"

MSG		LONGFIL;
MSG		NOTOPEN;
MSG		A68BAD;
MSG		A68LNK;
MSG		BADMOD;

MAP		txtmap;
MAP		datmap;

ADDR		lastframe;
ADDR		callpc;

INT		infile;
INT		outfile;
CHAR		*lp;
L_INT		maxoff;
L_INT		maxpos;
INT		radix;

/* symbol management */
L_INT		localval;

/* breakpoints */
BKPTR		bkpthead;

REGLIST reglist [] = {
	"p1lr",	P1LR,	&pcb.pcb_p1lr,
	"p1br",	P1BR,	&pcb.pcb_p1br,
	"p0lr",	P0LR,	&pcb.pcb_p0lr,
	"p0br",	P0BR,	&pcb.pcb_p0br,
	"ksp",	KSP,	&pcb.pcb_ksp,
	"esp",	ESP,	&pcb.pcb_esp,
	"ssp",	SSP,	&pcb.pcb_ssp,
	"psl",	PSL,	&pcb.pcb_psl,
	"pc",	PC,	&pcb.pcb_pc,
	"usp",	USP,	&pcb.pcb_usp,
	"fp",	FP,	&pcb.pcb_fp,
	"ap",	AP,	&pcb.pcb_ap,
	"r11",	R11,	&pcb.pcb_r11,
	"r10",	R10,	&pcb.pcb_r10,
	"r9",	R9,	&pcb.pcb_r9,
	"r8",	R8,	&pcb.pcb_r8,
	"r7",	R7,	&pcb.pcb_r7,
	"r6",	R6,	&pcb.pcb_r6,
	"r5",	R5,	&pcb.pcb_r5,
	"r4",	R4,	&pcb.pcb_r4,
	"r3",	R3,	&pcb.pcb_r3,
	"r2",	R2,	&pcb.pcb_r2,
	"r1",	R1,	&pcb.pcb_r1,
	"r0",	R0,	&pcb.pcb_r0,
};

char		lastc;

INT		fcor;
STRING		errflg;
INT		signo;
INT		sigcode;


L_INT		dot;
L_INT		var[];
STRING		symfil;
STRING		corfil;
INT		pid;
L_INT		adrval;
INT		adrflg;
L_INT		cntval;
INT		cntflg;

STRING		signals[] = {
		"",
		"hangup",
		"interrupt",
		"quit",
		"illegal instruction",
		"trace/BPT",
		"IOT",
		"EMT",
		"floating exception",
		"killed",
		"bus error",
		"memory fault",
		"bad system call",
		"broken pipe",
		"alarm call",
		"terminated",
		"signal 16",
		"stop (signal)",
		"stop (tty)",
		"continue (signal)",
		"child termination",
		"stop (tty input)",
		"stop (tty output)",
		"input available (signal)",
		"cpu timelimit",
		"file sizelimit",
		"signal 26",
		"signal 27",
		"signal 28",
		"signal 29",
		"signal 30",
		"signal 31",
};

/* general printing routines ($) */

printtrace(modif)
{
	INT		narg, i, stat, name, limit;
	POS		dynam;
	REG BKPTR	bkptr;
	CHAR		hi, lo;
	ADDR		word;
	STRING		comptr;
	ADDR		argp, frame, link;
	register struct nlist *sp;
	INT		stack;
	INT		ntramp;

	IF cntflg==0 THEN cntval = -1; FI

	switch (modif) {

	    case '<':
		IF cntval == 0
		THEN	WHILE readchar() != EOR
			DO OD
			lp--;
			break;
		FI
		IF rdc() == '<'
		THEN	stack = 1;
		ELSE	stack = 0; lp--;
		FI
							/* fall through */
	    case '>':
		{CHAR		file[64];
		CHAR		Ifile[128];
		extern CHAR	*Ipath;
		INT		index;

		index=0;
		IF rdc()!=EOR
		THEN	REP file[index++]=lastc;
			    IF index>=63 THEN error(LONGFIL); FI
			PER readchar()!=EOR DONE
			file[index]=0;
			IF modif=='<'
			THEN	IF Ipath THEN
					strcpy(Ifile, Ipath);
					strcat(Ifile, "/");
					strcat(Ifile, file);
				FI
				IF strcmp(file, "-")!=0
				THEN	iclose(stack, 0);
					infile=open(file,0);
					IF infile<0
					THEN	infile=open(Ifile,0);
					FI
				ELSE	lseek(infile, 0L, 0);
				FI
				IF infile<0
				THEN	infile=0; error(NOTOPEN);
				ELSE	IF cntflg
					THEN	var[9] = cntval;
					ELSE	var[9] = 1;
					FI
				FI
			ELSE	oclose();
				outfile=open(file,1);
				IF outfile<0
				THEN	outfile=creat(file,0644);
#ifndef EDDT
				ELSE	lseek(outfile,0L,2);
#endif
				FI
			FI

		ELSE	IF modif == '<'
			THEN	iclose(-1, 0);
			ELSE	oclose();
			FI
		FI
		lp--;
		}
		break;

	    case 'p':
		IF kernel == 0 THEN
			printf("not debugging kernel\n");
		ELSE
			IF adrflg THEN
				int pte = access(RD, dot, DSP, 0);
				masterpcbb = (pte&PG_PFNUM)*512;
			FI
			getpcb();
		FI
		break;

	    case 'd':
		if (adrflg) {
			if (adrval<2 || adrval>16) {printf("must have 2 <= radix <= 16"); break;}
			printf("radix=%d base ten",radix=adrval);
		}
		break;

	    case 'q': case 'Q': case '%':
		done();

	    case 'w': case 'W':
		maxpos=(adrflg?adrval:MAXPOS);
		break;

	    case 's': case 'S':
		maxoff=(adrflg?adrval:MAXOFF);
		break;

	    case 'v': case 'V':
		prints("variables\n");
		FOR i=0;i<=35;i++
		DO IF var[i]
		   THEN printc((i<=9 ? '0' : 'a'-10) + i);
			printf(" = %X\n",var[i]);
		   FI
		OD
		break;

	    case 'm': case 'M':
		printmap("? map",&txtmap);
		printmap("/ map",&datmap);
		break;

	    case 0: case '?':
		IF pid
		THEN printf("pcs id = %d\n",pid);
		ELSE prints("no process\n");
		FI
		sigprint(); flushbuf();

	    case 'r': case 'R':
		printregs();
		return;

	    case 'c': case 'C':
		IF adrflg
		THEN frame=adrval;
			word=get(adrval+6,DSP)&0xFFFF;
			IF word&0x2000
			THEN /* 'calls', can figure out argp */
				argp=adrval+20+((word>>14)&3); word &= 0xFFF;
				WHILE word DO IF word&1 THEN argp+=4; FI word>>=1; OD
			ELSE /* 'callg', can't tell where argp is */ argp=frame;
			FI
			callpc=get(frame+16,DSP);
		ELIF kcore THEN
			argp = pcb.pcb_ap;
			frame = pcb.pcb_fp;
			callpc = pcb.pcb_pc;
		ELSE	argp= *(ADDR *)(((ADDR)&u)+AP);
			frame= *(ADDR *)(((ADDR)&u)+FP);
			callpc= *(ADDR *)(((ADDR)&u)+PC);
		FI
		lastframe=0;
		ntramp = 0;
		WHILE cntval--
		DO	char *name;
			chkerr();
			if (callpc > 0x80000000 - 0x200 * UPAGES) {
				name = "sigtramp";
				ntramp++;
			} else {
				ntramp = 0;
				findsym(callpc,ISYM);
				if (cursym &&
				    !strcmp(cursym->n_un.n_name, "start")) 
					break;
				if (cursym)
					name = cursym->n_un.n_name;
				else
					name = "?";
			}
			printf("%s(", name);
			narg = get(argp,DSP); IF narg&~0xFF THEN narg=0; FI
			LOOP IF narg==0 THEN break; FI
				printf("%R", get(argp += 4, DSP));
				IF --narg!=0 THEN printc(','); FI
			POOL
			printf(") from %X\n",callpc);  /* jkf mod */

			IF modif=='C'
			THEN WHILE localsym(frame,argp)
			     DO word=get(localval,DSP);
				printf("%8t%s:%10t", cursym->n_un.n_name);
				IF errflg THEN prints("?\n"); errflg=0; ELSE printf("%R\n",word); FI
			     OD
			FI

			if (ntramp == 1)
				callpc=get(frame+64, DSP);
			else
				callpc=get(frame+16, DSP);
			argp=get(frame+8, DSP);
			lastframe=frame;
			frame=get(frame+12, DSP)&EVEN;
			IF frame==0 ORF (!adrflg ANDF !INSTACK(frame))
			THEN break;
			FI
		OD
		break;

	    /*print externals*/
	    case 'e': case 'E':
		for (sp = symtab; sp < esymtab; sp++) {
		   if (sp->n_type==(N_DATA|N_EXT) ORF sp->n_type==(N_BSS|N_EXT))
		   	printf("%s:%12t%R\n", sp->n_un.n_name, get(sp->n_value,DSP));
		}
		break;

	    case 'a': case 'A':
		error("No algol 68 on VAX");
		/*NOTREACHED*/

	    /*print breakpoints*/
	    case 'b': case 'B':
		printf("breakpoints\ncount%8tbkpt%24tcommand\n");
		for (bkptr=bkpthead; bkptr; bkptr=bkptr->nxtbkpt)
			if (bkptr->flag) {
		   		printf("%-8.8d",bkptr->count);
				psymoff(leng(bkptr->loc),ISYM,"%24t");
				comptr=bkptr->comm;
				WHILE *comptr DO printc(*comptr++); OD
			}
		break;

	    default: error(BADMOD);
	}

}

printmap(s,amap)
STRING	s; MAP *amap;
{
	int file;
	file=amap->ufd;
	printf("%s%12t`%s'\n",s,(file<0 ? "-" : (file==fcor ? corfil : symfil)));
	printf("b1 = %-16R",amap->b1);
	printf("e1 = %-16R",amap->e1);
	printf("f1 = %-16R",amap->f1);
	printf("\nb2 = %-16R",amap->b2);
	printf("e2 = %-16R",amap->e2);
	printf("f2 = %-16R",amap->f2);
	printc(EOR);
}

printregs()
{
	REG REGPTR	p;
	L_INT		v;

	FOR p=reglist; p < &reglist[24]; p++
	DO	v = kcore ? *p->rkern : *(ADDR *)(((ADDR)&u)+p->roffs);
		printf("%s%6t%R %16t", p->rname, v);
		valpr(v,(p->roffs==PC?ISYM:DSYM));
		printc(EOR);
	OD
	printpc();
}

getreg(regnam) {
	REG REGPTR	p;
	REG STRING	regptr;
	CHAR	*olp;
	CHAR		regnxt;

	olp=lp;
	FOR p=reglist; p < &reglist[24]; p++
	DO	regptr=p->rname;
		IF (regnam == *regptr++)
		THEN
			WHILE *regptr
			DO IF (regnxt=readchar()) != *regptr++
				THEN --regptr; break;
				FI
			OD
			IF *regptr
			THEN lp=olp;
			ELSE
				int i = kcore ? (int)p->rkern : p->roffs;
				return (i);
			FI
		FI
	OD
	lp=olp;
	return(0);
}

printpc()
{
	dot= *(ADDR *)(((ADDR)&u)+PC);
	psymoff(dot,ISYM,":%16t"); printins(0,ISP,chkget(dot,ISP));
	printc(EOR);
}

char	*illinames[] = {
	"reserved addressing fault",
	"priviliged instruction fault",
	"reserved operand fault"
};
char	*fpenames[] = {
	0,
	"integer overflow trap",
	"integer divide by zero trap",
	"floating overflow trap",
	"floating/decimal divide by zero trap",
	"floating underflow trap",
	"decimal overflow trap",
	"subscript out of range trap",
	"floating overflow fault",
	"floating divide by zero fault",
	"floating undeflow fault"
};

sigprint()
{
	IF (signo>=0) ANDF (signo<sizeof signals/sizeof signals[0])
	THEN prints(signals[signo]); FI
	switch (signo) {

	case SIGFPE:
		IF (sigcode > 0 &&
		    sigcode < sizeof fpenames / sizeof fpenames[0]) THEN
			prints(" ("); prints(fpenames[sigcode]); prints(")");
		FI
		break;

	case SIGILL:
		IF (sigcode >= 0 &&
		    sigcode < sizeof illinames / sizeof illinames[0]) THEN
			prints(" ("); prints(illinames[sigcode]); prints(")");
		FI
		break;
	}
}
Commit	Line	Data
e1da0be5	1	static char sccsid[] = "@(#)print.c 4.5 %G%";
81f0c5ba BJ	2	/*
	3	*
	4	* UNIX debugger
	5	*
	6	*/
	7	#include "defs.h"
	8
	9	MSG LONGFIL;
	10	MSG NOTOPEN;
	11	MSG A68BAD;
	12	MSG A68LNK;
	13	MSG BADMOD;
	14
	15	MAP txtmap;
	16	MAP datmap;
	17
	18	ADDR lastframe;
	19	ADDR callpc;
	20
	21	INT infile;
	22	INT outfile;
	23	CHAR *lp;
	24	L_INT maxoff;
	25	L_INT maxpos;
	26	INT radix;
	27
	28	/* symbol management */
	29	L_INT localval;
	30
	31	/* breakpoints */
	32	BKPTR bkpthead;
	33
	34	REGLIST reglist [] = {
6eadceb1 BJ	35	"p1lr", P1LR, &pcb.pcb_p1lr,
	36	"p1br", P1BR, &pcb.pcb_p1br,
	37	"p0lr", P0LR, &pcb.pcb_p0lr,
	38	"p0br", P0BR, &pcb.pcb_p0br,
	39	"ksp", KSP, &pcb.pcb_ksp,
	40	"esp", ESP, &pcb.pcb_esp,
	41	"ssp", SSP, &pcb.pcb_ssp,
	42	"psl", PSL, &pcb.pcb_psl,
	43	"pc", PC, &pcb.pcb_pc,
	44	"usp", USP, &pcb.pcb_usp,
	45	"fp", FP, &pcb.pcb_fp,
	46	"ap", AP, &pcb.pcb_ap,
	47	"r11", R11, &pcb.pcb_r11,
	48	"r10", R10, &pcb.pcb_r10,
	49	"r9", R9, &pcb.pcb_r9,
	50	"r8", R8, &pcb.pcb_r8,
	51	"r7", R7, &pcb.pcb_r7,
	52	"r6", R6, &pcb.pcb_r6,
	53	"r5", R5, &pcb.pcb_r5,
	54	"r4", R4, &pcb.pcb_r4,
	55	"r3", R3, &pcb.pcb_r3,
	56	"r2", R2, &pcb.pcb_r2,
	57	"r1", R1, &pcb.pcb_r1,
	58	"r0", R0, &pcb.pcb_r0,
81f0c5ba BJ	59	};
	60
	61	char lastc;
	62
	63	INT fcor;
	64	STRING errflg;
	65	INT signo;
	66	INT sigcode;
	67
	68
	69	L_INT dot;
	70	L_INT var[];
	71	STRING symfil;
	72	STRING corfil;
	73	INT pid;
	74	L_INT adrval;
	75	INT adrflg;
	76	L_INT cntval;
	77	INT cntflg;
	78
	79	STRING signals[] = {
	80	"",
	81	"hangup",
	82	"interrupt",
	83	"quit",
	84	"illegal instruction",
	85	"trace/BPT",
	86	"IOT",
	87	"EMT",
	88	"floating exception",
	89	"killed",
	90	"bus error",
	91	"memory fault",
	92	"bad system call",
	93	"broken pipe",
	94	"alarm call",
	95	"terminated",
	96	"signal 16",
	97	"stop (signal)",
	98	"stop (tty)",
	99	"continue (signal)",
	100	"child termination",
	101	"stop (tty input)",
	102	"stop (tty output)",
	103	"input available (signal)",
	104	"cpu timelimit",
	105	"file sizelimit",
	106	"signal 26",
	107	"signal 27",
	108	"signal 28",
	109	"signal 29",
	110	"signal 30",
	111	"signal 31",
	112	};
	113
	114	/* general printing routines ($) */
	115
	116	printtrace(modif)
	117	{
	118	INT narg, i, stat, name, limit;
	119	POS dynam;
	120	REG BKPTR bkptr;
	121	CHAR hi, lo;
	122	ADDR word;
123	STRING comptr;
124	ADDR argp, frame, link;
125	register struct nlist *sp;
126	INT stack;
127	INT ntramp;
128
129	IF cntflg==0 THEN cntval = -1; FI
130
131	switch (modif) {
132
133	case '<':
134	IF cntval == 0
135	THEN WHILE readchar() != EOR
136	DO OD
137	lp--;
138	break;
139	FI
140	IF rdc() == '<'
141	THEN stack = 1;
142	ELSE stack = 0; lp--;
143	FI
144	/* fall through */
145	case '>':
146	{CHAR file[64];
147	CHAR Ifile[128];
148	extern CHAR *Ipath;
149	INT index;
150
151	index=0;
81f0c5ba BJ	152	IF rdc()!=EOR
	153	THEN REP file[index++]=lastc;
	154	IF index>=63 THEN error(LONGFIL); FI
	155	PER readchar()!=EOR DONE
	156	file[index]=0;
	157	IF modif=='<'
	158	THEN IF Ipath THEN
	159	strcpy(Ifile, Ipath);
	160	strcat(Ifile, "/");
	161	strcat(Ifile, file);
	162	FI
e1da0be5 RE	163	IF strcmp(file, "-")!=0
	164	THEN iclose(stack, 0);
	165	infile=open(file,0);
	166	IF infile<0
	167	THEN infile=open(Ifile,0);
	168	FI
	169	ELSE lseek(infile, 0L, 0);
	170	FI
	171	IF infile<0
81f0c5ba BJ	172	THEN infile=0; error(NOTOPEN);
	173	ELSE IF cntflg
	174	THEN var[9] = cntval;
	175	ELSE var[9] = 1;
	176	FI
	177	FI
e1da0be5 RE	178	ELSE oclose();
e1da0be5 RE	179	outfile=open(file,1);
81f0c5ba BJ	180	IF outfile<0
	181	THEN outfile=creat(file,0644);
	182	#ifndef EDDT
	183	ELSE lseek(outfile,0L,2);
	184	#endif
	185	FI
	186	FI
	187
	188	ELSE IF modif == '<'
	189	THEN iclose(-1, 0);
e1da0be5	190	ELSE oclose();
81f0c5ba BJ	191	FI
	192	FI
	193	lp--;
	194	}
	195	break;
	196
128eca8b BJ	197	case 'p':
	198	IF kernel == 0 THEN
	199	printf("not debugging kernel\n");
	200	ELSE
	201	IF adrflg THEN
	202	int pte = access(RD, dot, DSP, 0);
	203	masterpcbb = (pte&PG_PFNUM)*512;
	204	FI
	205	getpcb();
	206	FI
	207	break;
	208
81f0c5ba BJ	209	case 'd':
	210	if (adrflg) {
	211	if (adrval<2 \|\| adrval>16) {printf("must have 2 <= radix <= 16"); break;}
	212	printf("radix=%d base ten",radix=adrval);
	213	}
	214	break;
	215
	216	case 'q': case 'Q': case '%':
	217	done();
	218
	219	case 'w': case 'W':
	220	maxpos=(adrflg?adrval:MAXPOS);
	221	break;
	222
	223	case 's': case 'S':
	224	maxoff=(adrflg?adrval:MAXOFF);
	225	break;
	226
	227	case 'v': case 'V':
	228	prints("variables\n");
	229	FOR i=0;i<=35;i++
	230	DO IF var[i]
	231	THEN printc((i<=9 ? '0' : 'a'-10) + i);
e1da0be5	232	printf(" = %X\n",var[i]);
81f0c5ba BJ	233	FI
	234	OD
	235	break;
	236
	237	case 'm': case 'M':
	238	printmap("? map",&txtmap);
	239	printmap("/ map",&datmap);
	240	break;
	241
	242	case 0: case '?':
	243	IF pid
	244	THEN printf("pcs id = %d\n",pid);
	245	ELSE prints("no process\n");
	246	FI
	247	sigprint(); flushbuf();
	248
	249	case 'r': case 'R':
	250	printregs();
	251	return;
	252
	253	case 'c': case 'C':
	254	IF adrflg
	255	THEN frame=adrval;
	256	word=get(adrval+6,DSP)&0xFFFF;
	257	IF word&0x2000
	258	THEN /* 'calls', can figure out argp */
	259	argp=adrval+20+((word>>14)&3); word &= 0xFFF;
	260	WHILE word DO IF word&1 THEN argp+=4; FI word>>=1; OD
	261	ELSE /* 'callg', can't tell where argp is */ argp=frame;
	262	FI
	263	callpc=get(frame+16,DSP);
128eca8b BJ	264	ELIF kcore THEN
	265	argp = pcb.pcb_ap;
	266	frame = pcb.pcb_fp;
	267	callpc = pcb.pcb_pc;
	268	ELSE argp= (ADDR )(((ADDR)&u)+AP);
81f0c5ba BJ	269	frame= (ADDR )(((ADDR)&u)+FP);
	270	callpc= (ADDR )(((ADDR)&u)+PC);
	271	FI
	272	lastframe=0;
	273	ntramp = 0;
	274	WHILE cntval--
	275	DO char *name;
	276	chkerr();
	277	if (callpc > 0x80000000 - 0x200 * UPAGES) {
	278	name = "sigtramp";
	279	ntramp++;
	280	} else {
	281	ntramp = 0;
	282	findsym(callpc,ISYM);
	283	if (cursym &&
e1da0be5	284	!strcmp(cursym->n_un.n_name, "start"))
81f0c5ba BJ	285	break;
	286	if (cursym)
	287	name = cursym->n_un.n_name;
	288	else
	289	name = "?";
	290	}
	291	printf("%s(", name);
	292	narg = get(argp,DSP); IF narg&~0xFF THEN narg=0; FI
	293	LOOP IF narg==0 THEN break; FI
	294	printf("%R", get(argp += 4, DSP));
	295	IF --narg!=0 THEN printc(','); FI
	296	POOL
	297	printf(") from %X\n",callpc); /* jkf mod */
	298
	299	IF modif=='C'
	300	THEN WHILE localsym(frame,argp)
	301	DO word=get(localval,DSP);
	302	printf("%8t%s:%10t", cursym->n_un.n_name);
	303	IF errflg THEN prints("?\n"); errflg=0; ELSE printf("%R\n",word); FI
	304	OD
	305	FI
	306
	307	if (ntramp == 1)
	308	callpc=get(frame+64, DSP);
	309	else
	310	callpc=get(frame+16, DSP);
	311	argp=get(frame+8, DSP);
	312	lastframe=frame;
	313	frame=get(frame+12, DSP)&EVEN;
	314	IF frame==0 ORF (!adrflg ANDF !INSTACK(frame))
	315	THEN break;
	316	FI
	317	OD
	318	break;
	319
	320	/print externals/
	321	case 'e': case 'E':
	322	for (sp = symtab; sp < esymtab; sp++) {
	323	if (sp->n_type==(N_DATA\|N_EXT) ORF sp->n_type==(N_BSS\|N_EXT))
	324	printf("%s:%12t%R\n", sp->n_un.n_name, get(sp->n_value,DSP));
	325	}
	326	break;
	327
	328	case 'a': case 'A':
	329	error("No algol 68 on VAX");
	330	/NOTREACHED/
	331
	332	/print breakpoints/
	333	case 'b': case 'B':
	334	printf("breakpoints\ncount%8tbkpt%24tcommand\n");
	335	for (bkptr=bkpthead; bkptr; bkptr=bkptr->nxtbkpt)
	336	if (bkptr->flag) {
	337	printf("%-8.8d",bkptr->count);
	338	psymoff(leng(bkptr->loc),ISYM,"%24t");
	339	comptr=bkptr->comm;
	340	WHILE comptr DO printc(comptr++); OD
	341	}
	342	break;
	343
	344	default: error(BADMOD);
	345	}
	346
	347	}
	348
349	printmap(s,amap)
350	STRING s; MAP *amap;
351	{
352	int file;
353	file=amap->ufd;
354	printf("%s%12t`%s'\n",s,(file<0 ? "-" : (file==fcor ? corfil : symfil)));
355	printf("b1 = %-16R",amap->b1);
356	printf("e1 = %-16R",amap->e1);
357	printf("f1 = %-16R",amap->f1);
358	printf("\nb2 = %-16R",amap->b2);
359	printf("e2 = %-16R",amap->e2);
360	printf("f2 = %-16R",amap->f2);
361	printc(EOR);
362	}
363
364	printregs()
365	{
366	REG REGPTR p;
367	L_INT v;
368
369	FOR p=reglist; p < &reglist[24]; p++
6eadceb1 BJ	370	DO v = kcore ? p->rkern : (ADDR *)(((ADDR)&u)+p->roffs);
6eadceb1 BJ	371	printf("%s%6t%R %16t", p->rname, v);
81f0c5ba BJ	372	valpr(v,(p->roffs==PC?ISYM:DSYM));
	373	printc(EOR);
	374	OD
	375	printpc();
	376	}
	377
6eadceb1	378	getreg(regnam) {
81f0c5ba BJ	379	REG REGPTR p;
	380	REG STRING regptr;
	381	CHAR *olp;
	382	CHAR regnxt;
	383
	384	olp=lp;
	385	FOR p=reglist; p < &reglist[24]; p++
	386	DO regptr=p->rname;
	387	IF (regnam == *regptr++)
	388	THEN
	389	WHILE *regptr
	390	DO IF (regnxt=readchar()) != *regptr++
	391	THEN --regptr; break;
	392	FI
	393	OD
	394	IF *regptr
	395	THEN lp=olp;
6d4468aa BJ	396	ELSE
6d4468aa BJ	397	int i = kcore ? (int)p->rkern : p->roffs;
6d4468aa	398	return (i);
81f0c5ba BJ	399	FI
	400	FI
	401	OD
	402	lp=olp;
	403	return(0);
	404	}
	405
	406	printpc()
	407	{
	408	dot= (ADDR )(((ADDR)&u)+PC);
	409	psymoff(dot,ISYM,":%16t"); printins(0,ISP,chkget(dot,ISP));
	410	printc(EOR);
	411	}
	412
	413	char *illinames[] = {
	414	"reserved addressing fault",
	415	"priviliged instruction fault",
	416	"reserved operand fault"
	417	};
	418	char *fpenames[] = {
	419	0,
	420	"integer overflow trap",
	421	"integer divide by zero trap",
	422	"floating overflow trap",
	423	"floating/decimal divide by zero trap",
	424	"floating underflow trap",
	425	"decimal overflow trap",
	426	"subscript out of range trap",
	427	"floating overflow fault",
	428	"floating divide by zero fault",
	429	"floating undeflow fault"
	430	};
	431
	432	sigprint()
	433	{
	434	IF (signo>=0) ANDF (signo<sizeof signals/sizeof signals[0])
	435	THEN prints(signals[signo]); FI
	436	switch (signo) {
	437
	438	case SIGFPE:
	439	IF (sigcode > 0 &&
	440	sigcode < sizeof fpenames / sizeof fpenames[0]) THEN
	441	prints(" ("); prints(fpenames[sigcode]); prints(")");
	442	FI
	443	break;
	444
	445	case SIGILL:
	446	IF (sigcode >= 0 &&
	447	sigcode < sizeof illinames / sizeof illinames[0]) THEN
	448	prints(" ("); prints(illinames[sigcode]); prints(")");
	449	FI
	450	break;
	451	}
	452	}