![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fudge.c.386 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.386 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: // Intel 386 frame fudger
16:
17: /* careful -- stack frame not self-describing */
18: // STACK GROWS DOWN
19:
20: // We define a mask in which FrameLayout can record which regs are saved.
21: // We only care about the non-scratch regs edi, esi, ebx.
22: const short REG_EDI = 0x1;
23: const short REG_ESI = 0x2;
24: const short REG_EBX = 0x4;
25: #define ALL_REGS_SAVED(m) ((short)(m) == 0x0007)
26:
27: const int OPCODE_SIZE = 1;
28: const MACHINE_BYTE CALL_INSTR = 0xe8;
29: const int CALL_SIZE = 5;
30: const MACHINE_BYTE JMP_SHORT = 0xeb;
31: const MACHINE_BYTE JMP_DISPL = 0xe9;
32: // assumes we don't need to worry about jump near indirect (0xff)
33:
34: #define IS_JMP_INSTR(instr) \
35: ((MACHINE_BYTE)(instr) == (MACHINE_BYTE)JMP_SHORT || \
36: (MACHINE_BYTE)(instr) == (MACHINE_BYTE)JMP_DISPL)
37: const MACHINE_BYTE PUSH_EBP_INSTR = 0x55;
38: const int PUSH_SIZE = 1;
39: const MACHINE_BYTE MOV_INSTR = 0x8b;
40: const int MOV_SIZE = 2;
41: const MACHINE_BYTE SUB_INSTR = 0x83;
42: const int SUB_SIZE = 3;
43: const MACHINE_BYTE PUSH_EDI_INSTR = 0x57;
44: const MACHINE_BYTE PUSH_ESI_INSTR = 0x56;
45: const MACHINE_BYTE PUSH_EBX_INSTR = 0x53;
46: #define IS_PUSH_REG_INSTR(instp) \
47: ((*((MACHINE_BYTE*)(instp)) & 0xf0) == 0x50)
48: #define IS_SET_EBP_INSTR(instp) \
49: (((*(instp)) == MOV_INSTR) && (*((MACHINE_BYTE*)(instp) + 1) == 0xec))
50: #define IS_SUB_ESP_INSTR(instp) \
51: ((*((MACHINE_BYTE*)(instp)) == SUB_INSTR) \
52: && (*((MACHINE_BYTE*)(instp) + 1) == 0xec))
53:
54:
55: int* Skip_pc_p; // global to hold fudged return pc.
56: // See comments in hw_stack.c.
57:
58: /* Given a pointer to a call instruction, yield a pointer to
59: * the called function */
60: unsigned int
61: call_dst_ptr(MACHINE_BYTE* callp)
62: {
63: /*
64: * On the Intel 386, the call instruction is: call displ
65: * where the displacement is always relative to the pc.
66: */
67: MACHINE_BYTE* dst_op_p = callp + OPCODE_SIZE;
68: int offset = 0;
69: // bytes are in reverse order, must flip positions
70: offset = dst_op_p[0] |
71: dst_op_p[1] << 8 |
72: dst_op_p[2] << 16 |
73: dst_op_p[3] << 24;
74: return (unsigned int)(callp + CALL_SIZE + offset);
75: }
76:
77: FrameLayout::FrameLayout(int* fp)
78: {
79: mask = 0;
80: unsigned int* return_pc = (unsigned int*)OLD_PC(fp);
81: /*
82: * find the starting address of the function. The idea is that the
83: * instruction immediately before the return address must be the
84: * function call.
85: */
86: MACHINE_BYTE* callp = (MACHINE_BYTE*)return_pc - CALL_SIZE;
87: if (*callp != CALL_INSTR)
88: object::task_error(E_FUNCS, (object*)0);
89: MACHINE_BYTE* func_addr = (MACHINE_BYTE*) call_dst_ptr(callp);
90:
91: /* If first instruction is jmp (-O not used), add displacement to pc
92: * to get to function prologue.
93: * Function prologue should be:
94: * pushl %ebp
95: * movl %esp,%ebp
96: * subl XXX,%esp / XXX is the offset we want
97: * pushl %eXX / a push instruction for each saved reg
98: * / (sometimes first push is of scratch
99: * / reg, and then that is the offset)
100: * / stop when no more push instructions, or have saved all regs
101: */
102: if (IS_JMP_INSTR(*func_addr)) {
103: int displ;
104: if (*func_addr == JMP_SHORT) { // 1 byte displacement
105: displ = func_addr[1];
106: func_addr += 2; // next instruction
107: } else { // JMP_DISPL, 4 byte displacement
108: // bytes reversed
109: displ = func_addr[1] |
110: func_addr[2] << 8 |
111: func_addr[3] << 16 |
112: func_addr[4] << 24;
113: func_addr += 5; // next instruction
114: }
115: func_addr += displ; // jmp destination
116: }
117: if ((*func_addr == PUSH_EBP_INSTR)
118: && (IS_SET_EBP_INSTR(func_addr + PUSH_SIZE))) {
119: func_addr += MOV_SIZE + PUSH_SIZE;
120: if (IS_SUB_ESP_INSTR(func_addr)) {
121: offset = func_addr[2] / 4;
122: func_addr += SUB_SIZE;
123: } else { // assume no automatics to be allocated
124: offset = 0;
125: }
126: } else {
127: object::task_error(E_FUNCS, (object*)0);
128: }
129: while (IS_PUSH_REG_INSTR(func_addr) && (! ALL_REGS_SAVED(mask))) {
130: if (*func_addr == PUSH_EDI_INSTR) {
131: mask |= REG_EDI;
132: func_addr += PUSH_SIZE;
133: } else if (*func_addr == PUSH_ESI_INSTR) {
134: mask |= REG_ESI;
135: func_addr += PUSH_SIZE;
136: } else if (*func_addr == PUSH_EBX_INSTR) {
137: mask |= REG_EBX;
138: func_addr += PUSH_SIZE;
139: } else {
140: // Compiler might push a scratch reg before any non-
141: // scratch regs to reserve space for automatics.
142: if (mask != 0) {
143: // if non-scratch regs already saved,
144: // then this is not an offset
145: break;
146: } else {
147: offset += 1;
148: func_addr += PUSH_SIZE;
149: }
150: }
151:
152: }
153: }
154:
155: /*
156: * Fudge frame of function-defined-by-f_fp (called "f" below)
157: * so that that function returns to its grandparent,
158: * in particular, so a parent task returns to the function that
159: * called the derived constructor, skipping the derived constructor;
160: * the child will return to the derived constructor, which is its "main."
161: * To do this we will overwrite the old fp and pc (those saved by
162: * f) with the old-old ones (those saved by f's caller),
163: * and we will overwrite the register save area with registers saved by
164: * f's caller (referred to as "skip" below).
165: *
166: * There are 2 register-save cases to deal with:
167: * 1. skip_n_saved <= f_n_saved
168: * 3. skip_n_saved > f_n_saved
169: *
170: * These are handled as follows:
171: * 1. copy the saved skip_regs over the corresponding f_regs,
172: * leaving any additional saved f_regs intact.
173: * f's epilogue instructions will be correct.
174: * 2. f's epilogue instructions will restore too few regs,
175: * must take special care to see that the extras are restored properly.
176: * -Copy saved skip_regs over any corresponding f_regs,
177: * -If fudge_return saved more regs than f did, then
178: * copy saved extra saved skip_regs over any corresponding fudge_regs,
179: * -If more extra skip_regs (not saved by either f or fudge_return,
180: * and therefore not used by either) remain, restore them explicitly.
181: * They will not be disturbed by the return from fudge_return or f.
182: */
183: void
184: task::fudge_return(int* f_fp)
185: {
186: register int* fp = f_fp; // fp of frame-to-be-fudged
187: FrameLayout lo(fp); // frame to be fudged
188: register int* skip_fp = (int*)OLD_FP(fp); // fp for f's caller (skip)
189: FrameLayout skip_lo(skip_fp); // frame for skip
190: register int* fr_fp = FP(); // fp for fudge_return
191: FrameLayout fr_lo(fr_fp); // frame for fudge_return
192:
193: OLD_PC(fp) = (int)&fudge_sp; // task::task will return through
194: // fudge_sp, which will reset the sp
195: // to point at the return-pc in
196: // skip's frame
197: // copy old fp
198: OLD_FP(fp) = OLD_FP(skip_fp);
199:
200: // now copy saved registers
201: // copy any saved skip regs over corresponding f regs; if there isn't
202: // a corresponding f reg, copy over corresponding fudge_return reg;
203: // if there isn't a corresponding fr_reg, restore it explicitly.
204: register int* to = FIRST_SAVED_REG_P(fp, lo.offset);
205: register int* from = FIRST_SAVED_REG_P(skip_fp, skip_lo.offset);
206: register int* fr_to = FIRST_SAVED_REG_P(fr_fp, fr_lo.offset);
207: for (register short m = 1; m != 0x08; m <<=1) {
208: if (m & lo.mask) {
209: if (m & skip_lo.mask) {
210: *to-- = *from--;
211: if (m & fr_lo.mask) fr_to--;
212: } else { // nothing to copy
213: to--;
214: if (m & fr_lo.mask) fr_to--;
215: }
216: } else if (m & skip_lo.mask) {
217: // No slot for *from in f's frame
218: if (m & fr_lo.mask) { // copy to fudge_return's frame
219: *fr_to-- = *from--;
220: } else {
221: // Not used in f or fudge_return;
222: // restore explicitly
223: switch(m) {
224: case REG_EDI:
225: set_edi(from--);
226: break;
227: case REG_ESI:
228: set_esi(from--);
229: break;
230: case REG_EBX:
231: set_ebx(from--);
232: break;
233: default:
234: // Oops--don't expect other regs
235: // to be saved
236: from--;
237: task_error(E_REGMASK, this);
238: break;
239: }
240: }
241: }
242: }
243: }
244:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.