![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fudge.c.3b 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.3b 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 <stdio.h>
14: #include "hw_stack.h"
15:
16: // 3B frame fudger
17:
18: //Frames not self-describing!
19: //STACK GROWS UP
20:
21: #ifdef u3b
22: /*
23: * On the 3B20, the call instruction is call num,dst
24: * where num is the number of arguments to the function
25: * and dst is the address of the called function.
26: * There are 4 possible opcodes for the call instruction:
27: * 3 are optimizations possible when num can be represented in 4 bits
28: * (the usual case), and further depend on the addressing mode used.
29: * This code assumes that destination addresses will only be
30: * pc-relative, absolute, or absolute deferred.
31: */
32:
33: const GEN_CALL = 0x78;
34: const OPT_GEN_CALL = 0x79;
35: const PC_REL_CALL = 0x77;
36: const IMM_CALL = 0xB9;
37:
38: const ABSOLUTE_DESC = 0x08;
39: const PC_REL_DESC = 0x06;
40: const ABSOLUTE_DEF_DESC = 0x09;
41:
42: #define IS_CALL_OPCODE(instr) \
43: (((MACHINE_BYTE)(instr) == (MACHINE_BYTE)GEN_CALL) || \
44: ((MACHINE_BYTE)(instr) == (MACHINE_BYTE)OPT_GEN_CALL) || \
45: ((MACHINE_BYTE)(instr) == (MACHINE_BYTE)PC_REL_CALL) || \
46: ((MACHINE_BYTE)(instr) == (MACHINE_BYTE)IMM_CALL))
47:
48: const N_CALL_INSTR_SIZES = 3;
49: short call_size[N_CALL_INSTR_SIZES] = {4, 6, 7};
50:
51: #undef SAVE_OPERAND /* not needed for u3b */
52:
53: /* src op is not important in decoding the call instruction on u3b */
54: #define SRC_OP_DESC(instr) /* not needed for u3b */
55: #define IS_LEGAL_SRC_OP() 1
56: #undef SRC_OP_SIZE /* not needed for u3b */
57: const OPCODE_SIZE = 1;
58: const OPERAND1_SIZE = 1;
59:
60: #define DST_OP_DESC(instr) \
61: (((unsigned char *)(instr))[OPCODE_SIZE] & 0x0f)
62:
63: #define IS_LEGAL_DST_OP(desc) \
64: (((desc) == ABSOLUTE_DESC) || \
65: ((desc) == PC_REL_DESC) || \
66: ((desc) == ABSOLUTE_DEF_DESC) \
67: )
68: #define HAS_LEGAL_OPERANDS(call_instr) \
69: (IS_LEGAL_DST_OP((DST_OP_DESC(poss_callp))) || \
70: (call_instr[0] == PC_REL_CALL))
71:
72:
73: /* Given a pointer to a call instruction,
74: * yield a pointer to the called function */
75: unsigned int
76: call_dst_ptr(unsigned char* callp)
77: {
78: int offset = 0;
79: // points past operand1 and/or descriptor to address or offset
80: unsigned char* dst_op_p = callp + OPCODE_SIZE + OPERAND1_SIZE;
81: switch(*callp) {
82: case PC_REL_CALL: // 16-bit pc-relative address
83: offset = dst_op_p[0] << 8 | dst_op_p[1];
84: if (callp[1] & 0x80) // negative offset
85: offset = -(offset);
86: unsigned char* next_pc = callp + 4; // relative to NEXT pc
87: return (unsigned int)((short*)next_pc + offset);
88: case GEN_CALL:
89: case OPT_GEN_CALL:
90: switch(DST_OP_DESC(callp)) {
91: case ABSOLUTE_DESC: // 24-bit absolute address
92: return (dst_op_p[0] << 20 |
93: dst_op_p[1] << 12 |
94: dst_op_p[2] << 4 |
95: dst_op_p[3] >> 4 ) & 0x00ffffff;
96: case ABSOLUTE_DEF_DESC: // 24-bit absolute deferred address
97: int* addr_p =
98: (int*) ((dst_op_p[0] << 20 |
99: dst_op_p[1] << 12 |
100: dst_op_p[2] << 4 |
101: dst_op_p[3] >> 4 ) & 0x00ffffff);
102: return (unsigned int)(*addr_p);
103: case PC_REL_DESC: // 24-bit pc-relative address
104: offset = (dst_op_p[0] << 20 |
105: dst_op_p[1] << 12 |
106: dst_op_p[2] << 4 |
107: dst_op_p[3] >> 4 );
108: if (dst_op_p[0] & 0x08) // negative offset
109: offset |= 0xff000000;
110: else // positive offset
111: offset &= 0x00ffffff;
112: return (unsigned int)(callp + offset);
113: default: // illegal descriptor
114: object::task_error(E_FUNCS, (object*)0);
115: }
116: case IMM_CALL: // 24-bit immediate address
117: return (dst_op_p[0] << 20 |
118: dst_op_p[1] << 12 |
119: dst_op_p[2] << 4 |
120: dst_op_p[3] >> 4 ) & 0x00ffffff;
121: default: // illegal call instruction
122: object::task_error(E_FUNCS, (object*)0);
123: }
124: } /* call_dst_ptr */
125:
126:
127: #else /* m32: u3b2, u3b5, u3b15 */
128:
129: /*
130: * On the 3B2, the call instruction is CALL src,dst
131: * where src is the address of the new ap (where the args were
132: * already pushed on the stack) and dst is the address of the
133: * called function. src and dst can be various lengths:
134: * src will be a byte, halfword, or word displacement
135: * and dst will be absolute, or be a byte, halfword, or word displacement.
136: * Byte displacement = 2 bytes, halfword = 3, word = 5;
137: * the opcode = 1 byte; absolute = 5 bytes--12 possible combinations
138: * and 6 possible instr lengths.
139: */
140:
141:
142: #define IS_CALL_OPCODE(instr) ((MACHINE_BYTE)(instr) == (MACHINE_BYTE)0x2c)
143:
144: const BYTE_DISPL = 0xC0;
145: const HALFWORD_DISPL = 0xA0;
146: const WORD_DISPL = 0x80;
147: const ABSOLUTE = 0x70;
148: const REG_SP = 0x0C;
149: const REG_PC = 0x0F;
150:
151: const N_CALL_INSTR_SIZES = 6;
152: short call_size[N_CALL_INSTR_SIZES] = {5, 6, 7, 8, 9, 11};
153:
154: /* CALL's src operand descriptor needed to determine size of src operand */
155: #define SRC_OP_DESC(instr) (((unsigned char *)(instr))[1])
156: #define SRC_OP_SIZE(desc) \
157: ((MODE_FIELD(desc) == BYTE_DISPL) ? 2 : \
158: (MODE_FIELD(desc) == HALFWORD_DISPL) ? 3 : \
159: (MODE_FIELD(desc) == WORD_DISPL) ? 5 : \
160: ((object::task_error(E_FUNCS, (object*)0))) \
161: )
162: const OPCODE_SIZE = 1;
163: const DESC_SIZE = 1;
164:
165: #define DST_OP_DESC(instr) \
166: (((unsigned char *)(instr)) \
167: [OPCODE_SIZE + SRC_OP_SIZE(SRC_OP_DESC(instr))])
168: #define MODE_FIELD(desc) ((desc) & 0xf0)
169: #define REG_FIELD(desc) ((desc) & 0x0f)
170:
171: #define IS_LEGAL_SRC_OP(desc) /* assumes sp-relative displ */ \
172: (((MODE_FIELD(desc) == BYTE_DISPL) || \
173: (MODE_FIELD(desc) == HALFWORD_DISPL) || \
174: (MODE_FIELD(desc) == WORD_DISPL) \
175: ) && (REG_FIELD(desc) == REG_SP) \
176: )
177: /* destination displacement is probably pc-relative, but we don't
178: * make that assumption. It could be a call through a function pointer.
179: */
180: #define IS_LEGAL_DST_OP(desc) \
181: ((MODE_FIELD(desc) == BYTE_DISPL) || \
182: (MODE_FIELD(desc) == HALFWORD_DISPL) || \
183: (MODE_FIELD(desc) == WORD_DISPL) || \
184: ((MODE_FIELD(desc) == ABSOLUTE) && (REG_FIELD(desc) == REG_PC))\
185: )
186: #define HAS_LEGAL_OPERANDS(call_instr) \
187: (IS_LEGAL_SRC_OP((SRC_OP_DESC(call_instr))) \
188: && IS_LEGAL_DST_OP((DST_OP_DESC(call_instr))))
189:
190:
191: /* Given a pointer to a call instruction, yield a pointer to
192: * the called function */
193: unsigned int
194: call_dst_ptr(unsigned char* callp)
195: {
196: int sop_size = SRC_OP_SIZE(SRC_OP_DESC(callp));
197: unsigned char* dst_op_p =
198: /* points past the dst desc, to addr or offset */
199: callp + OPCODE_SIZE + sop_size + DESC_SIZE;
200: int offset = 0; // offset for displacement modes
201: switch(MODE_FIELD(DST_OP_DESC(callp))) {
202: case BYTE_DISPL:
203: offset = dst_op_p[0];
204: if(*dst_op_p & 0x80) {
205: /* negative--do sign extension for offset */
206: offset |= 0xffffff00;
207: }
208: return (unsigned int)(callp + offset);
209: case HALFWORD_DISPL:
210: // bytes are in reverse order, must flip positions
211: offset = dst_op_p[0] | dst_op_p[1] << 8;
212: if(dst_op_p[1] & 0x80) {
213: /* negative--do sign extension for offset */
214: offset |= 0xffff0000;
215: }
216: return (unsigned int)(callp + offset);
217: case WORD_DISPL:
218: // bytes are in reverse order, must flip positions
219: offset = dst_op_p[0] |
220: dst_op_p[1] << 8 |
221: dst_op_p[2] << 16 |
222: dst_op_p[3] << 24;
223: /* don't need sign extension */
224: return (unsigned int)(callp + offset);
225: case ABSOLUTE:
226: return
227: dst_op_p[0] |
228: dst_op_p[1] << 8 |
229: dst_op_p[2] << 16 |
230: dst_op_p[3] << 24;
231: default:
232: object::task_error(E_FUNCS, (object*)0);
233: }
234: } /* call_dst_ptr */
235:
236: #endif /* m32: u3b2, u3b5, u3b15 */
237:
238: FrameLayout::FrameLayout(int* fp)
239: {
240: /*
241: * Given a frame pointer, find the number of regs saved in the frame.
242: * The idea is that the instruction immediately before the return pc
243: * is the function call, and contains a pointer to the first
244: * instruction in the function denoted by the fp, which will be a save
245: * instruction. We can decode the save instruction to find how many
246: * registers were saved.
247: */
248:
249: int* return_pc = (int*)OLD_PC(fp);
250:
251: unsigned char* callp = NULL;
252: /* Because this method is nondeterministic, try all combinations
253: instead of stopping when one fits */
254: for(int i = 0; i < N_CALL_INSTR_SIZES; i++) {
255: unsigned char* poss_callp =
256: (unsigned char *)return_pc - call_size[i];
257: if ((IS_CALL_OPCODE(*poss_callp))
258: && HAS_LEGAL_OPERANDS(poss_callp)) {
259: if(!callp) callp = poss_callp;
260: else { // try some heuristics to disambiguate
261: // (Don't try to dereference dst ptr
262: // until sure, or necessary to disambiguate,
263: // to avoid unnecessary core dumps.)
264: // If first callp dst points to a save,
265: // assume that is the instruction we want.
266: if (!IS_SAVE_OPCODE(
267: *(unsigned char *)(call_dst_ptr(callp))) ) {
268: if (IS_SAVE_OPCODE(
269: *(unsigned char *)(call_dst_ptr(poss_callp))) ) {
270: callp = poss_callp;
271: } else {
272: // neither is right, go on
273: callp = 0;
274: }
275:
276: }
277: }
278: }
279: }
280: if (callp == NULL) object::task_error(E_FUNCS, (object*)0); //No match!
281: unsigned int func_addr = call_dst_ptr(callp);
282: if (!(IS_SAVE_OPCODE( *(unsigned char *)func_addr) ))
283: object::task_error(E_FUNCS, (object*)0);
284: n_saved = N_SAVED_REGS(func_addr);
285: }
286:
287: /*
288: * Fudge frame of function-defined-by-f_fp (called "f" below)
289: * so that that function returns to its grandparent,
290: * in particular, so a parent task returns to the function that
291: * called the derived constructor (de_ctor), skipping de_ctor;
292: * the child will return to the derived constructor, which is its "main."
293: * To do this we will overwrite the old fp, ap, and pc (those saved by
294: * f) with the old-old ones (those saved by f's caller),
295: * and we will overwrite the register save area with registers saved by
296: * f's caller (referred to as "skip" below).
297: *
298: * There are 2 register-save cases to deal with:
299: * 1. skip_n_saved <= f_n_saved
300: * 2. skip_n_saved > f_n_saved
301: *
302: * These are handled as follows:
303: * 1. copy the saved skip_regs over the corresponding f_regs,
304: * leaving any additional saved f_regs intact.
305: * f's restore instruction will be correct.
306: * 2. f's restore instruction will restore too few regs, must take special
307: * care to see that the extras are restored properly.
308: * -Copy saved skip_regs over any corresponding f_regs,
309: * -If fudge_return saved more regs than f did, then
310: * copy saved extra saved skip_regs over any corresponding fudge_regs,
311: * -If more extra skip_regs (not saved by either f or fudge_return,
312: * and therefore not used by either) remain, restore them explicitly.
313: * They will not be disturbed by the return from fudge_return or f,
314: */
315: void
316: task::fudge_return(int* f_fp)
317: {
318: register int* fp = f_fp; // fp of frame-to-be-fudged
319: FrameLayout lo(fp); // frame to be fudged
320: register int* skip_fp = (int*)OLD_FP(fp); // fp for f's caller (skip)
321: FrameLayout skip_lo(skip_fp); // frame for skip
322:
323: OLD_PC(fp) = OLD_PC(skip_fp);
324: OLD_AP(fp) = OLD_AP(skip_fp);
325: OLD_FP(fp) = OLD_FP(skip_fp);
326:
327: // finally copy saved regs
328: register int* from = LAST_SAVED_REG_P(skip_fp, skip_lo.n_saved);
329: register int* to = LAST_SAVED_REG_P(fp, lo.n_saved);
330: register int i;
331: if(lo.n_saved >= skip_lo.n_saved) {
332: // copy the saved skip regs over the corresponding f regs,
333: // leaving any additional saved f regs intact.
334: for(i = skip_lo.n_saved; i > 0; i--) {
335: *to-- = *from--;
336: }
337: } else { // lo.n_saved < skip_lo.n_saved--take care!
338: // copy the saved skip regs over any corresponding
339: // f regs.
340: for(i = lo.n_saved; i > 0; i--) {
341: *to-- = *from--;
342: }
343: int extra = skip_lo.n_saved - lo.n_saved;
344: // If fudge_return saved more regs than f, extra skip_regs
345: // should be copied over any corresponding fudge_return regs.
346: int* fr_fp = FP(); // fp for fudge_return
347: FrameLayout fr_lo(fr_fp); // frame for fudge_return
348: if (fr_lo.n_saved >= lo.n_saved) {
349: to = LAST_SAVED_REG_P(fr_fp, fr_lo.n_saved) - lo.n_saved;
350: int n;
351: int d = fr_lo.n_saved - lo.n_saved;
352: if (d >= extra) { // room for all extra skip_regs
353: n = extra;
354: } else {
355: n = d;
356: }
357: for(i = n; i > 0; i--) {
358: *to-- = *from--;
359: extra--;
360: }
361: }
362: if (extra) { // Remaining skip regs must be explicitly restored.
363: int r = skip_lo.n_saved - extra + 1;
364: for (i = extra; i > 0; i--) {
365: switch (r++) {
366: case 6:
367: set_r3(from);
368: from--;
369: break;
370: case 5:
371: set_r4(from);
372: from--;
373: break;
374: case 4:
375: set_r5(from);
376: from--;
377: break;
378: case 3:
379: set_r6(from);
380: from--;
381: break;
382: case 2:
383: set_r7(from);
384: from--;
385: break;
386: case 1:
387: set_r8(from);
388: from--;
389: break;
390: }
391: }
392: }
393: }
394: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.