![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fudge.c.68k CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / libC / task|
Return to fudge.c.68k CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / libC / task |
1.1 root 1: /*ident "%W%" */
2: /**************************************************************************
3: Copyright (c) 1984 AT&T
4: All Rights Reserved
5:
6: THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T
7:
8: The copyright notice above does not evidence any
9: actual or intended publication of such source code.
10:
11: *****************************************************************************/
12: #include <task.h>
13: #include "hw_stack.h"
14:
15: // Sun MC68000 frame fudger
16:
17: /* careful -- stack frame not self-describing */
18: // STACK GROWS DOWN
19:
20: /*
21: * On the 68K Suns, the four forms of function call generated
22: * by the compiler are:
23: * jsr followed by the function address (int)
24: * bsrl followed by the function offset (int) (68020 only)
25: * bsr followed by the function offset (short)
26: * bsrb low order byte is the offset
27: * (not actually seen or tested)
28: */
29: const JSR_CALL = 047271;
30: const BSRL_CALL = 060777;
31: const BSR_CALL = 060400;
32: const BSRB_CALL = 0x61; // Really 0x61NN, where NN is the offset.
33:
34: /* On the 68K Suns, the function prologue may include the following
35: * instructions. See FrameLayout for sequencing.
36: */
37: const LINKW = 047126; // linkw a6,xxx
38: const ADDL = 0157774; // addl #yyy,sp
39: const MOVLA5 = 027215; // movl a5,sp@
40: const MOVLD7 = 027207; // movl d7,sp@
41: const MOVEM = 044327; // movem mask,sp@
42: // (for movem M,a6@(xx) )
43:
44: int* Skip_pc_p; // global to hold fudged return pc.
45: // See comments in hw_stack.c.
46:
47: FrameLayout::FrameLayout(int* fp)
48: {
49: unsigned short* ret_addr = (unsigned short*)OLD_PC(fp);
50: /*
51: * find the starting address of the function. The idea is that the
52: * instruction immediately before the return address must be the function call.
53: * Only works if the function was called by name.
54: */
55: unsigned short* func_addr =
56: (ret_addr[-3] == JSR_CALL) ?
57: (unsigned short*)*(int*)(ret_addr-2) :
58: (ret_addr[-3] == BSRL_CALL) ?
59: (unsigned short*) ((char*)(ret_addr-2)
60: + *(int*)(ret_addr-2)) :
61: (ret_addr[-2] == BSR_CALL) ?
62: (unsigned short*) ((char*)(ret_addr-1)
63: + *(short*)(ret_addr-1)) :
64: (*(char*)(ret_addr-1) == BSRB_CALL) ?
65: (unsigned short*) ((char*)ret_addr
66: + *((char*)ret_addr-1)) :
67: (unsigned short*)object::task_error(E_FUNCS, (object*)0);
68: /*
69: * the first instruction in the function is linkw a6,xxx
70: * if -O was used, xxx is the frame size in bytes (saved regs + automatics),
71: * otherwise xxx is 0 and the next instruction is addl #yyy, sp
72: * where yyy is the frame size.
73: */
74: if (*func_addr == LINKW) {
75: if ((offset = (short)*++func_addr / 4) == 0)
76: if (*++func_addr == ADDL)
77: offset = (short)*(func_addr += 2) / 4;
78: } else object::task_error(E_FRAMES, (object*)0);
79: /*
80: * The next instruction saves the registers in the frame. Possibilities are:
81: * movem mask,sp@ | save the regs specified by the mask word
82: * movl a5,sp@ | just save a5
83: * movl d7,sp@ | just save d7
84: * The mask uses the standard 68000 layout
85: */
86: switch (*++func_addr) {
87: case MOVLA5: // movl a5,sp@
88: mask = 020000; // just a5
89: break;
90: case MOVEM: // movem mask,sp@
91: mask = *++func_addr; // mask word
92: break;
93: case MOVLD7: // movl d7,sp@
94: mask = 0200; // just d7
95: break;
96: default: // no saved registers is also possible
97: mask = 0;
98: break;
99: }
100: }
101:
102: /*
103: * Fudge frame of function-defined-by-f_fp (called "f" below)
104: * so that that function returns to its grandparent,
105: * in particular, so a parent task returns to the function that
106: * called the derived constructor (de_ctor), skipping de_ctor;
107: * the child will return to the derived constructor, which is its "main."
108: * To do this we will overwrite the old fp and pc (those saved by
109: * f) with the old-old ones (those saved by f's caller),
110: * and we will overwrite the register save area with registers saved by
111: * f's caller (referred to as "skip" below).
112: *
113: * There are 2 register-save cases to deal with:
114: * 1. skip_n_saved <= f_n_saved
115: * 3. skip_n_saved > f_n_saved
116: *
117: * These are handled as follows:
118: * 1. copy the saved skip_regs over the corresponding f_regs,
119: * leaving any additional saved f_regs intact.
120: * f's epilogue instructions will be correct.
121: * 2. f's epilogue instructions will restore too few regs,
122: * must take special care to see that the extras are restored properly.
123: * -Copy saved skip_regs over any corresponding f_regs,
124: * -If fudge_return saved more regs than f did, then
125: * copy saved extra saved skip_regs over any corresponding fudge_regs,
126: * -If more extra skip_regs (not saved by either f or fudge_return,
127: * and therefore not used by either) remain, restore them explicitly.
128: * They will not be disturbed by the return from fudge_return or f,
129: */
130: void
131: task::fudge_return(int* f_fp)
132: {
133: register int* fp = f_fp; // fp of frame-to-be-fudged
134: FrameLayout lo(fp); // frame to be fudged
135: register int* skip_fp = (int*)OLD_FP(fp); // fp for f's caller (skip)
136: FrameLayout skip_lo(skip_fp); // frame for skip
137: register int* fr_fp = FP(); // fp for fudge_return
138: FrameLayout fr_lo(fr_fp); // frame for fudge_return
139:
140: OLD_PC(fp) = (int)&fudge_sp; // task::task will return through
141: // fudge_sp, which will reset the sp
142: // to point at the return-pc in
143: // skip's frame
144: // copy old fp
145: OLD_FP(fp) = OLD_FP(skip_fp);
146:
147: // now copy saved registers
148: // copy any saved skip regs over corresponding f regs; if there isn't
149: // a corresponding f reg, copy over corresponding fudge_return reg;
150: // if there isn't a corresponding fr_reg, restore it explicitly.
151: register int* to = FIRST_SAVED_REG_P(fp, lo.offset);
152: register int* from = FIRST_SAVED_REG_P(skip_fp, skip_lo.offset);
153: register int* fr_to = FIRST_SAVED_REG_P(fr_fp, fr_lo.offset);
154: for (register int m = 1; m != 0x10000; m <<=1) {
155: if (m & lo.mask) {
156: if (m & skip_lo.mask) {
157: *to++ = *from++;
158: if (m & fr_lo.mask) fr_to++;
159: } else { // nothing to copy
160: to++;
161: if (m & fr_lo.mask) fr_to++;
162: }
163: } else if (m & skip_lo.mask) {
164: // No slot for *from in f's frame
165: if (m & fr_lo.mask) { // copy to fudge_return's frame
166: *fr_to++ = *from++;
167: } else {
168: // Not used in f or fudge_return;
169: // restore explicitly
170: switch(m) {
171: case 0x0004:
172: set_d2(from++);
173: break;
174: case 0x0008:
175: set_d3(from++);
176: break;
177: case 0x0010:
178: set_d4(from++);
179: break;
180: case 0x0020:
181: set_d5(from++);
182: break;
183: case 0x0040:
184: set_d6(from++);
185: break;
186: case 0x0080:
187: set_d7(from++);
188: break;
189: case 0x0400:
190: set_a2(from++);
191: break;
192: case 0x0800:
193: set_a3(from++);
194: break;
195: case 0x1000:
196: set_a4(from++);
197: break;
198: case 0x2000:
199: set_a5(from++);
200: break;
201: default:
202: // Oops--don't expect other regs
203: // to be saved
204: from++;
205: task_error(E_REGMASK, this);
206: break;
207: }
208: }
209: }
210: }
211: }
212:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.