Ausam/sys/sysd/source/proc4.c

/* file for cdb etc */

#include "proc.h"

#define	DSP	0
#define	ISP	1
#define	TRACEWARN	30
#define	TRACETERM	50
int	symoff;
int	errflg;
int	symlen;
int	symcnt;
struct symbol	*symbuf;
int	*alpha;
int	*numeric;

#ifndef	BIG_UNIX
stackdecode(r5, r6, ka6)
#endif
#ifdef	BIG_UNIX
stackdecode(r5, r6, aka5, ka6)
#endif
int	r5, r6;
#ifdef	BIG_UNIX
int	aka5;
#endif
int	ka6;
{
	unsigned int	i, j;
	unsigned int	rr5, rr6;
	int	nxtrr5;
	int	intrpt;
	int	callev, narg, argp;
	int	lcls;
	int	inst, adr, callpt;
	struct symbol	*ss;
	struct sybmol	*indss;
	int	callmode;
	int	oldpc;
#ifdef	BIG_UNIX
	int	ka5, nxtka5;
	int	knarg;
	int	paged;
#endif

	printf(S_PTAB, "Stack trace - last called routines appear first\n\n");
	printf(S_PTAB, "Calling routine ( arguments )\n");
	printf(SS_PTAB, "local variables - if any\n\n");

	DEBUG
		printf("stackdecode called with r5=%u (%o), r6=%u (%o), ka6=%u (%o)\n",
			r5, r5, r6, r6, ka6, ka6);

	rr5 = r5;
	rr6 = r6;
#ifdef	BIG_UNIX
	ka5 = aka5;
#endif
	callev = 0;
	errflg = 0;
	oldpc = 0;

	do {
		if (u.u_qsav[1] == rr5)
			printf(S_PTAB, "  <------ u.u_qsav\n");
		if (u.u_ssav[1] == rr5)
			printf(S_PTAB, "  <------ u.u_ssav\n");

		nxtrr5 = get(rr5, DSP, ka6);
		callpt = get(rr5+2, DSP, ka6);
#ifdef	BIG_UNIX
		inst = get(callpt-4, ISP, ka5);
		adr = get(callpt-2, ISP, ka5);
#endif	BIG_UNIX
#ifndef	BIG_UNIX
		inst = get(callpt-4, ISP, txtoff);
		adr = get(callpt-2, ISP, txtoff);
#endif	BIG_UNIX

#ifdef	BIG_UNIX
		paged = 0;
		nxtka5 = ka5;
		if (adr==04730 && inst==KISA5) {
			/* paged kernel transfer */
			paged++;
			printf(S_PTAB, "\t     V\b+--- paged transfer\n");
			inst = get(callpt, ISP, ka5);
			if (inst == 012637)		/* mov (sp)+,*$... */
				knarg = 0;
			else if (inst == 05726)		/* tst (sp)+ */
				knarg = 1;
			else if (inst == 022626) {
				/* cmp (sp)+,(sp)+ */
				inst = get(callpt+8, ISP, ka5);
				if (inst == 011607)	/* mov (sp),pc */
					knarg = 2;
				else
					knarg = (get(callpt+10, ISP, ka5) + 4)/2;
			} else {
				errflg++;
				break;
			}
			callpt = get(rr5+4+(knarg==0 ? 2 : knarg*2), DSP, ka6);
			nxtka5 = get(rr5+4+(knarg==0 ? 0 : (knarg+1)*2), DSP, ka6);
			inst = get(callpt-4, ISP, nxtka5);
			adr = get(callpt-2, ISP, nxtka5);
		}
#endif
		intrpt = 0;
		DEBUG
			printf("stackdecode first test ins=%u (%o), adr=%u (%o), callpt=%u (%o), txtoff=%u (%o)\n",
				inst, inst, adr, adr, callpt, callpt, txtoff, txtoff);
		if (adr == 04730) {
			/* jsr pc,*(r0)+ */
			intrpt++;
#ifdef	BIG_UNIX
			narg = paged ? knarg : 7;
#endif	BIG_UNIX
#ifndef	BIG_UNIX
			narg = 7;
#endif	BIG_UNIX
			adr = oldpc;
		} else {
			if (inst == 04737)			/* jsr pc,*$... */
				narg = 1;
			else if ((inst & ~077) == 04700)	/* jsr pc,... */
				narg = 0;
			else {
				errflg++;
				break;
			}

			callmode = 0;
			if (inst == 04767)		/* jsr pc,... */
				adr =+ callpt;
			else if (inst == 04777) {
				/* jsr pc,*... */
				callmode = 1;
				adr =+ callpt;
#ifdef	BIG_UNIX
				indss = vallook(adr, nxtka5);
#endif	BIG_UNIX
#ifndef	BIG_UNIX
				indss = vallook(adr);
#endif	BIG_UNIX
				adr = get(adr, DSP, ka6);
			} else if (inst == 04775) {
				/* jsr pc,*...(r5) */
				callmode = 2;
				adr = get(adr+nxtrr5, DSP, ka6);
			} else if ((inst & ~07) == 04770) {
				/* jsr pc,*...(?) */
				callmode = 3;
				adr = oldpc;
			}
#ifdef	BIG_UNIX
			if (paged && callmode<3) {
				i = get(adr+4, ISP, ka5);
				if (i != ka5)
					printf(S_PTAB, "-->ka5 discrepancy; vector=%o; stack=%o\n", i, ka5);
				adr = get(adr+6, ISP, ka5);
			}
			inst = get(callpt, ISP, nxtka5);
#endif	BIG_UNIX
#ifndef	BIG_UNIX
			inst = get(callpt, ISP, txtoff);
#endif	BIG_UNIX
			if (inst == 05726)		/* tst (sp)+ */
				narg++;
			else if (inst == 022626)	/* cmp (sp)+,(sp)+ */
				narg =+ 2;
			else if (inst == 062706)	/* add $n,sp */
#ifndef	BIG_UNIX
				narg =+ get(callpt+2, ISP, txtoff)/2;
#endif	BIG_UNIX
#ifdef	BIG_UNIX
				narg =+ get(callpt+2, ISP, nxtka5)/2;
			if (paged && knarg!=narg) {
				printf(S_PTAB, " difference in paged argument count and real argument count\n");
				printf(S_PTAB, "  real = %d.; paged = %d.\n", narg, knarg);
				printf(S_PTAB, " paged count shall be used\n");
				narg = knarg;
			}
#endif	BIG_UNIX
		}

		DEBUG
			printf("narg=%u (%o), rr5=%u (%o)\n", narg, narg, rr5, rr5);


		/*
		 * print call and arguments
		 */
#ifdef	BIG_UNIX
		ss = vallook(adr, ka5);
#endif	BIG_UNIX
#ifndef	BIG_UNIX
		ss = vallook(adr);
#endif	BIG_UNIX
		printf(S_PTAB, "%2d: %8.8s (", callev, ss->s_symbol);
		for (i = 0; i < narg; i++) {
			if (i > 0)
				printf(", ");
			printf("%.1o", get(rr5+4 + 2*i, DSP, ka6));
		}
		switch (callmode) {

		case 0:
			printf(")\n");
			break;

		case 1:
			printf(") indirect call via %8.8s\n", indss->s_symbol);
			break;

		case 2:
			printf(") called via higher arg list\n");
			break;

		case 3:
			printf(") called via array\n");
			adr = ss->s_symval;
			break;
		}

		/*
		 * list locals to called routine
		 */
		lcls = 0;
#ifdef	BIG_UNIX
		if (get(adr, ISP, ka5) == 04567) {
			/* jsr r5,csv */
			inst = get(adr+4, ISP, ka5);
			if (inst == 05746)		/* tst -(sp) */
				lcls = 1;
			else if (inst == 0162706)	/* sub $n,sp */
				lcls = get(adr+6, ISP, ka5) / 2;
		}
#endif	BIG=UNIX
#ifndef	BIG_UNIX
		if (get(adr, ISP, txtoff) == 04567) {
			/* jsr r5,csv */
			inst = get(adr+4, ISP, txtoff);
			if (inst == 05746)		/* tst -(sp) */
				lcls = 1;
			else if (inst == 0162706)	/* sub $n,sp */
				lcls = get(adr+6, ISP, txtoff) / 2;
		}
#endif	BIG_UNIX
		if (lcls > 0) {
			printf(SS_PTAB, "{");
			for (i = 0; i < lcls; i++) {
				if (i > 0)
					printf(", ");
				printf("%.1o", get(rr5-6 - 2*i, DSP, ka6));
			}
			printf("}\n");
		}
		printf(SS_PTAB, "%60tsaved registers:");
		for (i = 2; i <= 5; i++) {
			j = get(rr5 + (i - 5)*2, DSP, ka6);
			if (!(i & 1))
				printf("%78t");
			printf(" r%d = %u (%o);", i, j, j);
			if (i & 1)
				printf("\n");
		}

		if (callev == TRACEWARN)
			WARNING
				warn("stack trace level rather large!");
		if (callev++ == TRACETERM) {
			WARNING
				warn("stack trace looping - terminated!");
			errflg++;
		}

#ifdef	BIG_UNIX
		if (paged)
			ka5 = nxtka5;
#endif	BIG_UNIX
		if (intrpt) {
			i = rr5 + 14 + 4;
#ifdef	BIG_UNIX
			if (paged)
				i =+ 4;
#endif	BIG_UNIX
			if (i >= USERADR+04000)
				break;
		} else {
			if (rr5+4 >= USERADR+04000)
				break;
		}
		rr5 = nxtrr5;
		if (rr5 >= USERADR+04000)
			break;
		oldpc = callpt;

		if (rr5 >= USERADR+04000)
			break;
		DEBUG
			printf("at end of loop new rr5=%u (%o)\n", rr5, rr5);
	} while (!errflg);

	printf("\n\n");
}

/***********************/

get(adr, space, ka56)
unsigned adr;
int	space;
int	ka56;
{
	long	bign;
	int	word;

	DEBUG
		printf("get passed adr=%u (%o), space=%u (%o), ka56=%u (%o)\n", adr, adr, space, space, ka56, ka56);

	bign = ka56.unsign;
	bign =<< 6;	/* 64 bytes/block */
	if (space == DSP) {
		lseek(corefd, bign, 0);
		seek(corefd, adr - USERADR, 1);
	} else {
#ifdef	BIG_UNIX
		if (adr >= PAGEADR) {
			lseek(corefd, bign, 0);
			seek(corefd, adr - PAGEADR, 1);
		} else
#endif	BIG_UNIX
#ifdef	_1170
		if(adr >= FULLPAGE)
			{
			lseek(corefd, bign, 0);
			seek(corefd, adr - FULLPAGE, 1);
			}
		  else
			seek(corefd, adr, 0);
#endif	_1170
#ifdef	BIG_UNIX | _1140
			seek(corefd, adr, 0);
#endif	BIG_UNIX | _1140
	}

	if (read(corefd, &word, 2) != 2)
		errflg++;
	return(word);
}

/****************************/

#ifdef	BIG_UNIX
vallook(value, ka5)
#endif	BIG_UNIX
#ifndef	BIG_UNIX
vallook(value)
#endif	BIG_UNIX
unsigned value;
#ifdef	BIG_UNIX
int	ka5;
#endif	BIG_UNIX
{
#ifdef	BIG_UNIX
	return(getnum(value, ka5));
#endif	BIG_UNIX
#ifndef	BIG_UNIX
	return(getnum(value));
#endif	BIG_UNIX
}

/************************/

numcomp(a, b)
int *a, *b;
{
	register struct symbol	*sa, *sb;

	sa = &symbuf[*a];
	sb = &symbuf[*b];
	if (sa->s_symval < sb->s_symval)
		return(-1);
	if (sa->s_symval > sb->s_symval)
		return(1);
#ifdef	BIG_UNIX
	if (sa->s_symseg < sb->s_symseg)
		return(-1);
	if (sa->s_symseg > sb->s_symseg)
		return(1);
#endif	BIG_UNIX
	return(0);
}

/****************************/

alcomp(a, b)
int	*a, *b;
{
	return(alcom(symbuf[*a].s_symbol, symbuf[*b].s_symbol));
}

/************************/

symsort()
{
	/*
	 *	this procedure verifys the validity of the file
	 *	and having done this creates:
	 *
	 *	symbuf[] - an array of symbol table entry structures
	 *		   read from the namelist file.
	 *	alpha[] -  alpha ordered index into symbuf
	 *	numeric[] - numerically ordered index into symbuf
	 *
	 *	and for 70s notes where the text REALLY is
	 *
	 */

	/* declarations */

	register unsigned	i;

	seek(namefd, 0, 0);
	read(namefd, regbuf, 16);

	if (regbuf[0]!=0407 && regbuf[0]!=0410 && regbuf[0]!=0411)
		crash("namelist file - bad format!");

	symoff = regbuf[1] + regbuf[2];
	symlen = regbuf[4];
	if (symlen == 0)
		crash("namelist stripped!");
	if (regbuf[7] != 1)
		symoff =<< 1;
	symoff =+ 16;
	seek(namefd, symoff, 0);

	/* get core for it */

	symcnt = symlen / 6;

	if ((alpha = alloc(symcnt)) < 0)
		crash("no core for alpha!");
	if ((numeric = alloc(symcnt)) < 0)
		crash("no core for numeric!");

	symcnt = symlen / 12;

	/* get core for symbol buffer */

	if ((symbuf = alloc(symlen)) < 0)
		crash("no core for symbuf!");

	/* now initialise vectors and symbol table */

	for (i = 0; i < symcnt; i++) {
		alpha[i] = i;
		numeric[i] = i;
	}

	if (read(namefd, symbuf, symlen) < symlen)
		crash("cannot read whole symbuf!");

	/* now for a quicksort or two */

	qsort(alpha, symcnt, 2, alcomp);
	qsort(numeric, symcnt, 2, numcomp);
#ifdef	_1170
	if((i = albin("_end\0\0\0\0")) == 0)
		{
		crash("cant find \"_end\"!");
		}
	  else
		{
		txtoff = ((i->s_symval+63) >> 6) & 077777;
		}
	DEBUG
		printf("symsort 70 text offset=%u (%o)\n",
			txtoff, txtoff);
#endif	_1170
#ifdef	BIG_UNIX
	segsort();
#endif

	/* assuming they both worked, that is all */

}

/****************************/

#ifdef	BIG_UNIX
char	segsymbol[] "..seg000";

segsort()
{
	register int	i;
	register struct symbol	*sp;
	
	for (i = 0; i < MAXSEG; i++) {
		segsymbol[7] = (i+1) % 10 + '0';
		segsymbol[6] = (i+1)/10%10 + '0';
		segsymbol[5] = (i+1)/100%10 + '0';
		sp = albin(segsymbol);
		if (sp == 0)
			break;
		segbase[i] = sp->s_symval;
	}
	maxseg = i;
}
#endif

/****************************/

albin(string)
char	*string;
{
	/*
	 *	given a "string" (8-chars, null padded) this routine
	 *	will return a pointer to a structure of type "symbol"
	 *	whose symbol field matches the passed "string".
	 *	Otherwise will return null (0);
	 */

	register	i, j, k;
	int	r;

	i = 0;
	j = symcnt;

	while (i != j-1) {
		k = (i+j) / 2;
		DEBUG
			printf("albin loop: i=%u, j=%u, k=%u\n", i, j, k);
		DEBUG
			printf("alcom(%8.8s, %8.8s) ", string, symbuf[alpha[k]].s_symbol);
		r = alcom(string, symbuf[alpha[k]].s_symbol);
		if (r < 0)
			j = k;
		else
			i = k;
		DEBUG
			printf("=> %d\n", r);
	}
	if (alcom(string, symbuf[alpha[i]].s_symbol) == 0)
		return(&symbuf[alpha[i]]);

	return(0);
}

/***************************/

#ifndef	BIG_UNIX
numbin(a)
#endif
#ifdef	BIG_UNIX
numbin(a, ka5)
#endif
unsigned a;
#ifdef	BIG_UNIX
int	ka5;
#endif
{
	/*
	 *	given a value "a" will return a pointer to a structure
	 *	of type "symbol" whose "value" field is
	 *	exactly equal to the value passed.
	 *	otherwise a pointer to the structure
	 *	with the next lowest value is returned.
	 *	if no lower structure exists, null is returned (0).
	 *
	 *	A non-zero value of ka5 will cause us to look
	 *	in the appropriate page for symbols.
	 */

	register	i, j;
	int	k;
#ifdef	BIG_UNIX
	int	seg;
#endif
	int	r;
	register struct symbol	*sp;

#ifdef	BIG_UNIX
	seg = 0;
	if (a<PAGEADR || a>=PAGEADR+020000)
		ka5 = 0;
	if (ka5 != 0) {
		for (i = 0; i < maxseg; i++)
			if (ka5 == segbase[i]) {
				seg = i+1;
				break;
			}
	}

	DEBUG
		printf("numbin: a=%u, seg=%u, ka5=%u\n", a, seg, ka5);
#endif

	i = 0;
	j = symcnt;

	while (i != j-1) {
		k = (i+j) / 2;
		sp = &symbuf[numeric[k]];
		DEBUG {
			printf("numbin loop: i=%u, j=%u, k=%u\n", i, j, k);
#ifndef	BIG_UNIX
			printf("\t\ts_symval=%u\n", sp->s_symval);
#endif
#ifdef	BIG_UNIX
			printf("\t\ts_symval=%u, s_symseg=%u\n", sp->s_symval, sp->s_symseg);
#endif
		}
		if (a < sp->s_symval)
			j = k;
#ifdef	BIG_UNIX
		else if (a > sp->s_symval)
			i = k;
		else if (seg == 0)
			i = k;
		else if (seg < sp->s_symseg)
			j = k;
#endif
		else
			i = k;
	}

	sp = &symbuf[numeric[i]];
	if (a == sp->s_symval)
#ifdef	BIG_UNIX
		if (seg==0 || seg==sp->s_symseg)
#endif
			return(sp);

	if (i == 0)
		return(0);
	/* above should be checked by calling program */

#ifdef	BIG_UNIX
	if (seg != 0)
		/*
		 * It is a far better thing I do to find an even
		 * more distant symbol that is at least in the
		 * same page of memory.
		 */
		for (j = i; j != 0; j--) {
			DEBUG
				printf("numbin: segment test: s_symseg=%u, s_symval=%u\n",
					symbuf[numeric[j]].s_symseg,
					symbuf[numeric[j]].s_symval);
			if (seg == symbuf[numeric[j]].s_symseg) {
				sp = &symbuf[numeric[j]];
				break;
			}
		}
#endif

	return(sp);
}

/***************************/

alcom(a, b)
{
	register	r;
	register char	*p, *q;

	p = a;
	q = b;

	for (r = 0; r < 8; r++) {
		if (*p < *q)
			return(-1);
		if (*p++ > *q++)
			return(1);
	}
	return(0);
}

/*************************/

#ifdef	BIG_UNIX
getnum(adr, ka5)
#endif	BIG_UNIX
#ifndef	BIG_UNIX
getnum(adr)
#endif	BIG_UNIX
unsigned adr;
#ifdef	BIG_UNIX
int	ka5;
#endif	BIG_UNIX
{
	register struct symbol	*p;

#ifdef	BIG_UNIX
	p = numbin(adr, ka5);
#endif	BIG_UNIX
#ifndef	BIG_UNIX
	p = numbin(adr);
#endif	BIG_UNIX
	if (p == 0)
		p = &nullnum;

	return(p);
}

/*********************/

getname(string)
char	*string;
{
	return(albin(string));
}