![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to execlib.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 execlib.c CVS log | Up to [UNIX Amiga Emulator] / uae / src |
1.1 root 1: /*
2: * UAE - The Un*x Amiga Emulator
3: *
4: * exec.library emulation
5: *
6: * Copyright 1996 Bernd Schmidt
7: */
8:
9: #undef USE_EXECLIB
10:
11: #include "sysconfig.h"
12: #include "sysdeps.h"
13:
14: #include <assert.h>
15: #include <signal.h>
16: #ifdef USE_EXECLIB
17: #include <setjmp.h>
18: #endif
19:
20: #include "config.h"
21: #include "options.h"
22: #include "memory.h"
23: #include "custom.h"
24: #include "newcpu.h"
25: #include "xwin.h"
26: #include "autoconf.h"
27: #include "osemu.h"
28:
29: static CPTR sysbase;
30:
31: /*
32: * Exec list management
33: */
34:
35: void EXEC_NewList(CPTR list)
36: {
37: put_long(list, list + 4);
38: put_long(list + 4, 0);
39: put_long(list + 8, list);
40: }
41:
42: void EXEC_Insert(CPTR list, CPTR node, CPTR pred)
43: {
44: CPTR succ;
45: if (pred == 0)
46: pred = list;
47: put_long(node, succ = get_long(pred));
48: put_long(pred, node);
49: put_long(succ + 4, node);
50: put_long(node + 4, pred);
51: }
52:
53: void EXEC_Enqueue(CPTR list, CPTR node)
54: {
55: int pri = (BYTE)get_byte (node + 9);
56: CPTR lnode = get_long(list); /* lh_Head */
57: CPTR prev = 0, next;
58:
59: for (;(next = get_long(lnode)) != 0 && (BYTE)get_byte(lnode + 9) >= pri;) {
60: prev = lnode;
61: lnode = next;
62: }
63: EXEC_Insert(list, node, prev);
64: }
65:
66: void EXEC_Remove(CPTR node)
67: {
68: CPTR pred = get_long(node + 4), succ = get_long(node);
69: put_long(pred, succ);
70: put_long(succ + 4, pred);
71: }
72:
73: ULONG EXEC_RemHead(CPTR list)
74: {
75: CPTR head = get_long(list);
76: if (get_long(head) == 0)
77: return 0;
78: EXEC_Remove(head);
79: return head;
80: }
81:
82: ULONG EXEC_RemTail(CPTR list)
83: {
84: CPTR tail = get_long(list + 8);
85: if (get_long(tail + 4) == 0)
86: return 0;
87:
88: EXEC_Remove(tail);
89: return tail;
90: }
91:
92: void EXEC_AddTail(CPTR list, CPTR node)
93: {
94: EXEC_Insert(list, node, get_long(list + 8));
95: }
96:
97: CPTR EXEC_FindName(CPTR start, char *name)
98: {
99: CPTR node = start;
100: if (name == NULL)
101: return 0;
102:
103: for (;;) {
104: CPTR nnp;
105: char *nn;
106:
107: node = get_long(start);
108:
109: if (node == 0)
110: break;
111: nnp = get_long(node + 10);
112: if (nnp != 0 && (nn = get_real_address(nnp)) != NULL)
113: if (strcmp(nn, name) == 0)
114: return node;
115: start = node;
116: }
117: return 0;
118: }
119:
120: static ULONG execl_Enqueue(void) { EXEC_Enqueue(regs.a[0], regs.a[1]); return 0; }
121: static ULONG execl_Insert(void) { EXEC_Insert(regs.a[0], regs.a[1], regs.a[2]); return 0; }
122: static ULONG execl_AddHead(void) { EXEC_Insert(regs.a[0], regs.a[1], 0); return 0; }
123: static ULONG execl_AddTail(void) { EXEC_Insert(regs.a[0], regs.a[1], get_long(regs.a[0] + 8)); return 0; }
124: static ULONG execl_Remove(void) { EXEC_Remove(regs.a[1]); return 0; }
125: static ULONG execl_RemHead(void) { return EXEC_RemHead(regs.a[0]); }
126: static ULONG execl_RemTail(void) { return EXEC_RemTail(regs.a[0]); }
127: static ULONG execl_FindName(void) { CPTR n = EXEC_FindName(regs.a[0], get_real_address(regs.a[1])); ZFLG = n == 0; return n; }
128:
129: /*
130: * Miscellaneous
131: */
132:
133: void EXEC_InitStruct(CPTR inittable, CPTR memory, unsigned long size)
134: {
135: CPTR dptr = memory;
136: UBYTE *mem = get_real_address(memory);
137: if (memory == 0 || mem == NULL || !valid_address(memory, size)) {
138: fprintf(stderr, "Foo\n");
139: return;
140: }
141: memset(mem, 0, size);
142: fprintf(stderr, "InitStruct\n");
143: for (;;) {
144: UBYTE command;
145: int count, desttype, srcloc;
146: ULONG offset;
147:
148: /* Read commands from even bytes */
149: inittable = (inittable + 1) & ~1;
150:
151: command = get_byte(inittable);
152: if (command == 0)
153: break;
154: desttype = (command >> 6) & 3;
155: srcloc = (command >> 4) & 3;
156: count = (command & 15) + 1;
157:
158: if (desttype == 3) {
159: dptr = memory + (get_long(inittable) & 0xFFFFFF);
160: inittable += 4;
161: } else if (desttype == 2) {
162: dptr = memory + get_byte(inittable+1), inittable += 2;
163: } else
164: inittable++;
165:
166: if (srcloc != 0)
167: inittable = (inittable + 1) & ~1;
168:
169: if (desttype != 1) {
170: for(; count > 0; count--) {
171: switch (srcloc) {
172: case 0: put_long(dptr, get_long(inittable)); dptr += 4; inittable += 4; break;
173: case 1: put_word(dptr, get_word(inittable)); dptr += 2; inittable += 2; break;
174: case 2: put_byte(dptr, get_byte(inittable)); dptr += 1; inittable += 1; break;
175: }
176: }
177: } else {
178: ULONG data;
179: switch (srcloc) {
180: case 0: data = get_byte(inittable); inittable += 1; break;
181: case 1: data = get_word(inittable); inittable += 2; break;
182: case 2: data = get_long(inittable); inittable += 4; break;
183: default: data = 0; /* Alert */ break;
184: }
185: for(; count > 0; count--) {
186: switch (srcloc) {
187: case 0: put_long(dptr, data); dptr += 4; break;
188: case 1: put_word(dptr, data); dptr += 2; break;
189: case 2: put_byte(dptr, data); dptr += 1; break;
190: }
191: }
192: }
193: }
194: }
195: /* The size parameter sometimes seems to contain garbage in the top 16 bit */
196: static ULONG execl_InitStruct(void) { EXEC_InitStruct(regs.a[1], regs.a[2], regs.d[0] & 0xFFFF); return 0; }
197:
198: /*
199: * Interrupts
200: * This is all very confusing. As I see things, the IntVects field of the
201: * ExecBase is set up as follows:
202: * One interrupt may either be assigned an IntServer, or an IntHandler.
203: * PORTS, COPER, VERTB EXTER and NMI are set up as Servers (at least that's
204: * what the AutoDocs say), the others as IntHandlers.
205: * An IntServer field has a pointer to an Exec list in the iv_Data field,
206: * the list contains all the server Interrupt nodes in a nice chain. The
207: * iv_Node field is zero. For an IntHandler, the iv_Node field contains a
208: * pointer to the node that was passed in SetIntVector.
209: */
210:
211: CPTR EXEC_SetIntVector(int number, CPTR interrupt)
212: {
213: CPTR oldvec = get_long(sysbase + 84 + 12*number + 8);
214: if (interrupt == 0) {
215: put_long(sysbase + 84 + 12*number, 0);
216: put_long(sysbase + 84 + 12*number + 4, 0);
217: put_long(sysbase + 84 + 12*number + 8, 0);
218: } else {
219: put_long(sysbase + 84 + 12*number, get_long(interrupt + 14));
220: put_long(sysbase + 84 + 12*number + 4, get_long(interrupt + 18));
221: put_long(sysbase + 84 + 12*number + 8, interrupt);
222: }
223: return oldvec;
224: }
225:
226: void EXEC_RemIntServer(ULONG nr, CPTR interrupt)
227: {
228: CPTR list = get_long(sysbase + 84 + nr*12);
229:
230: EXEC_Remove(interrupt);
231: /* Disable interrupt if necessary */
232: if (get_long(get_long(list)) == 0)
233: put_word(0xDFF09A, 1 << nr);
234: }
235:
236: void EXEC_AddIntServer(ULONG nr, CPTR interrupt)
237: {
238: CPTR list = get_long(sysbase + 84 + nr*12);
239: int was_empty;
240:
241: /* Disable interrupt if necessary */
242: was_empty = get_long(get_long(list)) == 0;
243:
244: EXEC_Enqueue(list, interrupt);
245: if (was_empty)
246: put_word(0xDFF09A, 0x8000 | (1 << nr));
247:
248: }
249:
250: static ULONG execl_SetIntVector(void) { return EXEC_SetIntVector(regs.d[0], regs.a[1]); }
251: static ULONG execl_AddIntServer(void) { EXEC_AddIntServer(regs.d[0] & 15, regs.a[1]); return 0; }
252: static ULONG execl_RemIntServer(void) { EXEC_RemIntServer(regs.d[0] & 15, regs.a[1]); return 0; }
253:
254: /*
255: * Memory functions
256: */
257:
258: #define MEMF_PUBLIC 1
259: #define MEMF_CHIP 2
260: #define MEMF_FAST 4
261: #define MEMF_LOCAL 256
262: #define MEMF_24BITDMA 512
263: #define MEMF_CLEAR (1<<16)
264: #define MEMF_LARGEST (1<<17)
265: #define MEMF_REVERSE (1<<18)
266: #define MEMF_TOTAL (1<<19)
267:
268: CPTR EXEC_Allocate(CPTR memheader, unsigned long size)
269: {
270: CPTR chunk, chunkpp;
271: unsigned long avail;
272:
273: size = (size + 7) & ~7;
274:
275: if (size == 0 || size > get_long(memheader + 28))
276: return 0;
277:
278: for (chunk = get_long(chunkpp = memheader + 16); chunk != 0; chunkpp = chunk, chunk = get_long(chunk))
279: if ((avail = get_long(chunk + 4)) >= size) {
280: CPTR nextchunk = get_long(chunk);
281: if (avail-size == 0)
282: put_long(chunkpp, nextchunk);
283: else {
284: put_long(chunkpp, chunk + size);
285: put_long(chunk + size, nextchunk);
286: put_long(chunk + size + 4, avail - size);
287: }
288: put_long(memheader + 28, get_long(memheader + 28) - size);
289: return chunk;
290: }
291: return 0;
292: }
293:
294: void EXEC_Deallocate(CPTR memheader, CPTR addr, unsigned long size)
295: {
296: CPTR chunk, chunkpp;
297: CPTR areaend;
298:
299: if (addr == 0)
300: return;
301:
302: size = (size + 7) & ~7;
303: areaend = addr + size;
304:
305: put_long(memheader + 28, get_long(memheader + 28) + size);
306:
307: for (chunk = get_long(chunkpp = memheader + 16); chunk != 0; chunkpp = chunk, chunk = get_long(chunk)) {
308: if (chunk + get_long(chunk + 4) == addr) {
309: /* Merge with this and go ahead so we can also merge with the next */
310: put_long(chunkpp, get_long(chunk));
311: addr = chunk; size += get_long(chunk + 4);
312: chunk = chunkpp;
313: continue;
314: }
315: if (areaend == chunk) {
316: /* Merge with previous */
317: put_long(chunkpp, addr);
318: put_long(addr, get_long(chunk));
319: put_long(addr + 4, get_long(chunk + 4) + size);
320: return;
321: }
322: if (chunk > addr)
323: break;
324: }
325: put_long(chunkpp, addr);
326: put_long(addr, chunk);
327: put_long(addr + 4, size);
328: }
329:
330: CPTR EXEC_AllocMem(unsigned long size, ULONG requirements)
331: {
332: CPTR nextmh, memheader = get_long(sysbase + 322);
333: ULONG attrs = requirements & (MEMF_PUBLIC | MEMF_CHIP | MEMF_FAST);
334: CPTR result = 0;
335:
336: size = (size + 7) & ~7;
337:
338: for (;(nextmh = get_long(memheader)) != 0; memheader = nextmh) {
339: if ((get_word(memheader + 14) & attrs) != attrs)
340: continue;
341: result = EXEC_Allocate(memheader, size);
342: if (result != 0)
343: break;
344: }
345: if (result) {
346: if (requirements & MEMF_CLEAR)
347: memset(get_real_address(result), 0, size);
348: }
349: return result;
350: }
351:
352: CPTR EXEC_AllocEntry(CPTR ml)
353: {
354: CPTR newml = EXEC_AllocMem(16 + 8*get_word(ml + 14), MEMF_PUBLIC|MEMF_CLEAR);
355: int i;
356:
357: if (newml == 0)
358: return 0x80000000|MEMF_PUBLIC;
359: for (i = 0; i < get_word(ml + 14); i++) {
360: ULONG reqs = get_long(ml + 16 + 8*i);
361: ULONG addr = EXEC_AllocMem(get_long(ml + 16 + 8*i + 4), reqs);
362: if (addr == 0)
363: /* Thank god for SetPatch */
364: return 0x80000000 | reqs;
365: put_long(newml + 16 + 8*i, addr);
366: put_long(newml + 16 + 8*i + 4, reqs);
367: }
368: return newml;
369: }
370:
371: void EXEC_FreeMem(CPTR addr, unsigned long size)
372: {
373: CPTR nextmh, memheader = get_long(sysbase + 322);
374:
375: size = (size + 7) & ~7;
376: if (addr == 0)
377: return;
378:
379: for (;(nextmh = get_long(memheader)) != 0; memheader = nextmh) {
380: if (get_long(memheader + 20) <= addr
381: && get_long(memheader + 24) > addr) {
382: EXEC_Deallocate(memheader, addr, size);
383: return;
384: }
385: }
386: }
387:
388: unsigned long EXEC_AvailMem(ULONG requirements)
389: {
390: ULONG attrs = requirements & (MEMF_PUBLIC | MEMF_CHIP | MEMF_FAST);
391: CPTR nextmh, memheader = get_long(sysbase + 322);
392: CPTR result = 0;
393:
394: for (;(nextmh = get_long(memheader)) != 0; memheader = nextmh) {
395: if ((get_word(memheader + 14) & attrs) != attrs)
396: continue;
397: if (attrs & MEMF_LARGEST) {
398: unsigned long maxsize = 0;
399: CPTR chunk;
400: for (chunk = get_long(memheader + 16); chunk != 0; chunk = get_long(chunk))
401: if (get_long(chunk+4) > maxsize)
402: maxsize = get_long(chunk + 4);
403: result += maxsize;
404: } else if (attrs & MEMF_TOTAL) {
405: result += get_long(memheader + 24) - get_long(memheader + 20);
406: } else result += get_long(memheader + 28);
407: }
408: return result;
409: }
410:
411: void EXEC_AddMemList(unsigned long size, ULONG attrs, int pri, CPTR base,
412: CPTR name)
413: {
414: put_byte(base + 8, 0);
415: put_byte(base + 9, pri);
416: put_long(base + 10, name);
417: put_word(base + 14, attrs);
418: put_long(base + 16, base + 32);
419: put_long(base + 20, base + 32);
420: put_long(base + 36, size - 32);
421: put_long(base + 28, size - 32);
422: put_long(base + 24, base + size);
423: EXEC_Enqueue(sysbase + 322, base);
424: }
425:
426: static ULONG execl_AddMemList(void)
427: {
428: EXEC_AddMemList(regs.d[0], regs.d[1], (LONG)regs.d[2], regs.a[0], regs.a[1]);
429: return 0;
430: }
431:
432: static ULONG execl_CopyMem(void)
433: {
434: UBYTE *src = get_real_address(regs.a[0]);
435: UBYTE *dst = get_real_address(regs.a[1]);
436:
437: if (src != NULL && dst != NULL
438: && valid_address(regs.a[0], regs.d[0])
439: && valid_address(regs.a[1], regs.d[0]))
440: memcpy(dst, src, regs.d[0]);
441: else
442: fprintf(stderr, "CopyMem with bogus parameters\n");
443: return 0;
444: }
445:
446: static ULONG execl_AllocMem(void) { return EXEC_AllocMem(regs.d[0], regs.d[1]); }
447: static ULONG execl_AllocEntry(void) { return EXEC_AllocEntry(regs.a[0]); }
448: static ULONG execl_Allocate(void) { return EXEC_Allocate(regs.a[0], regs.d[0]); }
449: static ULONG execl_FreeMem(void) { EXEC_FreeMem(regs.a[1], regs.d[0]); return 0; }
450: static ULONG execl_AvailMem(void) { return EXEC_AvailMem(regs.d[1]); }
451: static ULONG execl_Deallocate(void) { EXEC_Deallocate(regs.a[0], regs.a[1], regs.d[0]); return 0; }
452:
453: /*
454: * Scheduling
455: */
456:
457: #define TS_RUN 2
458: #define TS_READY 3
459: #define TS_WAIT 4
460: #define TS_EXCEPT 5
461:
462: struct NewTask {
463: struct NewTask *next, *prev;
464: CPTR exectask;
465: #ifdef USE_EXECLIB
466: jmp_buf j;
467: #endif
468: void *stack;
469: struct regstruct regs;
470: struct flag_struct flags;
471: };
472:
473: static struct NewTask idle_task;
474: static int intr_count, need_resched;
475:
476: static struct NewTask *find_newtask(CPTR task)
477: {
478: /* Ugh, this is ugly */
479: struct NewTask *t = &idle_task;
480: do {
481: if (t->exectask == task)
482: return t;
483: t = t->next;
484: } while (t != &idle_task);
485: fprintf(stderr, "Uh oh. Task list corrupt\n");
486: }
487:
488: static void schedule(void)
489: {
490: #ifdef USE_EXECLIB
491: CPTR readylist = sysbase + 406;
492: CPTR readytask = get_long(readylist);
493: CPTR runtask = get_long(sysbase + 276);
494: struct NewTask *runtask_nt, *readytask_nt;
495: unsigned long oldflags;
496:
497: int idis;
498:
499: need_resched = 0;
500: /* Any ready tasks? */
501: if (get_long(readytask) == 0)
502: return;
503:
504: /* If the running task is going to sleep, don't check priorities*/
505: if (get_byte(runtask + 15) != TS_WAIT) {
506: /* Has the running task a higher priority than any ready tasks? */
507: if ((BYTE)get_byte(runtask + 9) > (BYTE)get_byte(readytask + 9))
508: return;
509: /* We should only preempt a task of the same priority if the quantum
510: * has expired. Hmmm... */
511: }
512: if (get_byte(runtask + 15) == TS_RUN)
513: put_byte(runtask + 15, TS_READY);
514: if (get_byte(runtask + 15) == TS_WAIT)
515: EXEC_Enqueue(sysbase + 420, runtask);
516: else
517: EXEC_Enqueue(readylist, runtask);
518: put_byte(readytask + 15, TS_RUN);
519: EXEC_Remove(readytask);
520:
521: readytask_nt = find_newtask(readytask);
522: runtask_nt = find_newtask(runtask);
523:
524:
525: oldflags = regs.spcflags;
526: runtask_nt->regs = regs;
527: runtask_nt->flags = regflags;
528: regs = readytask_nt->regs;
529: regflags = readytask_nt->flags;
530: regs.spcflags = (regs.spcflags & ~PRESERVED_FLAGS) | (oldflags & PRESERVED_FLAGS);
531:
532: put_byte(runtask + 16, get_byte(sysbase + 294));
533: put_byte(runtask + 17, get_byte(sysbase + 295));
534: put_byte(sysbase + 294, idis = get_byte(readytask + 16));
535: put_byte(sysbase + 295, get_byte(readytask + 17));
536: put_long(sysbase + 276, readytask);
537: /* Set INTENA according to new interrupt enable status */
538: if (idis == 0xFF)
539: put_word(0xDFF09A, 0xC000);
540: else
541: put_word(0xDFF09A, 0x4000);
542: /* Whee... */
543: fprintf(stderr, "Task switch: new task %s\n", get_real_address(get_long(readytask + 10)));
544: if (setjmp(runtask_nt->j) == 0)
545: longjmp(readytask_nt->j, 1);
546: regs.spcflags &= ~SPCFLAG_BRK;
547: #endif
548: }
549:
550: static __inline__ void maybe_schedule(void)
551: {
552: /* @@@ Should we avoid a schedule when supervisor bit is set?
553: * Definitely not if the running task is the idle task */
554: if (intr_count == 0 && get_byte(sysbase + 294) == 0xFF && get_byte(sysbase + 295) == 0xFF && need_resched)
555: schedule();
556: }
557:
558: /*
559: * Signals
560: */
561:
562: int EXEC_AllocSignal(int signum)
563: {
564: CPTR thistask = get_long(sysbase + 276);
565: ULONG sigalloc = get_long(thistask + 18);
566: if (signum == -1)
567: for (signum = 0; signum < 32; signum++)
568: if ((sigalloc & (1 << signum)) == 0)
569: break;
570:
571: if ((sigalloc & (1 << signum)) == 0) {
572: put_long(thistask + 18, sigalloc | (1 << signum));
573: } else
574: signum = -1;
575:
576: return signum;
577: }
578:
579: void EXEC_FreeSignal(int signum)
580: {
581: CPTR thistask = get_long(sysbase + 276);
582: if (signum != -1)
583: return;
584: put_long(thistask + 18, get_long(thistask + 18) & ~(1 << signum));
585: }
586:
587: ULONG EXEC_SetSignal(ULONG newsig, ULONG exec_sigmask)
588: {
589: CPTR task = get_long(sysbase + 276);
590: ULONG signals = get_long(task + 26);
591: /* @@@ check SigExcept here */
592: put_long(task + 26, (signals & ~exec_sigmask) | (newsig & exec_sigmask));
593: return signals;
594: }
595:
596: void EXEC_Signal(CPTR task, ULONG exec_sigmask)
597: {
598: ULONG exec_sigs = get_long(task + 26);
599: ULONG sigwait = get_long(task + 22);
600: put_long(task + 26, exec_sigs | exec_sigmask);
601: if (get_byte(task + 15) == TS_WAIT && (sigwait & exec_sigmask) != 0) {
602: EXEC_Remove(task);
603: EXEC_Enqueue(sysbase + 406, task);
604: need_resched = 1;
605: maybe_schedule();
606: }
607: }
608:
609: ULONG EXEC_Wait(ULONG exec_sigmask)
610: {
611: CPTR task = get_long(sysbase + 276);
612: ULONG exec_sigs = get_long(task + 26);
613: if ((exec_sigs & exec_sigmask) != 0) {
614: put_long(task + 26, exec_sigs & ~exec_sigmask);
615: return exec_sigs & exec_sigmask;
616: }
617: if (get_byte(sysbase + 294) != 0xFF || get_byte(sysbase + 295) != 0xFF)
618: {
619: fprintf(stderr, "Arrgh, task Wait()ing when it shouldn't\n");
620: }
621: if (intr_count || regs.s) {
622: fprintf(stderr, "Arrgh, task Wait()ing when it _really_ shouldn't\n");
623: }
624:
625: put_byte(task + 15, TS_WAIT);
626: put_long(task + 22, exec_sigmask);
627: schedule();
628: exec_sigs = get_long(task + 26);
629: if ((exec_sigs & exec_sigmask) != 0) {
630: put_long(task + 26, exec_sigs & ~exec_sigmask);
631: return exec_sigs & exec_sigmask;
632: }
633: fprintf(stderr, "Bug: task woke up without signals\n");
634: return 0;
635: }
636:
637: static ULONG execl_SetSignal(void) { return EXEC_SetSignal(regs.d[0], regs.d[1]); }
638: static ULONG execl_Signal(void) { EXEC_Signal(regs.a[1], regs.d[0]); return 0; }
639: static ULONG execl_Wait(void) { return EXEC_Wait(regs.d[0]); }
640: static ULONG execl_AllocSignal(void) { return EXEC_AllocSignal((BYTE)regs.d[0]); }
641: static ULONG execl_FreeSignal(void) { EXEC_FreeSignal((BYTE)regs.d[0]); return 0; }
642:
643: /*
644: * Semaphores
645: */
646:
647: void EXEC_InitSemaphore(CPTR exec_sigsem)
648: {
649: EXEC_NewList(exec_sigsem + 16);
650: put_word(exec_sigsem + 14, 0);
651: put_word(exec_sigsem + 44, 0xFFFF);
652: }
653:
654: ULONG EXEC_AttemptSemaphore(CPTR exec_sigsem)
655: {
656: CPTR task = get_long(sysbase + 276);
657: UWORD count = get_word(exec_sigsem + 44);
658: if (count == 0xFFFF) {
659: /* Semaphore free -> lock it */
660: put_word(exec_sigsem + 44, 0);
661: put_long(exec_sigsem + 40, task);
662: put_word(exec_sigsem + 14, 1);
663: return 1;
664: }
665: if (get_long(exec_sigsem + 40) == task) {
666: /* Locked by same task -> Increment NestCount */
667: put_word(exec_sigsem + 14, get_word(exec_sigsem + 14) + 1);
668: return 1;
669: }
670: return 0;
671: }
672:
673: void EXEC_ObtainSemaphore(CPTR exec_sigsem)
674: {
675: CPTR task = get_long(sysbase + 276);
676: UWORD count = get_word(exec_sigsem + 44);
677: if (count == 0xFFFF) {
678: /* Semaphore free -> lock it */
679: put_word(exec_sigsem + 44, 0);
680: put_long(exec_sigsem + 40, task);
681: put_word(exec_sigsem + 14, 1);
682: return;
683: }
684: if (get_long(exec_sigsem + 40) == task) {
685: /* Locked by same task -> Increment NestCount */
686: put_word(exec_sigsem + 14, get_word(exec_sigsem + 14) + 1);
687: return;
688: }
689: /* Need to wait. */
690: /* @@@ None of the predefined signals in exec/tasks.h seem to be used
691: * for this. We use 0x8000, which appears not to be used otherwise */
692: put_word(exec_sigsem + 44, count + 1);
693: EXEC_AddTail(exec_sigsem + 16, task);
694: if (EXEC_Wait(0x8000) != 0x8000)
695: fprintf(stderr, "BUG\n");
696:
697: /* Now it's mine, all mine! */
698: put_long(exec_sigsem + 40, task);
699: put_word(exec_sigsem + 14, 1);
700: }
701:
702: void EXEC_ReleaseSemaphore(CPTR exec_sigsem)
703: {
704: UWORD nest = get_word(exec_sigsem + 14);
705: put_word(exec_sigsem + 14, nest - 1);
706: if (nest == 1) {
707: /* We're losing it. Signal the first task on the wait queue
708: * (that one will in turn wake the next, etc.) */
709: CPTR task = EXEC_RemHead(exec_sigsem + 16);
710: UWORD count = get_word(exec_sigsem + 44);
711: put_word(exec_sigsem + 44, count - 1);
712: if (task) {
713: EXEC_Signal(task, 0x8000);
714: }
715: }
716: }
717:
718: static ULONG execl_ObtainSemaphore(void) { EXEC_ObtainSemaphore(regs.a[0]); return 0; }
719: static ULONG execl_ReleaseSemaphore(void) { EXEC_ReleaseSemaphore(regs.a[0]); return 0; }
720: static ULONG execl_FindSemaphore(void) { return EXEC_FindName(sysbase + 532, get_real_address(regs.a[1])); }
721: static ULONG execl_InitSemaphore(void) { EXEC_InitSemaphore(regs.a[0]); return 0; }
722: static ULONG execl_AttemptSemaphore(void) { return EXEC_AttemptSemaphore(regs.a[0]); }
723: static ULONG execl_AddSemaphore(void) { put_byte(regs.a[1] + 8, 15); EXEC_Enqueue(sysbase + 532, regs.a[1]); return 0; }
724:
725: /*
726: * Messages and ports
727: */
728:
729: CPTR EXEC_GetMsg(CPTR port)
730: {
731: return EXEC_RemHead(port + 20);
732: }
733:
734: /* This is shared between PutMsg and ReplyMsg */
735: static void EXEC_doputmsg(CPTR port, CPTR msg)
736: {
737: UBYTE flags = get_byte (port + 14);
738: EXEC_AddTail(port + 20, msg);
739: if (flags == 0)
740: EXEC_Signal(get_long(port + 16), 1 << get_byte(port + 15));
741: else if (flags == 1)
742: fprintf(stderr, "PA_SOFTINT unsupported\n");
743:
744: }
745:
746: void EXEC_PutMsg(CPTR port, CPTR msg)
747: {
748: put_byte(msg + 8, 5);
749: EXEC_doputmsg(port, msg);
750: }
751:
752: void EXEC_ReplyMsg(CPTR msg)
753: {
754: put_byte(msg + 8, 7);
755: EXEC_doputmsg(get_long(msg + 14), msg);
756: }
757:
758: CPTR EXEC_WaitPort(CPTR port)
759: {
760: for (;;) {
761: CPTR msg = get_long(port + 20);
762: if (get_long(msg) != 0)
763: return msg;
764: if (get_byte(port + 14) != 0)
765: fprintf(stderr, "Don't know how to WaitPort()\n");
766: EXEC_Wait(1 << get_byte(port + 15));
767: }
768: }
769:
770: static ULONG execl_GetMsg(void) { return EXEC_GetMsg(regs.a[0]); }
771: static ULONG execl_PutMsg(void) { EXEC_PutMsg(regs.a[0], regs.a[1]); return 0; }
772: static ULONG execl_ReplyMsg(void) { EXEC_ReplyMsg(regs.a[1]); return 0; }
773: static ULONG execl_WaitPort(void) { return EXEC_WaitPort(regs.a[0]); }
774: static ULONG execl_FindPort(void) { return EXEC_FindName(sysbase + 392, get_real_address(regs.a[1])); }
775: static ULONG execl_AddPort(void) { put_byte(regs.a[1] + 8, 4); EXEC_Enqueue(sysbase + 392, regs.a[1]); return 0; }
776:
777: /*
778: * I/O
779: */
780:
781: LONG EXEC_WaitIO(CPTR ioreq)
782: {
783: /* The device is supposed to clear the IO_QUICK bit if it's going to
784: * reply to the command */
785: if ((get_byte(ioreq + 30) & 1) == 1)
786: return (LONG)(BYTE)get_byte(ioreq + 31);
787:
788: for (;;) {
789: if (get_byte(ioreq + 8) == 7) /* NT_REPLYMSG? */
790: break;
791: /* We'll just hope that this a) has a ReplyPort and b) that port
792: * is of type PA_SIGNAL
793: * Don't WaitPort() here: WaitPort() returns a message, and we
794: * aren't sure it's for us. */
795:
796: EXEC_Wait(1 << get_byte(get_long(ioreq + 14) + 15));
797: }
798: EXEC_Remove(ioreq);
799: return (LONG)(BYTE)get_byte(ioreq + 31);
800: }
801:
802: static void EXEC_BeginIO(CPTR ioreq)
803: {
804: CPTR dev = get_long(ioreq + 20);
805: regs.a[6] = dev;
806: regs.a[1] = ioreq;
807: Call68k(dev - 30, 1);
808: }
809:
810: void EXEC_DoIO(CPTR ioreq)
811: {
812: put_byte(ioreq + 30, 1);
813: EXEC_BeginIO(ioreq);
814: EXEC_WaitIO(ioreq);
815: }
816:
817: void EXEC_SendIO(CPTR ioreq)
818: {
819: put_byte(ioreq + 30, 0);
820: EXEC_BeginIO(ioreq);
821: }
822:
823: CPTR EXEC_CheckIO(CPTR ioreq)
824: {
825: if ((get_byte(ioreq + 30) & 1) == 1)
826: return ioreq;
827: if (get_byte(ioreq + 8) == 7)
828: return ioreq;
829: return 0;
830: }
831:
832: static ULONG execl_WaitIO(void) { return EXEC_WaitIO(regs.a[1]); }
833: static ULONG execl_DoIO(void) { EXEC_DoIO(regs.a[1]); return 0; }
834: static ULONG execl_SendIO(void) { EXEC_SendIO(regs.a[1]); return 0; }
835: static ULONG execl_CheckIO(void) { return EXEC_CheckIO(regs.a[1]); }
836:
837: /*
838: * Libraries
839: */
840:
841: void EXEC_SumLibrary(CPTR lib)
842: {
843: CPTR start = lib - get_word(lib + 16);
844: int len = get_word(lib + 16) + get_word(lib + 18);
845: ULONG sum = 0;
846: UWORD flags = get_word(lib + 14);
847:
848: if (flags & 1) /* SUMMING? */
849: return;
850: if (!(flags & 4)) /* SUMUSED? */
851: return;
852: put_word(lib + 14, flags & ~2); /* mark as not changed */
853: /* Pretend the checksum is OK, I don't care enough */
854: }
855:
856: CPTR EXEC_SetFunction(CPTR lib, int funcOffset, CPTR function)
857: {
858: CPTR oldfunc = get_long(lib + funcOffset + 2);
859: put_word(lib + funcOffset, 0x4EF9);
860: put_long(lib + funcOffset + 2, function);
861: put_word(lib + 14, get_word(lib + 14) | 2);
862: EXEC_SumLibrary(lib);
863: return oldfunc;
864: }
865:
866: void EXEC_AddLibrary(CPTR lib)
867: {
868: EXEC_Enqueue(sysbase + 378, lib);
869: put_word(lib + 14, 2); /* mark as changed */
870: EXEC_SumLibrary(lib);
871: }
872:
873: CPTR EXEC_OpenLibrary(char *name, int version)
874: {
875: CPTR lib = EXEC_FindName(sysbase + 378, name);
876: if (lib != 0) {
877: regs.a[6] = lib;
878: regs.d[0] = version;
879: lib = Call68k(lib - 6, 1);
880: }
881: return lib;
882: }
883:
884: CPTR EXEC_OpenDevice(char *name, ULONG unit, CPTR ioRequest, ULONG flags)
885: {
886: CPTR dev = EXEC_FindName(sysbase + 350, name);
887: CPTR replyport = get_long(ioRequest + 14);
888: put_long(ioRequest + 20, dev);
889: put_byte(ioRequest + 31, 0);
890: put_byte(ioRequest + 30, flags); /* is this right? */
891: if (replyport == 0)
892: fprintf(stderr, "ioRequest has no ReplyPort\n");
893: else {
894: CPTR rtask = get_long(replyport + 16);
895: if (rtask == 0)
896: fprintf(stderr, "replyTask == 0\n");
897: else if (rtask != get_long(sysbase + 276))
898: fprintf(stderr, "replyTask != current\n");
899: /* put_long(replyport + 16, get_long(sysbase + 276));*/
900: }
901: if (dev != 0) {
902: regs.a[6] = dev;
903: regs.a[1] = ioRequest;
904: regs.d[0] = unit;
905: regs.d[1] = flags;
906: dev = Call68k(dev - 6, 1);
907: }
908: return (LONG)(BYTE)get_byte(ioRequest + 31);
909: }
910:
911: void EXEC_AddDevice(CPTR lib)
912: {
913: EXEC_Enqueue(sysbase + 350, lib);
914: }
915:
916: void EXEC_AddResource(CPTR lib)
917: {
918: EXEC_Enqueue(sysbase + 336, lib);
919: }
920:
921: CPTR EXEC_OpenResource(char *name)
922: {
923: CPTR lib = EXEC_FindName(sysbase + 336, name);
924: return lib;
925: }
926:
927: void EXEC_MakeFunctions(CPTR target, CPTR funcarray, CPTR funcdispb)
928: {
929: if (funcdispb != 0) {
930: WORD tmp;
931: for (;;) {
932: tmp = get_word(funcarray); funcarray += 2;
933: if (tmp == -1)
934: break;
935: target -= 6;
936: put_word(target, 0x4EF9); /* JMP.L */
937: put_long(target + 2, funcdispb + tmp);
938: }
939: } else {
940: CPTR tmp;
941: for (;;) {
942: tmp = get_long(funcarray); funcarray += 4;
943: if (tmp == (CPTR)-1)
944: break;
945: target -= 6;
946: put_word(target, 0x4EF9); /* JMP.L */
947: put_long(target + 2, tmp);
948: }
949: }
950: }
951:
952: /* This doesn't work yet */
953: CPTR EXEC_MakeLibrary(CPTR vectors, CPTR structure, CPTR init,
954: unsigned long dsize, ULONG seglist_b)
955: {
956: CPTR seglist = seglist_b << 2;
957: int vec_cnt = 0;
958: unsigned long negsize;
959: CPTR base, fdispb = 0, funcarray = vectors;
960: ULONG retval = 0;
961:
962: fprintf(stderr, "MakeLibrary\n");
963: if (get_word (vectors) == (UWORD)-1) {
964: int offs = 2;
965: fdispb = vectors;
966: funcarray += 2;
967: while (get_word (vectors+offs) != (UWORD)-1) {
968: offs += 2;
969: vec_cnt++;
970: }
971: } else {
972: int offs = 0;
973: while (get_long (vectors+offs) != (LONG)-1) {
974: offs += 4;
975: vec_cnt++;
976: }
977: }
978: negsize = (vec_cnt * 6 + 3) & ~3;
979: dsize = (dsize + 3) & ~3;
980:
981: base = EXEC_AllocMem(negsize + dsize, MEMF_PUBLIC|MEMF_CLEAR);
982: if (base == 0) /* Uh oh */
983: return 0;
984: EXEC_MakeFunctions(base + negsize, funcarray, fdispb);
985: base += negsize;
986: put_word(base + 16, negsize);
987: put_word(base + 18, dsize);
988: if (structure != 0) {
989: /* Size is set to 0 so we won't clear it again */
990: EXEC_InitStruct(structure, base, 0);
991: }
992: if (init != 0) {
993: regs.a[6] = sysbase;
994: regs.a[0] = seglist_b; /* BCPL seglist here? */
995: regs.d[0] = base;
996: /* call it */
997: retval = Call68k(init, 0);
998: } else
999: retval = base;
1000:
1001: return retval;
1002: }
1003:
1004: CPTR EXEC_InitResident(CPTR resident, ULONG segList)
1005: {
1006: UBYTE flags = get_byte(resident + 10);
1007:
1008: if (flags & 0x80) {
1009: CPTR autoinit = get_long(resident + 22);
1010: return EXEC_MakeLibrary(get_long(autoinit + 4), get_long(autoinit + 8),
1011: get_long(autoinit + 12), get_long(autoinit), segList >> 4);
1012: }
1013:
1014: regs.d[0] = 0; regs.a[0] = segList; regs.a[6] = sysbase;
1015: return Call68k(get_long(resident + 22), 0);
1016: }
1017:
1018: static ULONG execl_MakeFunctions(void) { EXEC_MakeFunctions(regs.a[0], regs.a[1], regs.a[2]); return 0; }
1019: static ULONG execl_SumLibrary(void) { EXEC_SumLibrary(regs.a[1]); return 0; }
1020: static ULONG execl_SetFunction(void) { return EXEC_SetFunction(regs.a[1], (WORD)regs.a[0], regs.d[0]); }
1021: static ULONG execl_AddLibrary(void) { EXEC_AddLibrary(regs.a[1]); return 0; }
1022: static ULONG execl_AddDevice(void) { EXEC_AddDevice(regs.a[1]); return 0; }
1023: static ULONG execl_AddResource(void) { EXEC_AddResource(regs.a[1]); return 0; }
1024: static ULONG execl_OpenLibrary(void) { return EXEC_OpenLibrary(get_real_address(regs.a[1]), regs.d[0]); }
1025: static ULONG execl_OpenDevice(void) { return EXEC_OpenDevice(get_real_address(regs.a[0]), regs.d[0], regs.a[1], regs.d[1]); }
1026: static ULONG execl_OpenResource(void) { return EXEC_OpenResource(get_real_address(regs.a[1])); }
1027: static ULONG execl_MakeLibrary(void) { return EXEC_MakeLibrary(regs.a[0], regs.a[1], regs.a[2], regs.d[0], regs.d[1]); }
1028:
1029: /*
1030: * Tasks
1031: */
1032:
1033: static void task_startup(void)
1034: {
1035: m68k_setpc(regs.pc);
1036: Call68k_retaddr(regs.pc, 0, get_long(regs.a[7] - 4));
1037: fprintf(stderr, "Task fell through at the end\n");
1038: }
1039:
1040: CPTR EXEC_AddTask(CPTR task, CPTR initPC, CPTR finalPC)
1041: {
1042: #ifdef USE_EXECLIB
1043: struct NewTask *nt = (struct NewTask *)malloc(sizeof (struct NewTask));
1044: nt->exectask = task;
1045: nt->prev = &idle_task;
1046: nt->next = idle_task.next;
1047: idle_task.next->prev = nt;
1048: idle_task.next = nt;
1049: memset(&nt->regs, 0, sizeof (nt->regs));
1050: nt->regs.pc = initPC;
1051: nt->regs.a[7] = get_long(task + 54);
1052:
1053: if (finalPC == 0)
1054: finalPC = 0xF0FFF0; /* standard "return from 68k mode" calltrap */
1055: put_byte(task + 16, 0xFF);
1056: put_byte(task + 17, 0xFF);
1057: put_long(nt->regs.a[7] - 4, finalPC);
1058: nt->stack = malloc(65536); /* @@@ make this smaller after checking that
1059: * no parts of the emulator need much stack
1060: * space */
1061: nt->j[0].__sp = nt->stack + 65536;
1062: nt->j[0].__pc = &task_startup;
1063: put_byte(task + 15, TS_READY);
1064: put_long(task + 18,0x0000FFFF); /* all tasks have the lower 16 signals allocated */
1065: EXEC_Enqueue(sysbase + 406, task);
1066: need_resched = 1;
1067: maybe_schedule();
1068: return task;
1069: #endif
1070: }
1071:
1072: CPTR EXEC_FindTask(char *name)
1073: {
1074: char *n;
1075: CPTR v;
1076:
1077: if (name == NULL || ((n = get_real_address(get_long(get_long(sysbase + 276) + 10))) != NULL
1078: && strcmp(n, name) == 0))
1079: return get_long(sysbase + 276);
1080:
1081: v = EXEC_FindName(sysbase + 406, name); /* ready tasks */
1082: if (v != 0)
1083: return v;
1084: return EXEC_FindName(sysbase + 420, name); /* waiting tasks */
1085: }
1086:
1087: static ULONG execl_FindTask(void) { return EXEC_FindTask(regs.a[1] == 0 ? NULL : get_real_address(regs.a[1])); }
1088: static ULONG execl_AddTask(void) { return EXEC_AddTask(regs.a[1], regs.a[2], regs.a[3]); }
1089:
1090: ULONG EXEC_Forbid(void)
1091: {
1092: int count = (BYTE)get_byte(sysbase + 295);
1093: count++;
1094: put_byte(sysbase + 295, count);
1095: return 0;
1096: }
1097: ULONG EXEC_Permit(void)
1098: {
1099: int count = (BYTE)get_byte(sysbase + 295);
1100: if (count == -1)
1101: fprintf(stderr, "Too many Permit() calls\n");
1102: else
1103: count--;
1104: put_byte(sysbase + 295, count);
1105: maybe_schedule();
1106: return 0;
1107: }
1108:
1109: ULONG EXEC_Disable(void)
1110: {
1111: int count = (BYTE)get_byte(sysbase + 294);
1112: count++;
1113: put_byte(sysbase + 294, count);
1114: put_word(0xDFF09A, 0x4000);
1115: return 0;
1116: }
1117:
1118: ULONG EXEC_Enable(void)
1119: {
1120: int count = (BYTE)get_byte(sysbase + 294);
1121: if (count == -1)
1122: fprintf(stderr, "Too many Enable() calls\n");
1123: else
1124: count--;
1125: if (count == -1)
1126: put_word(0xDFF09A, 0xC000);
1127: put_byte(sysbase + 294, count);
1128: maybe_schedule();
1129: return 0;
1130: }
1131: /*
1132: * Initialization
1133: */
1134: static ULONG execlib_init(void)
1135: {
1136: sysbase = get_long(4);
1137:
1138: /* CopyMem and CopyMemQuick */
1139: libemu_InstallFunction(execl_CopyMem, sysbase, -630);
1140: libemu_InstallFunction(execl_CopyMem, sysbase, -624);
1141: libemu_InstallFunction(execl_Allocate, sysbase, -186);
1142: libemu_InstallFunction(execl_AllocMem, sysbase, -198);
1143: libemu_InstallFunction(execl_Deallocate, sysbase, -192);
1144: libemu_InstallFunction(execl_FreeMem, sysbase, -210);
1145: libemu_InstallFunction(execl_AvailMem, sysbase, -216);
1146:
1147: /* List management */
1148: libemu_InstallFunction(execl_Insert, sysbase, -234);
1149: libemu_InstallFunction(execl_AddHead, sysbase, -240);
1150: libemu_InstallFunction(execl_AddTail, sysbase, -246);
1151: libemu_InstallFunction(execl_Enqueue, sysbase, -270);
1152: libemu_InstallFunction(execl_RemHead, sysbase, -258);
1153: libemu_InstallFunction(execl_RemTail, sysbase, -264);
1154: libemu_InstallFunction(execl_Remove, sysbase, -252);
1155: libemu_InstallFunction(execl_FindName, sysbase, -276);
1156:
1157: /* Signals */
1158: libemu_InstallFunction(execl_AllocSignal, sysbase, -330);
1159: libemu_InstallFunction(execl_FreeSignal, sysbase, -336);
1160:
1161: /* Semaphores */
1162: libemu_InstallFunction(execl_FindSemaphore, sysbase, -594);
1163: libemu_InstallFunction(execl_InitSemaphore, sysbase, -558);
1164: libemu_InstallFunction(execl_AddSemaphore, sysbase, -600);
1165:
1166: /* Messages/Ports */
1167: libemu_InstallFunction(execl_FindPort, sysbase, -390);
1168: libemu_InstallFunction(execl_GetMsg, sysbase, -372);
1169:
1170: /* Libraries */
1171: libemu_InstallFunction(execl_MakeFunctions, sysbase, -90);
1172: libemu_InstallFunction(execl_SumLibrary, sysbase, -426);
1173: libemu_InstallFunction(execl_SetFunction, sysbase, -420);
1174:
1175: /* Tasks */
1176: libemu_InstallFunction(execl_FindTask, sysbase, -294);
1177:
1178: /* Interrupts */
1179: libemu_InstallFunction(execl_SetIntVector, sysbase, -162);
1180: libemu_InstallFunction(execl_AddIntServer, sysbase, -168);
1181: libemu_InstallFunction(execl_RemIntServer, sysbase, -174);
1182:
1183: /* Miscellaneous */
1184: libemu_InstallFunction(execl_InitStruct, sysbase, -78);
1185:
1186: return 0;
1187: }
1188:
1189: static ULONG execlib_init2(void)
1190: {
1191: sysbase = get_long(4);
1192:
1193: libemu_InstallFunction(execl_AllocEntry, sysbase, -222);
1194:
1195: libemu_InstallFunction(execl_AddLibrary, sysbase, -396);
1196: libemu_InstallFunction(execl_AddDevice, sysbase, -432);
1197: libemu_InstallFunction(execl_AddResource, sysbase, -486);
1198: libemu_InstallFunction(execl_OpenLibrary, sysbase, -552);
1199: libemu_InstallFunction(execl_OpenDevice, sysbase, -444);
1200: libemu_InstallFunction(execl_OpenResource, sysbase, -498);
1201: libemu_InstallFunction(execl_MakeLibrary, sysbase, -84);
1202:
1203: libemu_InstallFunctionFlags(EXEC_Disable, sysbase, -120, TRAPFLAG_NORETVAL);
1204: libemu_InstallFunctionFlags(EXEC_Enable, sysbase, -126, TRAPFLAG_NORETVAL);
1205: libemu_InstallFunctionFlags(EXEC_Permit, sysbase, -138, TRAPFLAG_NORETVAL);
1206: libemu_InstallFunctionFlags(EXEC_Forbid, sysbase, -132, TRAPFLAG_NORETVAL);
1207:
1208: libemu_InstallFunction(execl_AddTask, sysbase, -282);
1209:
1210: libemu_InstallFunction(execl_SetSignal, sysbase, -306);
1211: libemu_InstallFunction(execl_Signal, sysbase, -324);
1212: libemu_InstallFunction(execl_Wait, sysbase, -318);
1213:
1214: libemu_InstallFunction(execl_PutMsg, sysbase, -366);
1215: libemu_InstallFunction(execl_ReplyMsg, sysbase, -378);
1216: libemu_InstallFunction(execl_WaitPort, sysbase, -384);
1217:
1218: libemu_InstallFunction(execl_WaitIO, sysbase, -474);
1219: libemu_InstallFunction(execl_DoIO, sysbase, -456);
1220: libemu_InstallFunction(execl_SendIO, sysbase, -462);
1221: libemu_InstallFunction(execl_CheckIO, sysbase, -468);
1222:
1223: libemu_InstallFunctionFlags(execl_ObtainSemaphore, sysbase, -564, TRAPFLAG_NORETVAL);
1224: libemu_InstallFunctionFlags(execl_ReleaseSemaphore, sysbase, -570, TRAPFLAG_NORETVAL);
1225: libemu_InstallFunction(execl_AttemptSemaphore, sysbase, -576);
1226:
1227: return 0;
1228: }
1229:
1230: /*
1231: * These functions are one day going to bootstrap the emulated Exec
1232: */
1233:
1234: #define NR_EXEC_FUNCTIONS 105 /* V34 (1.3) maximum */
1235:
1236: static ULONG EXEC_ENOSYS(void)
1237: {
1238: fprintf(stderr, "Not a system call\n");
1239: return 0;
1240: }
1241:
1242: static ULONG EXEC_StandardIntVec(void)
1243: {
1244: int num = regs.a[1];
1245: /* Call the IntHandlers */
1246: return 0;
1247: }
1248:
1249: static ULONG EXEC_IntTrap(void)
1250: {
1251: UWORD intsreq = get_word(0xDFF01E) & get_word(0xDFF01C);
1252: int i;
1253: intr_count++;
1254:
1255: for (i = 13; i >= 0; i--) {
1256: if ((intsreq & (1 << i)) != 0) {
1257: /* Is this a server chain? */
1258: if (i == 3 || i == 4 || i == 5 || i == 13 || i == 15) {
1259: CPTR slist = get_long(sysbase + 84 + 12*i);
1260: CPTR snode = get_long(slist);
1261: for (;;) {
1262: if (get_long(snode) == 0)
1263: break;
1264: regs.a[0] = 0xDFF000;
1265: regs.a[5] = get_long(snode + 18);
1266: regs.a[1] = get_long(snode + 14);
1267: Call68k(regs.a[5], 0);
1268: if (ZFLG == 0)
1269: break;
1270: snode = get_long(snode);
1271: }
1272: put_word(0xDFF09C, 1 << i);
1273: } else {
1274: CPTR intnode = get_long(sysbase + 84 + 12*i + 8);
1275: regs.d[1] = intsreq;
1276: regs.a[1] = get_long(intnode + 14);
1277: regs.a[0] = 0xDFF000;
1278: regs.a[5] = get_long(intnode + 18);
1279: regs.a[6] = sysbase;
1280: Call68k(regs.a[5], 0);
1281: }
1282: break;
1283: }
1284: }
1285: if (i < 0)
1286: fprintf(stderr, "So what interrupt am I supposed to serve?\n");
1287: intr_count--;
1288: maybe_schedule();
1289: }
1290:
1291: void execlib_sysinit(void)
1292: {
1293: CPTR tmp, tmp2;
1294: CPTR enosys = deftrap(EXEC_ENOSYS);
1295: CPTR intvec = deftrap(EXEC_StandardIntVec);
1296: CPTR inttrap = deftrap2(EXEC_IntTrap, TRAPFLAG_NORETVAL);
1297: CPTR sysstack;
1298: int i;
1299:
1300: tmp = here();
1301: calltrap2(enosys); dw(RTS);
1302:
1303: /* why 0x400? */
1304: sysbase = 0x400 + NR_EXEC_FUNCTIONS*6;
1305: memset(get_real_address(sysbase), 0, 558);
1306: put_long(4, sysbase);
1307:
1308: /* Build vectors. We initialize SetFunction so we can call execlib_Init() */
1309: tmp2 = here();
1310: calltrap(deftrap(execl_SetFunction));
1311: dw(RTS);
1312: for (i = 0; i < NR_EXEC_FUNCTIONS; i++) {
1313: put_word(sysbase - 6*(i+1), 0x4EF9);
1314: put_long(sysbase - 6*(i+1) + 2, i == 69 ? tmp2 : tmp);
1315: }
1316:
1317: /* Build syslists */
1318: EXEC_NewList(sysbase + 322); /* MemList */
1319: EXEC_NewList(sysbase + 336); /* ResourceList */
1320: EXEC_NewList(sysbase + 350); /* ResourceList */
1321: EXEC_NewList(sysbase + 364); /* List */
1322: EXEC_NewList(sysbase + 378); /* LibList */
1323: EXEC_NewList(sysbase + 392); /* PortList */
1324: EXEC_NewList(sysbase + 406); /* TaskReady */
1325: EXEC_NewList(sysbase + 420); /* TaskWait */
1326: EXEC_NewList(sysbase + 434); /* SoftInts[5] */
1327: EXEC_NewList(sysbase + 450);
1328: EXEC_NewList(sysbase + 466);
1329: EXEC_NewList(sysbase + 482);
1330: EXEC_NewList(sysbase + 498);
1331: EXEC_NewList(sysbase + 532); /* SemaphoreList */
1332:
1333: tmp = sysbase + 558; /* sizeof struct V34 execbase */
1334: /* We put the supervisor stack at the end, the user stack for our new
1335: * task at the end - 0x800, and build the ResModules array at the bottom
1336: * of the stack */
1337: sysstack = chipmem_size - 0x2000;
1338:
1339: /* Don't mess with Fast or Bogo for now, just set up Chip */
1340: EXEC_AddMemList(sysstack - tmp, MEMF_CHIP|MEMF_PUBLIC, -10, tmp,
1341: ds("Chip Memory"));
1342:
1343: /* Set up the CPU */
1344: regs.usp = chipmem_size - 0x800;
1345: regs.isp = chipmem_size; /* What about MSP? */
1346: regs.a[7] = regs.usp;
1347: regs.s = 0; regs.m = 0;
1348: regs.vbr = 0;
1349: regs.t0 = regs.t1 = 0;
1350: regs.intmask = 0;
1351: put_word(0xDFF09A, 0x7FFF);
1352: put_word(0xDFF096, 0x7FFF);
1353: put_word(0xDFF09C, 0x7FFF);
1354: put_word(0xDFF09A, 0xC000);
1355: put_word(0xDFF096, 0xE100);
1356: /* Initialize our supported functions */
1357: execlib_init();
1358: execlib_init2();
1359:
1360: /* Initialize interrupts */
1361: intr_count = 0;
1362: put_byte(sysbase + 294, 0xFF);
1363: put_byte(sysbase + 295, 0xFF);
1364:
1365: tmp = here();
1366: calltrap2(inttrap);
1367: dw(RTE);
1368: for (i = 0; i < 8; i++)
1369: put_long((24+i)*4, tmp);
1370:
1371: tmp = here();
1372: calltrap2(intvec); dw(RTS);
1373: for (i = 0; i < 16; i++) {
1374: tmp2 = 0;
1375: /* Is this a server chain? */
1376: if (i == 3 || i == 4 || i == 5 || i == 13 || i == 15)
1377: EXEC_NewList(tmp2 = EXEC_AllocMem(14, MEMF_PUBLIC));
1378: put_long(sysbase + 84 + i*12, tmp2);
1379: put_long(sysbase + 84 + i*12 + 4, tmp);
1380: put_long(sysbase + 84 + i*12 + 8, 0);
1381: }
1382: put_word(0xDFF09A, 0xAFC3); /* Enable everything but the server chains */
1383: /* Set up the init task. We don't really set it up properly. */
1384: tmp = EXEC_AllocMem(92, MEMF_CLEAR);
1385: put_long(sysbase + 276, tmp);
1386: put_byte(tmp + 8, 1);
1387: put_byte(tmp + 9, -127);
1388: put_long(tmp + 10, ds("init"));
1389: put_byte(tmp + 16, 0xFF);
1390: put_byte(tmp + 17, 0xFF);
1391: put_long(tmp + 54, chipmem_size - 0x804);
1392: put_long(tmp + 58, chipmem_size - 0x1800);
1393: put_long(tmp + 62, chipmem_size - 0x800);
1394: put_byte(tmp + 15, TS_RUN);
1395: put_long(tmp + 18,0x0000FFFF);
1396: EXEC_NewList(tmp + 74);
1397: idle_task.next = idle_task.prev = &idle_task;
1398: idle_task.exectask = tmp;
1399: idle_task.stack = NULL; /* we have a stack for this one already */
1400:
1401: /* Set up an idle task */
1402: tmp2 = here();
1403: dw (0x4E72); dw(0x2000); dw (0x4eF9); dl (tmp2);
1404:
1405: tmp = EXEC_AllocMem(92, MEMF_CLEAR);
1406: put_byte(tmp + 8, 1);
1407: put_byte(tmp + 9, -128);
1408: put_long(tmp + 10, ds("idle"));
1409: put_long(tmp + 58, chipmem_size - 0x2000);
1410: put_long(tmp + 62, chipmem_size - 0x1800);
1411: put_long(tmp + 54, chipmem_size - 0x1804);
1412: EXEC_NewList(tmp + 74);
1413: EXEC_AddTask(tmp, tmp2, 0); /* This won't start executing yet */
1414: find_newtask(tmp)->regs.s = 1;
1415:
1416:
1417: /* Grep Kickstart for resident modules */
1418: regs.a[7] -= 4;
1419: put_long(regs.a[7], 0);
1420: tmp2 = regs.a[7];
1421: for (tmp = 0xF80000; tmp < 0xFFFFFF; tmp += 2) {
1422: if (get_word(tmp) == 0x4AFC && get_long(tmp + 2) == tmp) {
1423: regs.a[7] -= 4; put_long(regs.a[7], tmp);
1424: }
1425: }
1426: put_long(sysbase + 300, regs.a[7]);
1427: /* Bubble me do */
1428: for (tmp = regs.a[7]; tmp < tmp2; tmp += 4) {
1429: CPTR tmp3;
1430: for (tmp3 = tmp2 - 4; tmp3 > tmp; tmp3 -= 4) {
1431: if ((BYTE)get_byte(get_long(tmp3) + 13) > (BYTE)get_byte(get_long(tmp3 - 4) + 13)) {
1432: CPTR tmp4 = get_long(tmp3);
1433: put_long(tmp3, get_long(tmp3 - 4));
1434: put_long(tmp3 - 4, tmp4);
1435: }
1436: }
1437: }
1438:
1439: /* Initialize them and watch everything blow up. */
1440: for (tmp = regs.a[7]; (tmp2 = get_long(tmp)) != 0; tmp += 4) {
1441: UBYTE flags = get_byte(tmp2 + 10);
1442: if (!(flags & 1)) /* RTF_COLDSTART? */
1443: continue;
1444: if (strncmp("alert", get_real_address(get_long(tmp2 + 18)), 5) == 0)
1445: /*continue*/;
1446: fprintf(stderr, "Initializing %s\n", get_real_address(get_long(tmp2 + 18)));
1447: EXEC_InitResident(tmp2, /* ? */ 0);
1448: }
1449: /* Idle task */
1450: for(;;) {
1451: Call68k(0xF0FFF0 - 4, 0);
1452: schedule();
1453: }
1454: }
1455:
1456: /*
1457: * Install the gfx-library-replacement
1458: */
1459: void execlib_install(void)
1460: {
1461: ULONG begin, end, resname, resid;
1462: int i;
1463:
1464: if (!use_gfxlib)
1465: return;
1466:
1467: resname = ds("UAEexeclib.resource");
1468: resid = ds("UAE execlib 0.1");
1469:
1470: begin = here();
1471: dw(0x4AFC); /* RTC_MATCHWORD */
1472: dl(begin); /* our start address */
1473: dl(0); /* Continue scan here */
1474: dw(0x0101); /* RTF_COLDSTART; Version 1 */
1475: dw(0x0805); /* NT_RESOURCE; pri 5 */
1476: dl(resname); /* name */
1477: dl(resid); /* ID */
1478: dl(here() + 4); /* Init area: directly after this */
1479:
1480: calltrap(deftrap(execlib_init)); dw(RTS);
1481:
1482: end = here();
1483: org(begin + 6);
1484: dl(end);
1485:
1486: org(end);
1487:
1488: intr_count = 1; /* So we don't try to schedule if we don't emulate
1489: * all of Exec */
1490: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.