![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to traps.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [UNIX Amiga Emulator] / uae / src|
Return to traps.c CVS log | Up to [UNIX Amiga Emulator] / uae / src |
1.1 root 1: /*
2: * E-UAE - The portable Amiga Emulator
3: *
4: * Support for traps
5: *
6: * Copyright Richard Drummond 2005
7: *
8: * Inspired by code from UAE:
9: * Copyright 1995, 1996 Bernd Schmidt
10: * Copyright 1996 Ed Hanway
11: */
12:
13: #include "sysconfig.h"
14: #include "sysdeps.h"
15:
16: #include "options.h"
17: #include "memory.h"
18: #include "custom.h"
19: #include "newcpu.h"
20: #include "threaddep/thread.h"
21: #include "autoconf.h"
22: #include "traps.h"
23:
24: /* We'll need a lot of these. */
25: #define MAX_TRAPS 4096
26: static TrapFunction traps[MAX_TRAPS];
27: static int trapmode[MAX_TRAPS];
28: static const char *trapstr[MAX_TRAPS];
29: static uaecptr trapoldfunc[MAX_TRAPS];
30:
31: static int max_trap = 0;
32:
33: /* Stack management */
34:
35: /* The mechanism for doing m68k calls from native code is as follows:
36: *
37: * m68k code executes, stack is main
38: * calltrap to execute_fn_on_extra_stack. new stack is allocated
39: * do_stack_magic is called for the first time
40: * current context is saved with setjmp [0]
41: * transfer_control is done
42: * native code executes on new stack
43: * native code calls call_m68k
44: * setjmp saves current context [1]
45: * longjmp back to execute_fn_on_extra_stack [0]
46: * pointer to new stack is saved on m68k stack. m68k return address set
47: * to RTAREA_BASE + 0xFF00. m68k PC set to called function
48: * m68k function executes, stack is main
49: * m68k function returns to RTAREA_BASE + 0xFF00
50: * calltrap to m68k_mode_return
51: * do_stack_magic is called again
52: * current context is saved again with setjmp [0]
53: * this time, transfer_control is _not_ done, instead a longjmp[1]
54: * to the previously saved context
55: * native code executes again on temp stack
56: * native function returns to stack_stub
57: * longjmp[0] back to old context
58: * back again!
59: *
60: * A bearded man enters the room, carrying a bowl of spaghetti.
61: */
62:
63: /* This _shouldn't_ crash with a stack size of 4096, but it does...
64: * might be a bug */
65: #ifndef EXTRA_STACK_SIZE
66: #define EXTRA_STACK_SIZE 65536
67: #endif
68:
69: static void *extra_stack_list = NULL;
70:
71: static void *get_extra_stack (void)
72: {
73: void *s = extra_stack_list;
74: if (s)
75: extra_stack_list = *(void **)s;
76: if (!s)
77: s = xmalloc (EXTRA_STACK_SIZE);
78: return s;
79: }
80:
81: static void free_extra_stack (void *s)
82: {
83: *(void **)s = extra_stack_list;
84: extra_stack_list = s;
85: }
86:
87: static void stack_stub (void *s, TrapFunction f, uae_u32 *retval)
88: {
89: #ifdef CAN_DO_STACK_MAGIC
90: /*printf("in stack_stub: %p %p %p %x\n", s, f, retval, (int)*retval);*/
91: *retval = f ();
92: /*write_log ("returning from stack_stub\n");*/
93: longjmp (((jmp_buf *)s)[0], 1);
94: #endif
95: }
96:
97: static void *current_extra_stack = NULL;
98: static uaecptr m68k_calladdr;
99:
100: static void do_stack_magic (TrapFunction f, void *s, int has_retval)
101: {
102: #ifdef CAN_DO_STACK_MAGIC
103: uaecptr a7;
104: jmp_buf *j = (jmp_buf *)s;
105: switch (setjmp (j[0])) {
106: case 0:
107: /* Returning directly */
108: current_extra_stack = s;
109: if (has_retval == -1) {
110: /*write_log ("finishing m68k mode return\n");*/
111: longjmp (j[1], 1);
112: }
113: /*write_log ("calling native function\n");*/
114: transfer_control (s, EXTRA_STACK_SIZE, stack_stub, f, has_retval);
115: /* not reached */
116: abort ();
117:
118: case 1:
119: /*write_log ("native function complete\n");*/
120: /* Returning normally. */
121: if (stack_has_retval (s, EXTRA_STACK_SIZE))
122: m68k_dreg (regs, 0) = get_retval_from_stack (s, EXTRA_STACK_SIZE);
123: free_extra_stack (s);
124: break;
125:
126: case 2:
127: /* Returning to do a m68k call. We're now back on the main stack. */
128: a7 = m68k_areg(regs, 7) -= (sizeof (void *) + 7) & ~3;
129: /* Save stack to restore */
130: *((void **)get_real_address (a7 + 4)) = s;
131: /* Save special return address: this address contains a
132: * calltrap that will longjmp to the right stack. */
133: put_long (m68k_areg (regs, 7), RTAREA_BASE + 0xFF00);
134: m68k_setpc (m68k_calladdr);
135: fill_prefetch_slow ();
136: /*write_log ("native function calls m68k\n");*/
137: break;
138: }
139: current_extra_stack = 0;
140: #endif
141: }
142:
143: static uae_u32 execute_fn_on_extra_stack (TrapFunction f, int has_retval)
144: {
145: #ifdef CAN_DO_STACK_MAGIC
146: void *s = get_extra_stack ();
147: do_stack_magic (f, s, has_retval);
148: #endif
149: return 0;
150: }
151:
152: uae_u32 m68k_mode_return (void)
153: {
154: #ifdef CAN_DO_STACK_MAGIC
155: uaecptr a7 = m68k_areg(regs, 7);
156: void *s = *(void **)get_real_address(a7);
157: m68k_areg(regs, 7) += (sizeof (void *) + 3) & ~3;
158: /*write_log ("doing m68k mode return\n");*/
159: do_stack_magic (NULL, s, -1);
160: #endif
161: return 0;
162: }
163:
164: static uae_u32 call_m68k (uaecptr addr, int saveregs)
165: {
166: volatile uae_u32 retval = 0;
167: volatile int do_save = saveregs;
168: if (current_extra_stack == NULL)
169: abort();
170: #ifdef CAN_DO_STACK_MAGIC
171: {
172: volatile struct regstruct saved_regs;
173: jmp_buf *j = (jmp_buf *)current_extra_stack;
174:
175: if (do_save)
176: saved_regs = regs;
177: m68k_calladdr = addr;
178: switch (setjmp(j[1])) {
179: case 0:
180: /*write_log ("doing call\n");*/
181: /* Returning directly: now switch to main stack and do the call */
182: longjmp (j[0], 2);
183: case 1:
184: /*write_log ("returning from call\n");*/
185: retval = m68k_dreg (regs, 0);
186: if (do_save)
187: regs = saved_regs;
188: /* Returning after the call. */
189: break;
190: }
191: }
192: #endif
193: return retval;
194: }
195:
196: uae_u32 CallLib (uaecptr base, uae_s16 offset)
197: {
198: int i;
199: uaecptr olda6 = m68k_areg(regs, 6);
200: uae_u32 retval;
201: #if 0
202: for (i = 0; i < n_libpatches; i++) {
203: if (libpatches[i].libbase == base && libpatches[i].functions[-offset/6] != NULL)
204: return (*libpatches[i].functions[-offset/6])();
205: }
206: #endif
207: m68k_areg(regs, 6) = base;
208: retval = call_m68k(base + offset, 1);
209: m68k_areg(regs, 6) = olda6;
210: return retval;
211: }
212:
213: static int trace_traps = 1;
214:
215: void REGPARAM2 call_calltrap(int func)
216: {
217: uae_u32 retval = 0;
218: int has_retval = (trapmode[func] & TRAPFLAG_NO_RETVAL) == 0;
219: int implicit_rts = (trapmode[func] & TRAPFLAG_DORET) != 0;
220:
221: if (*trapstr[func] != 0 && trace_traps)
222: write_log ("TRAP: %s\n", trapstr[func]);
223:
224: /* For monitoring only? */
225: if (traps[func] == NULL) {
226: m68k_setpc(trapoldfunc[func]);
227: fill_prefetch_slow ();
228: return;
229: }
230:
231: if (func < max_trap) {
232: if (trapmode[func] & TRAPFLAG_EXTRA_STACK) {
233: execute_fn_on_extra_stack(traps[func], has_retval);
234: return;
235: }
236: retval = (*traps[func])();
237: } else
238: write_log ("illegal emulator trap\n");
239:
240: if (has_retval)
241: m68k_dreg(regs, 0) = retval;
242: if (implicit_rts) {
243: m68k_do_rts ();
244: fill_prefetch_slow ();
245: }
246: }
247:
248: static volatile int four = 4;
249: uaecptr libemu_InstallFunctionFlags (TrapFunction f, uaecptr libbase, int offset,
250: int flags, const char *tracename)
251: {
252: int i;
253: uaecptr retval;
254: uaecptr execbase = get_long (four);
255: int trnum;
256: uaecptr addr = here();
257: calltrap (trnum = deftrap2 (f, flags, tracename));
258: dw (RTS);
259:
260: m68k_areg(regs, 1) = libbase;
261: m68k_areg(regs, 0) = offset;
262: m68k_dreg(regs, 0) = addr;
263: retval = CallLib (execbase, -420);
264:
265: trapoldfunc[trnum] = retval;
266: #if 0
267: for (i = 0; i < n_libpatches; i++) {
268: if (libpatches[i].libbase == libbase)
269: break;
270: }
271: if (i == n_libpatches) {
272: int j;
273: libpatches[i].libbase = libbase;
274: for (j = 0; j < 300; j++)
275: libpatches[i].functions[j] = NULL;
276: n_libpatches++;
277: }
278: libpatches[i].functions[-offset/6] = f;
279: #endif
280: return retval;
281: }
282:
283: int deftrap2 (TrapFunction func, int mode, const char *str)
284: {
285: int num = max_trap++;
286: traps[num] = func;
287: trapstr[num] = str;
288: trapmode[num] = mode;
289: return num;
290: }
291:
292: int deftrap (TrapFunction func)
293: {
294: return deftrap2 (func, 0, "");
295: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.