[unix-history] / usr / src / cmd / sdb / xeq.c

#include "head.h"
#include <a.out.h>
struct user u;
#include <stdio.h>
INT signo;
INT adrflg;
INT pid;
ADDR userpc;
L_INT cntval;


/* service routines for sub process control */


/*
 * single step until loc with descriptor format d is modified
 * return its new value.
 */
monex(loc, d)
ADDR loc; char d; {
	register ADDR oldval;
	
	oldval = getval(loc, d);
	do {
		subpcs('s');
	} while (oldval == getval(loc, d));
	return(getval(loc, d));
}

/* single step count source stmts */
singstep(count, cmd)
	char cmd; {
	register int thisline, curline;
	register struct proct *thisproc;
	
	if (sdbttym.sg_flags != userttym.sg_flags)
		stty(2, &userttym);
	dot = *(ADDR *) (((ADDR) &u) + PC);
	thisproc = adrtoprocp(dot);
	thisline = adrtolineno(dot);
	if (count == 0) count = 1;
	for(; count; count--) {
		do {
			if (cmd == 'S') {
				dot = *(ADDR *) (((ADDR) &u) + PC);
				if ((get(dot,ISP) & 0xff) == 0xfb){ /* calls */
					int retaddr;
					subpcs('s');
					retaddr =
					   *(ADDR *) (((ADDR) &u) + USP) + 16;
					retaddr = dot = get(retaddr, DSP);
					subpcs('b');
					subpcs('c');
					dot = retaddr;
					subpcs('d');
					dot = *(ADDR *) (((ADDR) &u) + PC);
					if (retaddr != dot && signo == 0) {
						gtty(2, &userttym);
						if (sdbttym.sg_flags !=
							userttym.sg_flags)
							stty(2, &sdbttym);
						printf("Breakpoint at \n");
						return;
					}
					continue;
				}
			}

			subpcs('s');
			dot = *(ADDR *) (((ADDR) &u) + PC);
			curline = adrtolineno(dot);
		} while (!signo && 
			((thisproc == adrtoprocp(dot) && thisline == curline) ||
			curline == -1));
		gtty(2, &userttym);
		if (sdbttym.sg_flags != userttym.sg_flags)
			stty(2, &sdbttym);
		if (signo) return;
	}
}

doscall() {
	int subargs[NUMARGS];	     /* subargs[0]    = address, 
					subargs[1]    = number of arguments
					subargs[2:NUMARGS] = actual arguments */
	union {
		struct {
			int w[128-NUMARGS];
		};
		struct {
			char c[4*(128-NUMARGS)];
		};
	}substr;
	
	register int i, numchars, *subargp;
	register char ch;
	ADDR straddr, adr, praddr;
	ADDR j;
	
	praddr = extaddr(proc);
	if (praddr == -1) {
		printf("Cannot find %s\n", proc);
		return;
	}
	straddr = extaddr("_dbargs");
	if (straddr == -1) {
		error("Program not loaded with -lg");
		return;
	}
	
	numchars = 0;
	subargp = subargs;
	argsp++;
	*subargp++ = praddr;
	subargp++;
	
	for (i=0; i<NUMARGS - 2; i++) {  /* process an argument */
		ch = *argsp;
		if (ch == '\'') {
			*subargp++ = *(argsp+1);
			argsp += 2;
		} else if (ch == '"') {
			*subargp++ = straddr + sizeof subargs + numchars;
			argsp++;
			for (;;) {
				ch = *argsp++;
				if (ch == '\\') {
					switch(ch = *argsp++) {
					case 'r':
						ch = '\015';
						break;
					case 'n':
						ch = '\012';
						break;
					case '\\':
						ch = '\\';
						break;
					}
				}
				substr.c[numchars++] = ch;
				if (ch == '"') {
					substr.c[numchars-1] = '\0';
					break;
				}
				if (ch == '\0') {
					error("Unterminated string constant");
					return;
				}
				if (numchars > sizeof substr.c) {
					error("Too many string constants");
					return;
				}
			}
		} else if ((ch >= '0' && ch <= '9') || ch == '-') {
			*subargp++ = readint(&argsp);
		} else if ((ch >= 'a' && ch <= 'z') ||
			(ch >= 'A' && ch <= 'Z') || ch == '_') {
			cpname(var, argsp);
			j = varaddr(curproc()->pname, var);
			if (j == -1) {
				return;
			}
			*subargp++ =
				sl_class == N_RSYM ?
				  *(ADDR *)(((ADDR) &u) + R0 + (WORDSIZE)*j) :
				  getval(j, typetodesc(sl_type, 0)[0]);
			do {
				argsp++;
			} while (varchar(*argsp) || number(*argsp));
		} else if (ch != ')') {
			printf("Unexpected character %c\n", ch);
			return;
		}
	
		do {
			ch = *argsp++;
		} while(ch == ' ');
		if (ch == ')') {
			if (scallx == 0) {
				scallx = 1;
 				pcs = *(ADDR *)(((ADDR)&u)+PC);
 				fps = *(ADDR *)(((ADDR)&u)+FP);
 				aps = *(ADDR *)(((ADDR)&u)+AP);
				if (bkpts = scanbkpt(userpc)) {
					if (flagss = bkpts->flag) {
						bkpts->flag = BKPTSET;
					}
				}
			}
 			dot = *(ADDR *)(((ADDR)&u)+PC) = extaddr("_dbsubc");
			if (dot == -1) {
				error("Internal error - cannot find _dbsubc");
				return;
			}
			adrflg = 1;
			cntval = 1;
			if (pid == 0 || signo) subpcs('r');
			subargs[1] = (subargp - subargs) - 2;
			adr = straddr;
			for (j=0; j<=(subargp-subargs); j++) {
				put(adr, DSP, subargs[j]);
				adr += WORDSIZE;
			}
			adr = straddr + sizeof subargs;
			for (j=0; j<(numchars+WORDSIZE-1)/WORDSIZE; j++) {
				put(adr, DSP, substr.w[j]);
				adr += WORDSIZE;
			}
			dschar = *argsp++;
			errflg = 0;
			dopcs('c');
			if (!signo) printf("Breakpoint");
			printf(" at\n");
			return;
		}
		while (*argsp == ' ' || *argsp == ',')
			argsp++;
	}
	
	error ("Too many arguments");

}


/* get arguments from core file, place them in args */
getargs() {
	struct proct *procp;
	ADDR p, av;
	int ac, i;
	char *argsp = args;
	union {
		struct {
			char c[WORDSIZE]; 
			};
		struct {
			int w;
		};
		struct {
			float f;
		}
	} word;

	if ((procp = initframe()) == badproc) goto old1;
	do {
		if (eqstr("main", procp->pname))
			goto fnd;
	} while ((procp = nextframe()) != badproc);

old1:	cpstr(args, oldargs);
	printf("%s %s\n", symfil, args);
	return;

fnd:	ac = get(argp, DSP);
	if ((ac == 0) || (ac & 0xff)) goto old1;
	ac = get(argp+4, DSP);
	av = (ADDR) get(argp+8, DSP);

	av += WORDSIZE;
	ac--;

	for (; ac; ac--) {
		p = (ADDR) get(av, DSP);
		av += WORDSIZE;
		for (;;) {
			word.w = get(p, DSP);
			for (i=0; i<WORDSIZE; i++) {
				if (word.c[i] == '\0') goto l1;
				*argsp++ = word.c[i];
			}
			p += WORDSIZE;
		}
l1:		*argsp++ = ' ';
	}
	*argsp == '\0';
	printf("%s %s\n", symfil, args);
	return;


}

dopcs(c) 
char c; {
	if (c != 'r' && c != 'R' && sdbttym.sg_flags != userttym.sg_flags)
		stty(2, &userttym);
	subpcs(c);
	gtty(2, &userttym);
	if (sdbttym.sg_flags != userttym.sg_flags)
		stty(2, &sdbttym);
 	
	if (eqany(c, "cCsS") && 
	     *(ADDR *)(((ADDR)&u)+PC) == extaddr("_dbsubn")) {
		if (dschar == '/') {
			dispf((ADDR) 0, *argsp ? argsp : "d", N_RSYM, 0, 0);
		}
		else
			printf("Procedure returned normally\n");
 		userpc = dot = *(ADDR *)(((ADDR)&u)+PC) = pcs;
 		*(ADDR *)(((ADDR)&u)+FP) = fps;
 		*(ADDR *)(((ADDR)&u)+AP) = aps;
		if (bkpts)
			bkpts->flag = flagss;
		scallx = 0;
		longjmp(env, 0);
	}
}

/* execute commands from a breakpoint */
acommand(cmds)
char *cmds; {
	char *p = cmds;
	int endflg = 0;

	setcur(0);
	do { 		/* process a command */
		for (;;) {
			if (*p == ';') {
				*p = '\n';
				break;
			}
			if (*p == '\n') {
				endflg++;
				break;
			}
			p++;
		}
		if (decode(cmds) == 1) {
			printf("Bad command: ");
			do {
				printf("%c", *cmds);
			} while (*cmds++ != '\n');
			return;
		}
		docommand();
		p = cmds = p + 1;
	} while (!endflg);
}
Commit	Line	Data
b7523e3d HK	1	#include "head.h"
	2	#include <a.out.h>
	3	struct user u;
	4	#include <stdio.h>
	5	INT signo;
	6	INT adrflg;
	7	INT pid;
	8	ADDR userpc;
	9	L_INT cntval;
	10
	11
	12	/* service routines for sub process control */
	13
	14
	15	/*
	16	* single step until loc with descriptor format d is modified
	17	* return its new value.
	18	*/
	19	monex(loc, d)
	20	ADDR loc; char d; {
	21	register ADDR oldval;
	22
	23	oldval = getval(loc, d);
	24	do {
	25	subpcs('s');
	26	} while (oldval == getval(loc, d));
	27	return(getval(loc, d));
	28	}
	29
	30	/* single step count source stmts */
	31	singstep(count, cmd)
	32	char cmd; {
	33	register int thisline, curline;
	34	register struct proct *thisproc;
	35
	36	if (sdbttym.sg_flags != userttym.sg_flags)
	37	stty(2, &userttym);
	38	dot = (ADDR ) (((ADDR) &u) + PC);
	39	thisproc = adrtoprocp(dot);
	40	thisline = adrtolineno(dot);
	41	if (count == 0) count = 1;
	42	for(; count; count--) {
	43	do {
	44	if (cmd == 'S') {
	45	dot = (ADDR ) (((ADDR) &u) + PC);
	46	if ((get(dot,ISP) & 0xff) == 0xfb){ /* calls */
	47	int retaddr;
	48	subpcs('s');
	49	retaddr =
	50	(ADDR ) (((ADDR) &u) + USP) + 16;
	51	retaddr = dot = get(retaddr, DSP);
	52	subpcs('b');
	53	subpcs('c');
	54	dot = retaddr;
	55	subpcs('d');
	56	dot = (ADDR ) (((ADDR) &u) + PC);
	57	if (retaddr != dot && signo == 0) {
	58	gtty(2, &userttym);
	59	if (sdbttym.sg_flags !=
	60	userttym.sg_flags)
	61	stty(2, &sdbttym);
	62	printf("Breakpoint at \n");
	63	return;
	64	}
65	continue;
66	}
67	}
68
69	subpcs('s');
70	dot = (ADDR ) (((ADDR) &u) + PC);
71	curline = adrtolineno(dot);
72	} while (!signo &&
73	((thisproc == adrtoprocp(dot) && thisline == curline) \|\|
74	curline == -1));
75	gtty(2, &userttym);
76	if (sdbttym.sg_flags != userttym.sg_flags)
77	stty(2, &sdbttym);
78	if (signo) return;
79	}
80	}
81
82	doscall() {
83	int subargs[NUMARGS]; /* subargs[0] = address,
84	subargs[1] = number of arguments
85	subargs[2:NUMARGS] = actual arguments */
86	union {
87	struct {
88	int w[128-NUMARGS];
89	};
90	struct {
91	char c[4*(128-NUMARGS)];
92	};
93	}substr;
94
95	register int i, numchars, *subargp;
96	register char ch;
97	ADDR straddr, adr, praddr;
98	ADDR j;
99
100	praddr = extaddr(proc);
101	if (praddr == -1) {
102	printf("Cannot find %s\n", proc);
103	return;
104	}
105	straddr = extaddr("_dbargs");
106	if (straddr == -1) {
107	error("Program not loaded with -lg");
108	return;
109	}
110
111	numchars = 0;
112	subargp = subargs;
113	argsp++;
114	*subargp++ = praddr;
115	subargp++;
116
117	for (i=0; i<NUMARGS - 2; i++) { /* process an argument */
118	ch = *argsp;
119	if (ch == '\'') {
120	subargp++ = (argsp+1);
121	argsp += 2;
122	} else if (ch == '"') {
123	*subargp++ = straddr + sizeof subargs + numchars;
124	argsp++;
125	for (;;) {
126	ch = *argsp++;
127	if (ch == '\\') {
128	switch(ch = *argsp++) {
129	case 'r':
130	ch = '\015';
131	break;
132	case 'n':
133	ch = '\012';
134	break;
135	case '\\':
136	ch = '\\';
137	break;
138	}
139	}
140	substr.c[numchars++] = ch;
141	if (ch == '"') {
142	substr.c[numchars-1] = '\0';
143	break;
144	}
145	if (ch == '\0') {
146	error("Unterminated string constant");
147	return;
148	}
149	if (numchars > sizeof substr.c) {
150	error("Too many string constants");
151	return;
152	}
153	}
154	} else if ((ch >= '0' && ch <= '9') \|\| ch == '-') {
155	*subargp++ = readint(&argsp);
156	} else if ((ch >= 'a' && ch <= 'z') \|\|
157	(ch >= 'A' && ch <= 'Z') \|\| ch == '_') {
158	cpname(var, argsp);
159	j = varaddr(curproc()->pname, var);
160	if (j == -1) {
161	return;
162	}
163	*subargp++ =
164	sl_class == N_RSYM ?
165	(ADDR )(((ADDR) &u) + R0 + (WORDSIZE)*j) :
166	getval(j, typetodesc(sl_type, 0)[0]);
167	do {
168	argsp++;
169	} while (varchar(argsp) \|\| number(argsp));
170	} else if (ch != ')') {
171	printf("Unexpected character %c\n", ch);
172	return;
173	}
174
175	do {
176	ch = *argsp++;
177	} while(ch == ' ');
178	if (ch == ')') {
179	if (scallx == 0) {
180	scallx = 1;
181	pcs = (ADDR )(((ADDR)&u)+PC);
182	fps = (ADDR )(((ADDR)&u)+FP);
183	aps = (ADDR )(((ADDR)&u)+AP);
184	if (bkpts = scanbkpt(userpc)) {
185	if (flagss = bkpts->flag) {
186	bkpts->flag = BKPTSET;
187	}
188	}
189	}
190	dot = (ADDR )(((ADDR)&u)+PC) = extaddr("_dbsubc");
191	if (dot == -1) {
192	error("Internal error - cannot find _dbsubc");
193	return;
194	}
195	adrflg = 1;
196	cntval = 1;
197	if (pid == 0 \|\| signo) subpcs('r');
198	subargs[1] = (subargp - subargs) - 2;
199	adr = straddr;
200	for (j=0; j<=(subargp-subargs); j++) {
201	put(adr, DSP, subargs[j]);
202	adr += WORDSIZE;
203	}
204	adr = straddr + sizeof subargs;
205	for (j=0; j<(numchars+WORDSIZE-1)/WORDSIZE; j++) {
206	put(adr, DSP, substr.w[j]);
207	adr += WORDSIZE;
208	}
209	dschar = *argsp++;
210	errflg = 0;
211	dopcs('c');
212	if (!signo) printf("Breakpoint");
213	printf(" at\n");
214	return;
215	}
216	while (argsp == ' ' \|\| argsp == ',')
217	argsp++;
218	}
219
220	error ("Too many arguments");
221
222	}
223
224
225	/* get arguments from core file, place them in args */
226	getargs() {
227	struct proct *procp;
228	ADDR p, av;
229	int ac, i;
230	char *argsp = args;
231	union {
232	struct {
233	char c[WORDSIZE];
234	};
235	struct {
236	int w;
237	};
238	struct {
239	float f;
240	}
241	} word;
242
243	if ((procp = initframe()) == badproc) goto old1;
244	do {
245	if (eqstr("main", procp->pname))
246	goto fnd;
247	} while ((procp = nextframe()) != badproc);
248
249	old1: cpstr(args, oldargs);
250	printf("%s %s\n", symfil, args);
251	return;
252
253	fnd: ac = get(argp, DSP);
254	if ((ac == 0) \|\| (ac & 0xff)) goto old1;
255	ac = get(argp+4, DSP);
256	av = (ADDR) get(argp+8, DSP);
257
258	av += WORDSIZE;
259	ac--;
260
261	for (; ac; ac--) {
262	p = (ADDR) get(av, DSP);
263	av += WORDSIZE;
264	for (;;) {
265	word.w = get(p, DSP);
266	for (i=0; i<WORDSIZE; i++) {
267	if (word.c[i] == '\0') goto l1;
268	*argsp++ = word.c[i];
269	}
270	p += WORDSIZE;
271	}
272	l1: *argsp++ = ' ';
273	}
274	*argsp == '\0';
275	printf("%s %s\n", symfil, args);
276	return;
277
278
279	}
280
281	dopcs(c)
282	char c; {
283	if (c != 'r' && c != 'R' && sdbttym.sg_flags != userttym.sg_flags)
284	stty(2, &userttym);
285	subpcs(c);
286	gtty(2, &userttym);
287	if (sdbttym.sg_flags != userttym.sg_flags)
288	stty(2, &sdbttym);
289
290	if (eqany(c, "cCsS") &&
291	(ADDR )(((ADDR)&u)+PC) == extaddr("_dbsubn")) {
292	if (dschar == '/') {
293	dispf((ADDR) 0, *argsp ? argsp : "d", N_RSYM, 0, 0);
294	}
295	else
296	printf("Procedure returned normally\n");
297	userpc = dot = (ADDR )(((ADDR)&u)+PC) = pcs;
298	(ADDR )(((ADDR)&u)+FP) = fps;
299	(ADDR )(((ADDR)&u)+AP) = aps;
300	if (bkpts)
301	bkpts->flag = flagss;
302	scallx = 0;
303	longjmp(env, 0);
304	}
305	}
306
307	/* execute commands from a breakpoint */
308	acommand(cmds)
309	char *cmds; {
310	char *p = cmds;
311	int endflg = 0;
312
313	setcur(0);
314	do { /* process a command */
315	for (;;) {
316	if (*p == ';') {
317	*p = '\n';
318	break;
319	}
320	if (*p == '\n') {
321	endflg++;
322	break;
323	}
324	p++;
325	}
326	if (decode(cmds) == 1) {
327	printf("Bad command: ");
328	do {
329	printf("%c", *cmds);
330	} while (*cmds++ != '\n');
331	return;
332	}
333	docommand();
334	p = cmds = p + 1;
335	} while (!endflg);
336	}