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