![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sweep.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / icon / rt|
Return to sweep.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / icon / rt |
1.1 root 1: #include "../h/rt.h"
2: #include "../h/gc.h"
3: #ifdef VAX
4: /*
5: * sweep - sweep the stack, marking all descriptors there. Method
6: * is to start at a known point, specifically, the frame that the
7: * fp points to, and then trace back along the stack looking for
8: * descriptors and local variables, marking them when they are found.
9: * The sp starts at the first frame, and then is moved up through
10: * the stack. Procedure, generator, and expression frames are
11: * recognized when the sp is a certain distance from the fp, gfp,
12: * and efp respectively.
13: *
14: * Sweeping problems can be manifested in a variety of ways due to
15: * the "if it can't be identified it's a descriptor" methodology.
16: */
17: #undef gfp
18: #undef efp
19: #undef fp
20: sweep(fp)
21: int *fp;
22: {
23: register int *sp, *gfp, *efp, *ap;
24: int *getap();
25: int nargs;
26:
27: ap = getap(fp); /* Get pointer to 0(ap) for frame
28: on top of stack. */
29: sp = fp - FRAMELIMIT; /* Start sp at _file word of current
30: frame, the lowest word of it. */
31: nargs = 0; /* Nargs counter is 0 initially. */
32: while ((fp != 0 || nargs)) { /* Keep going until current fp is
33: 0 and no arguments are left. */
34: if (sp == fp - FRAMELIMIT) { /* The sp has reached the lower
35: boundary of a procedure frame,
36: process the frame. */
37: efp = (int *) ap[-1]; /* Get saved efp out of frame, it's
38: the first word below 0(ap). */
39: gfp = (int *) ap[-2]; /* Saved gfp is second word below
40: 0(ap). */
41: sp = ap + 2; /* First argument descriptor is
42: second word above 0(ap), point
43: sp at it. */
44: ap = (int *) fp[2]; /* Get saved ap */
45: fp = (int *) fp[3]; /* and fp from frame. */
46: nargs = sp[-1]; /* Nargs is in word below first
47: argument descriptor. */
48: }
49: else if (sp == gfp - 3) { /* The sp has reached the lower end
50: of a generator frame, process
51: the frame.*/
52: fp = (int *) gfp[0]; /* Get old fp, available as saved
53: boundary value in the frame. */
54: ap = getap(fp); /* Find 0(ap) corresponding to just-
55: restored boundary value. */
56: sp = fp - FRAMELIMIT; /* Set up to trigger recognition of
57: procedure frame next time around*/
58: }
59: else if (sp == efp - 2) { /* The sp has reached the lower end
60: of a generator frame, process
61: the frame. */
62: gfp = (int *) efp[-1]; /* Restore gfp, */
63: efp = (int *) efp[0]; /* and efp from frame. */
64: sp += 3; /* Move up past expression frame
65: marker. */
66: }
67: else { /* Assume the sp is pointing at a
68: descriptor. */
69: mark(sp); /* Mark it. */
70: sp += 2; /* Move past descriptor. */
71: if (nargs) /* Decrement argument count if in an*/
72: nargs--; /* argument list. */
73: }
74: }
75: }
76: /*
77: * getap - return ap of frame addressed by fp
78: */
79: int *getap(fp)
80: register int *fp;
81: {
82: register
83: int mask = fp[1]>>15 & 0x1ffe; /* Get register mask out of saved
84: psw word. */
85: fp += 5; /* Point fp at where first saved
86: register (if any) is. */
87: while (mask >>= 1) /* Move fp up for each register */
88: fp += mask & 1; /* saved. When done, fp points */
89: return fp; /* at word where ap would point */
90: }
91: #endif VAX
92:
93: #ifdef PORT
94: sweep()
95: {
96: syserr("Call to sweep() in garbage collector not implemented yet");
97: }
98: #endif PORT
99:
100: #ifdef PDP11
101: /*
102: * sweep - sweep the stack, marking all descriptors there.
103: */
104:
105: sweep(b)
106: int *b;
107: {
108: register int *sp, *r5, *r4;
109: int *r3, nargs;
110:
111: r5 = b; /* start at last Icon/C boundary */
112: sp = r5 - 5;
113: nargs = 0;
114: while ((r5 != 0 || nargs) && sp < (int *)0177776) {
115: if (sp == r5 - 5) { /* at a procedure frame */
116: r3 = r5[-2];
117: r4 = r5[-1];
118: r5 = r5[0];
119: sp += 8;
120: nargs = sp[-1];
121: }
122: else if (sp == r3 - 3) { /* at a generator frame */
123: r5 = r3[0]; /* go to next boundary */
124: sp = r5 - 5;
125: }
126: else if (sp == r4 - 2) { /* at an expression frame */
127: r3 = r4[-1];
128: r4 = r4[0];
129: sp += 3;
130: }
131: else { /* must be a descriptor! */
132: mark(sp);
133: sp += 2;
134: if (nargs)
135: nargs--;
136: }
137: }
138: }
139: #endif PDP11
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.