![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to runtime.vax.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / lib / old_compiler / dbx|
Return to runtime.vax.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / lib / old_compiler / dbx |
1.1 root 1: /*
2: * Copyright (c) 1983 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char sccsid[] = "@(#)runtime.vax.c 5.3 (Berkeley) 1/12/88";
9: #endif not lint
10:
11: static char rcsid[] = "$Header: runtime.vax.c,v 1.3 88/01/11 21:27:00 donn Exp $";
12:
13: /*
14: * Runtime organization dependent routines, mostly dealing with
15: * activation records.
16: */
17:
18: #include "defs.h"
19: #include "runtime.h"
20: #include "process.h"
21: #include "machine.h"
22: #include "events.h"
23: #include "mappings.h"
24: #include "symbols.h"
25: #include "tree.h"
26: #include "eval.h"
27: #include "operators.h"
28: #include "object.h"
29: #include <sys/param.h>
30: #include <signal.h>
31:
32: #ifndef public
33: typedef struct Frame *Frame;
34:
35: #include "machine.h"
36: #endif
37:
38: #define NSAVEREG 12
39:
40: struct Frame {
41: integer condition_handler;
42: integer mask;
43: Address save_ap; /* argument pointer */
44: Address save_fp; /* frame pointer */
45: Address save_pc; /* program counter */
46: Word save_reg[NSAVEREG]; /* not necessarily there */
47: };
48:
49: private Frame curframe = nil;
50: private struct Frame curframerec;
51: private Boolean walkingstack = false;
52:
53: #define frameeq(f1, f2) ((f1)->save_fp == (f2)->save_fp)
54:
55: #define inSignalHandler(addr) \
56: (((addr) < 0x80000000) and ((addr) > 0x80000000 - ctob(UPAGES)))
57:
58: typedef struct {
59: Node callnode;
60: Node cmdnode;
61: boolean isfunc;
62: } CallEnv;
63:
64: private CallEnv endproc;
65:
66: /*
67: * Set a frame to the current activation record.
68: */
69:
70: private getcurframe(frp)
71: Frame frp;
72: {
73: register int i;
74:
75: checkref(frp);
76: frp->mask = reg(NREG);
77: frp->save_ap = reg(ARGP);
78: frp->save_fp = reg(FRP);
79: frp->save_pc = reg(PROGCTR);
80: for (i = 0; i < NSAVEREG; i++) {
81: frp->save_reg[i] = reg(i);
82: }
83: }
84:
85: /*
86: * Get the saved registers from one frame to another
87: * given mask specifying which registers were actually saved.
88: */
89:
90: #define bis(b, n) ((b & (1 << (n))) != 0)
91:
92: private getsaveregs (newfrp, frp, mask)
93: Frame newfrp, frp;
94: integer mask;
95: {
96: integer i, j;
97:
98: j = 0;
99: for (i = 0; i < NSAVEREG; i++) {
100: if (bis(mask, i)) {
101: newfrp->save_reg[i] = frp->save_reg[j];
102: ++j;
103: }
104: }
105: }
106:
107: /*
108: * Return a pointer to the next activation record up the stack.
109: * Return nil if there is none.
110: * Writes over space pointed to by given argument.
111: */
112:
113: private Frame nextframe(frp)
114: Frame frp;
115: {
116: Frame newfrp;
117: struct Frame frame;
118: integer mask;
119: Address prev_frame, callpc;
120: static integer ntramp = 0;
121:
122: newfrp = frp;
123: prev_frame = frp->save_fp;
124:
125: /*
126: * The check for interrupt generated frames is taken from adb with only
127: * partial understanding. If you're in "sub" and on a sigxxx "sigsub"
128: * gets control, then the stack does NOT look like <main, sub, sigsub>.
129: *
130: * As best I can make out it looks like:
131: *
132: * <main, (machine check exception block + sub), sysframe, sigsub>.
133: *
134: * When the signal occurs an exception block and a frame for the routine
135: * in which it occured are pushed on the user stack. Then another frame
136: * is pushed corresponding to a call from the kernel to sigsub.
137: *
138: * The addr in sub at which the exception occured is not in sub.save_pc
139: * but in the machine check exception block. It is at the magic address
140: * fp + 84.
141: *
142: * The current approach ignores the sys_frame (what adb reports as sigtramp)
143: * and takes the pc for sub from the exception block. This allows the
144: * "where" command to report <main, sub, sigsub>, which seems reasonable.
145: */
146:
147: nextf:
148: if (prev_frame + sizeof(struct Frame) <= USRSTACK) {
149: dread(&frame, prev_frame, sizeof(struct Frame));
150: } else if (USRSTACK - prev_frame > 2 * sizeof(Word)) {
151: dread(&frame, prev_frame, USRSTACK - prev_frame);
152: } else {
153: frame.save_fp = nil;
154: }
155: if (ntramp == 1) {
156: dread(&callpc, prev_frame + 92, sizeof(callpc));
157: } else {
158: callpc = frame.save_pc;
159: }
160: if (frame.save_fp == nil or frame.save_pc == (Address) -1) {
161: newfrp = nil;
162: } else {
163: if (inSignalHandler(callpc)) {
164: ntramp++;
165: prev_frame = frame.save_fp;
166: goto nextf;
167: }
168: frame.save_pc = callpc;
169: ntramp = 0;
170: newfrp->save_fp = frame.save_fp;
171: newfrp->save_pc = frame.save_pc;
172: mask = ((frame.mask >> 16) & 0x0fff);
173: getsaveregs(newfrp, &frame, mask);
174: newfrp->condition_handler = frame.condition_handler;
175: newfrp->mask = mask;
176: newfrp->save_ap = frame.save_ap;
177: }
178: return newfrp;
179: }
180:
181: /*
182: * Get the current frame information in the given Frame and store the
183: * associated function in the given value-result parameter.
184: */
185:
186: private getcurfunc (frp, fp)
187: Frame frp;
188: Symbol *fp;
189: {
190: getcurframe(frp);
191: *fp = whatblock(frp->save_pc);
192: }
193:
194: /*
195: * Return the frame associated with the next function up the call stack, or
196: * nil if there is none. The function is returned in a value-result parameter.
197: * For "inline" functions the statically outer function and same frame
198: * are returned.
199: */
200:
201: public Frame nextfunc (frp, fp)
202: Frame frp;
203: Symbol *fp;
204: {
205: Symbol t;
206: Frame nfrp;
207:
208: t = *fp;
209: checkref(t);
210: if (isinline(t)) {
211: t = container(t);
212: nfrp = frp;
213: } else {
214: nfrp = nextframe(frp);
215: if (nfrp == nil) {
216: t = nil;
217: } else {
218: t = whatblock(nfrp->save_pc);
219: }
220: }
221: *fp = t;
222: return nfrp;
223: }
224:
225: /*
226: * Return the frame associated with the given function.
227: * If the function is nil, return the most recently activated frame.
228: *
229: * Static allocation for the frame.
230: */
231:
232: public Frame findframe(f)
233: Symbol f;
234: {
235: Frame frp;
236: static struct Frame frame;
237: Symbol p;
238: Boolean done;
239:
240: frp = &frame;
241: getcurframe(frp);
242: if (f != nil) {
243: if (f == curfunc and curframe != nil) {
244: *frp = *curframe;
245: } else {
246: done = false;
247: p = whatblock(frp->save_pc);
248: do {
249: if (p == f) {
250: done = true;
251: } else if (p == program) {
252: done = true;
253: frp = nil;
254: } else {
255: frp = nextfunc(frp, &p);
256: if (frp == nil) {
257: done = true;
258: }
259: }
260: } while (not done);
261: }
262: }
263: return frp;
264: }
265:
266: /*
267: * Set the registers according to the given frame pointer.
268: */
269:
270: public getnewregs (addr)
271: Address addr;
272: {
273: struct Frame frame;
274: integer i, j, mask;
275:
276: dread(&frame, addr, sizeof(frame));
277: setreg(FRP, frame.save_fp);
278: setreg(PROGCTR, frame.save_pc);
279: setreg(ARGP, frame.save_ap);
280: mask = ((frame.mask >> 16) & 0x0fff);
281: j = 0;
282: for (i = 0; i < NSAVEREG; i++) {
283: if (bis(mask, i)) {
284: setreg(i, frame.save_reg[j]);
285: ++j;
286: }
287: }
288: pc = frame.save_pc;
289: setcurfunc(whatblock(pc));
290: }
291:
292: /*
293: * Find the return address of the current procedure/function.
294: */
295:
296: public Address return_addr()
297: {
298: Frame frp;
299: Address addr;
300: struct Frame frame;
301:
302: frp = &frame;
303: getcurframe(frp);
304: frp = nextframe(frp);
305: if (frp == nil) {
306: addr = 0;
307: } else {
308: addr = frp->save_pc;
309: }
310: return addr;
311: }
312:
313: /*
314: * Push the value associated with the current function.
315: */
316:
317: public pushretval(len, isindirect)
318: integer len;
319: boolean isindirect;
320: {
321: Word r0;
322:
323: r0 = reg(0);
324: if (isindirect) {
325: rpush((Address) r0, len);
326: } else {
327: switch (len) {
328: case sizeof(char):
329: push(char, r0);
330: break;
331:
332: case sizeof(short):
333: push(short, r0);
334: break;
335:
336: default:
337: if (len == sizeof(Word)) {
338: push(Word, r0);
339: } else if (len == 2*sizeof(Word)) {
340: push(Word, r0);
341: push(Word, reg(1));
342: } else {
343: error("[internal error: bad size %d in pushretval]", len);
344: }
345: break;
346: }
347: }
348: }
349:
350: /*
351: * Return the base address for locals in the given frame.
352: */
353:
354: public Address locals_base(frp)
355: Frame frp;
356: {
357: return (frp == nil) ? reg(FRP) : frp->save_fp;
358: }
359:
360: /*
361: * Return the base address for arguments in the given frame.
362: */
363:
364: public Address args_base(frp)
365: Frame frp;
366: {
367: return (frp == nil) ? reg(ARGP) : frp->save_ap;
368: }
369:
370: /*
371: * Return saved register n from the given frame.
372: */
373:
374: public Word savereg(n, frp)
375: integer n;
376: Frame frp;
377: {
378: Word w;
379:
380: if (frp == nil) {
381: w = reg(n);
382: } else {
383: switch (n) {
384: case ARGP:
385: w = frp->save_ap;
386: break;
387:
388: case FRP:
389: w = frp->save_fp;
390: break;
391:
392: case STKP:
393: w = reg(STKP);
394: break;
395:
396: case PROGCTR:
397: w = frp->save_pc;
398: break;
399:
400: default:
401: assert(n >= 0 and n < NSAVEREG);
402: w = frp->save_reg[n];
403: break;
404: }
405: }
406: return w;
407: }
408:
409: /*
410: * Return the nth argument to the current procedure.
411: */
412:
413: public Word argn(n, frp)
414: integer n;
415: Frame frp;
416: {
417: Address argaddr;
418: Word w;
419:
420: argaddr = args_base(frp) + (n * sizeof(Word));
421: dread(&w, argaddr, sizeof(w));
422: return w;
423: }
424:
425: /*
426: * Print a list of currently active blocks starting with most recent.
427: */
428:
429: public wherecmd()
430: {
431: walkstack(false);
432: }
433:
434: /*
435: * Print the variables in the given frame or the current one if nil.
436: */
437:
438: public dump (func)
439: Symbol func;
440: {
441: Symbol f;
442: Frame frp;
443:
444: if (func == nil) {
445: f = curfunc;
446: if (curframe != nil) {
447: frp = curframe;
448: } else {
449: frp = findframe(f);
450: }
451: } else {
452: f = func;
453: frp = findframe(f);
454: }
455: showaggrs = true;
456: printcallinfo(f, frp);
457: dumpvars(f, frp);
458: }
459:
460: /*
461: * Dump all values.
462: */
463:
464: public dumpall ()
465: {
466: walkstack(true);
467: }
468:
469: /*
470: * Walk the stack of active procedures printing information
471: * about each active procedure.
472: */
473:
474: private walkstack(dumpvariables)
475: Boolean dumpvariables;
476: {
477: Frame frp;
478: boolean save;
479: Symbol f;
480: struct Frame frame;
481:
482: if (notstarted(process) or isfinished(process)) {
483: error("program is not active");
484: } else {
485: save = walkingstack;
486: walkingstack = true;
487: showaggrs = dumpvariables;
488: frp = &frame;
489: getcurfunc(frp, &f);
490: for (;;) {
491: printcallinfo(f, frp);
492: if (dumpvariables) {
493: dumpvars(f, frp);
494: putchar('\n');
495: }
496: frp = nextfunc(frp, &f);
497: if (frp == nil or f == program) {
498: break;
499: }
500: }
501: if (dumpvariables) {
502: printf("in \"%s\":\n", symname(program));
503: dumpvars(program, nil);
504: putchar('\n');
505: }
506: walkingstack = save;
507: }
508: }
509:
510: /*
511: * Print out the information about a call, i.e.,
512: * routine name, parameter values, and source location.
513: */
514:
515: private printcallinfo (f, frp)
516: Symbol f;
517: Frame frp;
518: {
519: Lineno line;
520: Address savepc;
521:
522: savepc = frp->save_pc;
523: if (frp->save_fp != reg(FRP)) {
524: savepc -= 1;
525: }
526: printname(stdout, f);
527: if (not isinline(f)) {
528: printparams(f, frp);
529: }
530: line = srcline(savepc);
531: if (line != 0) {
532: printf(", line %d", line);
533: printf(" in \"%s\"\n", srcfilename(savepc));
534: } else {
535: printf(" at 0x%x\n", savepc);
536: }
537: }
538:
539: /*
540: * Set the current function to the given symbol.
541: * We must adjust "curframe" so that subsequent operations are
542: * not confused; for simplicity we simply clear it.
543: */
544:
545: public setcurfunc (f)
546: Symbol f;
547: {
548: curfunc = f;
549: curframe = nil;
550: }
551:
552: /*
553: * Return the frame for the current function.
554: * The space for the frame is allocated statically.
555: */
556:
557: public Frame curfuncframe ()
558: {
559: static struct Frame frame;
560: Frame frp;
561:
562: if (curframe == nil) {
563: frp = findframe(curfunc);
564: curframe = &curframerec;
565: *curframe = *frp;
566: } else {
567: frp = &frame;
568: *frp = *curframe;
569: }
570: return frp;
571: }
572:
573: /*
574: * Set curfunc to be N up/down the stack from its current value.
575: */
576:
577: public up (n)
578: integer n;
579: {
580: integer i;
581: Symbol f;
582: Frame frp;
583: boolean done;
584:
585: if (not isactive(program)) {
586: error("program is not active");
587: } else if (curfunc == nil) {
588: error("no current function");
589: } else {
590: i = 0;
591: f = curfunc;
592: frp = curfuncframe();
593: done = false;
594: do {
595: if (frp == nil) {
596: done = true;
597: error("not that many levels");
598: } else if (i >= n) {
599: done = true;
600: curfunc = f;
601: curframe = &curframerec;
602: *curframe = *frp;
603: showaggrs = false;
604: printcallinfo(curfunc, curframe);
605: } else if (f == program) {
606: done = true;
607: error("not that many levels");
608: } else {
609: frp = nextfunc(frp, &f);
610: }
611: ++i;
612: } while (not done);
613: }
614: }
615:
616: public down (n)
617: integer n;
618: {
619: integer i, depth;
620: Frame frp, curfrp;
621: Symbol f;
622: struct Frame frame;
623:
624: if (not isactive(program)) {
625: error("program is not active");
626: } else if (curfunc == nil) {
627: error("no current function");
628: } else {
629: depth = 0;
630: frp = &frame;
631: getcurfunc(frp, &f);
632: if (curframe == nil) {
633: curfrp = findframe(curfunc);
634: curframe = &curframerec;
635: *curframe = *curfrp;
636: }
637: while ((f != curfunc or !frameeq(frp, curframe)) and f != nil) {
638: frp = nextfunc(frp, &f);
639: ++depth;
640: }
641: if (f == nil or n > depth) {
642: error("not that many levels");
643: } else {
644: depth -= n;
645: frp = &frame;
646: getcurfunc(frp, &f);
647: for (i = 0; i < depth; i++) {
648: frp = nextfunc(frp, &f);
649: assert(frp != nil);
650: }
651: curfunc = f;
652: *curframe = *frp;
653: showaggrs = false;
654: printcallinfo(curfunc, curframe);
655: }
656: }
657: }
658:
659: /*
660: * Find the entry point of a procedure or function.
661: *
662: * On the VAX we add the size of the register mask (FUNCOFFSET) or
663: * the size of the Modula-2 internal entry sequence, on other machines
664: * (68000's) we add the entry sequence size (FUNCOFFSET) unless
665: * we're right at the beginning of the program.
666: */
667:
668: public findbeginning (f)
669: Symbol f;
670: {
671: if (isinternal(f)) {
672: f->symvalue.funcv.beginaddr += 18; /* VAX only */
673: } else {
674: f->symvalue.funcv.beginaddr += FUNCOFFSET;
675: }
676: }
677:
678: /*
679: * Return the address corresponding to the first line in a function.
680: */
681:
682: public Address firstline(f)
683: Symbol f;
684: {
685: Address addr;
686:
687: addr = codeloc(f);
688: while (linelookup(addr) == 0 and addr < objsize) {
689: ++addr;
690: }
691: if (addr == objsize) {
692: addr = -1;
693: }
694: return addr;
695: }
696:
697: /*
698: * Catcher drops strike three ...
699: */
700:
701: public runtofirst()
702: {
703: Address addr, endaddr;
704:
705: addr = pc;
706: endaddr = objsize + CODESTART;
707: while (linelookup(addr) == 0 and addr < endaddr) {
708: ++addr;
709: }
710: if (addr < endaddr) {
711: stepto(addr);
712: }
713: }
714:
715: /*
716: * Return the address corresponding to the end of the program.
717: *
718: * We look for the entry to "exit".
719: */
720:
721: public Address lastaddr()
722: {
723: Symbol s;
724:
725: s = lookup(identname("exit", true));
726: if (s == nil) {
727: panic("can't find exit");
728: }
729: return codeloc(s);
730: }
731:
732: /*
733: * Decide if the given function is currently active.
734: *
735: * We avoid calls to "findframe" during a stack trace for efficiency.
736: * Presumably information evaluated while walking the stack is active.
737: */
738:
739: public Boolean isactive (f)
740: Symbol f;
741: {
742: Boolean b;
743:
744: if (isfinished(process)) {
745: b = false;
746: } else {
747: if (walkingstack or f == program or f == nil or
748: (ismodule(f) and isactive(container(f)))) {
749: b = true;
750: } else {
751: b = (Boolean) (findframe(f) != nil);
752: }
753: }
754: return b;
755: }
756:
757: /*
758: * Evaluate a call to a procedure.
759: */
760:
761: public callproc(exprnode, isfunc)
762: Node exprnode;
763: boolean isfunc;
764: {
765: Node procnode, arglist;
766: Symbol proc;
767: integer argc;
768:
769: procnode = exprnode->value.arg[0];
770: arglist = exprnode->value.arg[1];
771: if (procnode->op != O_SYM) {
772: beginerrmsg();
773: fprintf(stderr, "can't call \"");
774: prtree(stderr, procnode);
775: fprintf(stderr, "\"");
776: enderrmsg();
777: }
778: assert(procnode->op == O_SYM);
779: proc = procnode->value.sym;
780: if (not isblock(proc)) {
781: error("\"%s\" is not a procedure or function", symname(proc));
782: }
783: endproc.isfunc = isfunc;
784: endproc.callnode = exprnode;
785: endproc.cmdnode = topnode;
786: pushenv();
787: pc = codeloc(proc);
788: argc = pushargs(proc, arglist);
789: setreg(FRP, 1); /* have to ensure it's non-zero for return_addr() */
790: beginproc(proc, argc);
791: event_once(
792: build(O_EQ, build(O_SYM, pcsym), build(O_SYM, retaddrsym)),
793: buildcmdlist(build(O_PROCRTN, proc))
794: );
795: isstopped = false;
796: if (not bpact()) {
797: isstopped = true;
798: cont(0);
799: }
800: /*
801: * bpact() won't return true, it will call printstatus() and go back
802: * to command input if a breakpoint is found.
803: */
804: /* NOTREACHED */
805: }
806:
807: /*
808: * Push the arguments on the process' stack. We do this by first
809: * evaluating them on the "eval" stack, then copying into the process'
810: * space.
811: */
812:
813: private integer pushargs(proc, arglist)
814: Symbol proc;
815: Node arglist;
816: {
817: Stack *savesp;
818: int argc, args_size;
819:
820: savesp = sp;
821: if (varIsSet("$unsafecall")) {
822: argc = unsafe_evalargs(proc, arglist);
823: } else {
824: argc = evalargs(proc, arglist);
825: }
826: args_size = sp - savesp;
827: setreg(STKP, reg(STKP) - args_size);
828: dwrite(savesp, reg(STKP), args_size);
829: sp = savesp;
830: return argc;
831: }
832:
833: /*
834: * Check to see if an expression is correct for a given parameter.
835: * If the given parameter is false, don't worry about type inconsistencies.
836: *
837: * Return whether or not it is ok.
838: */
839:
840: private boolean chkparam (actual, formal, chk)
841: Node actual;
842: Symbol formal;
843: boolean chk;
844: {
845: boolean b;
846:
847: b = true;
848: if (chk) {
849: if (formal == nil) {
850: beginerrmsg();
851: fprintf(stderr, "too many parameters");
852: b = false;
853: } else if (not compatible(formal->type, actual->nodetype)) {
854: beginerrmsg();
855: fprintf(stderr, "type mismatch for %s", symname(formal));
856: b = false;
857: }
858: }
859: if (b and formal != nil and
860: isvarparam(formal) and not isopenarray(formal->type) and
861: not (
862: actual->op == O_RVAL or actual->nodetype == t_addr or
863: (
864: actual->op == O_TYPERENAME and
865: (
866: actual->value.arg[0]->op == O_RVAL or
867: actual->value.arg[0]->nodetype == t_addr
868: )
869: )
870: )
871: ) {
872: beginerrmsg();
873: fprintf(stderr, "expected variable, found \"");
874: prtree(stderr, actual);
875: fprintf(stderr, "\"");
876: b = false;
877: }
878: return b;
879: }
880:
881: /*
882: * Pass an expression to a particular parameter.
883: *
884: * Normally we pass either the address or value, but in some cases
885: * (such as C strings) we want to copy the value onto the stack and
886: * pass its address.
887: *
888: * Another special case raised by strings is the possibility that
889: * the actual parameter will be larger than the formal, even with
890: * appropriate type-checking. This occurs because we assume during
891: * evaluation that strings are null-terminated, whereas some languages,
892: * notably Pascal, do not work under that assumption.
893: */
894:
895: private passparam (actual, formal)
896: Node actual;
897: Symbol formal;
898: {
899: boolean b;
900: Address addr;
901: Stack *savesp;
902: integer actsize, formsize;
903:
904: if (formal != nil and isvarparam(formal) and
905: (not isopenarray(formal->type))
906: ) {
907: addr = lval(actual->value.arg[0]);
908: push(Address, addr);
909: } else if (passaddr(formal, actual->nodetype)) {
910: savesp = sp;
911: eval(actual);
912: actsize = sp - savesp;
913: setreg(STKP,
914: reg(STKP) - ((actsize + sizeof(Word) - 1) & ~(sizeof(Word) - 1))
915: );
916: dwrite(savesp, reg(STKP), actsize);
917: sp = savesp;
918: push(Address, reg(STKP));
919: if (formal != nil and isopenarray(formal->type)) {
920: push(integer, actsize div size(formal->type->type));
921: }
922: } else if (formal != nil) {
923: formsize = size(formal);
924: savesp = sp;
925: eval(actual);
926: actsize = sp - savesp;
927: if (actsize > formsize) {
928: sp -= (actsize - formsize);
929: }
930: } else {
931: eval(actual);
932: }
933: }
934:
935: /*
936: * Evaluate an argument list left-to-right.
937: */
938:
939: private integer evalargs(proc, arglist)
940: Symbol proc;
941: Node arglist;
942: {
943: Node p, actual;
944: Symbol formal;
945: Stack *savesp;
946: integer count;
947: boolean chk;
948:
949: savesp = sp;
950: count = 0;
951: formal = proc->chain;
952: chk = (boolean) (not nosource(proc));
953: for (p = arglist; p != nil; p = p->value.arg[1]) {
954: assert(p->op == O_COMMA);
955: actual = p->value.arg[0];
956: if (not chkparam(actual, formal, chk)) {
957: fprintf(stderr, " in call to %s", symname(proc));
958: sp = savesp;
959: enderrmsg();
960: }
961: passparam(actual, formal);
962: if (formal != nil) {
963: formal = formal->chain;
964: }
965: ++count;
966: }
967: if (chk) {
968: if (formal != nil) {
969: sp = savesp;
970: error("not enough parameters to %s", symname(proc));
971: }
972: }
973: return count;
974: }
975:
976: /*
977: * Evaluate an argument list without any type checking.
978: * This is only useful for procedures with a varying number of
979: * arguments that are compiled -g.
980: */
981:
982: private integer unsafe_evalargs (proc, arglist)
983: Symbol proc;
984: Node arglist;
985: {
986: Node p;
987: integer count;
988:
989: count = 0;
990: for (p = arglist; p != nil; p = p->value.arg[1]) {
991: assert(p->op == O_COMMA);
992: eval(p->value.arg[0]);
993: ++count;
994: }
995: return count;
996: }
997:
998: public procreturn(f)
999: Symbol f;
1000: {
1001: integer retvalsize;
1002: Node tmp;
1003: char *copy;
1004:
1005: flushoutput();
1006: popenv();
1007: if (endproc.isfunc) {
1008: retvalsize = size(f->type);
1009: if (retvalsize > sizeof(long)) {
1010: pushretval(retvalsize, true);
1011: copy = newarr(char, retvalsize);
1012: popn(retvalsize, copy);
1013: tmp = build(O_SCON, copy);
1014: } else {
1015: tmp = build(O_LCON, (long) (reg(0)));
1016: }
1017: tmp->nodetype = f->type;
1018: tfree(endproc.callnode);
1019: *(endproc.callnode) = *(tmp);
1020: dispose(tmp);
1021: eval(endproc.cmdnode);
1022: } else {
1023: putchar('\n');
1024: printname(stdout, f);
1025: printf(" returns successfully\n");
1026: }
1027: erecover();
1028: }
1029:
1030: /*
1031: * Push the current environment.
1032: */
1033:
1034: private pushenv()
1035: {
1036: push(Address, pc);
1037: push(Lineno, curline);
1038: push(String, cursource);
1039: push(Boolean, isstopped);
1040: push(Symbol, curfunc);
1041: push(Frame, curframe);
1042: push(struct Frame, curframerec);
1043: push(CallEnv, endproc);
1044: push(Word, reg(PROGCTR));
1045: push(Word, reg(STKP));
1046: push(Word, reg(FRP));
1047: }
1048:
1049: /*
1050: * Pop back to the real world.
1051: */
1052:
1053: public popenv()
1054: {
1055: String filename;
1056:
1057: setreg(FRP, pop(Word));
1058: setreg(STKP, pop(Word));
1059: setreg(PROGCTR, pop(Word));
1060: endproc = pop(CallEnv);
1061: curframerec = pop(struct Frame);
1062: curframe = pop(Frame);
1063: curfunc = pop(Symbol);
1064: isstopped = pop(Boolean);
1065: filename = pop(String);
1066: curline = pop(Lineno);
1067: pc = pop(Address);
1068: setsource(filename);
1069: }
1070:
1071: /*
1072: * Flush the debuggee's standard output.
1073: *
1074: * This is VERY dependent on the use of stdio.
1075: */
1076:
1077: public flushoutput()
1078: {
1079: Symbol p, iob;
1080: Stack *savesp;
1081:
1082: p = lookup(identname("fflush", true));
1083: while (p != nil and not isblock(p)) {
1084: p = p->next_sym;
1085: }
1086: if (p != nil) {
1087: iob = lookup(identname("_iob", true));
1088: if (iob != nil) {
1089: pushenv();
1090: pc = codeloc(p) - FUNCOFFSET;
1091: savesp = sp;
1092: push(long, address(iob, nil) + sizeof(*stdout));
1093: setreg(STKP, reg(STKP) - sizeof(long));
1094: dwrite(savesp, reg(STKP), sizeof(long));
1095: sp = savesp;
1096: beginproc(p, 1);
1097: stepto(return_addr());
1098: popenv();
1099: }
1100: }
1101: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.