![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to m68010.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [The Machine Emulator] / tme / ic / m68k|
Return to m68010.c CVS log | Up to [The Machine Emulator] / tme / ic / m68k |
1.1 root 1: /* $Id: m68010.c,v 1.5 2003/05/16 21:48:10 fredette Exp $ */
2:
3: /* ic/m68k/m68010.c - implementation of Motorola 68010 emulation: */
4:
5: /*
6: * Copyright (c) 2002, 2003 Matt Fredette
7: * All rights reserved.
8: *
9: * Redistribution and use in source and binary forms, with or without
10: * modification, are permitted provided that the following conditions
11: * are met:
12: * 1. Redistributions of source code must retain the above copyright
13: * notice, this list of conditions and the following disclaimer.
14: * 2. Redistributions in binary form must reproduce the above copyright
15: * notice, this list of conditions and the following disclaimer in the
16: * documentation and/or other materials provided with the distribution.
17: * 3. All advertising materials mentioning features or use of this software
18: * must display the following acknowledgement:
19: * This product includes software developed by Matt Fredette.
20: * 4. The name of the author may not be used to endorse or promote products
21: * derived from this software without specific prior written permission.
22: *
23: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
25: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
27: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
28: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
29: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
31: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
32: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33: * POSSIBILITY OF SUCH DAMAGE.
34: */
35:
36: #include <tme/common.h>
37: _TME_RCSID("$Id: m68010.c,v 1.5 2003/05/16 21:48:10 fredette Exp $");
38:
39: /* includes: */
40: #include "m68k-impl.h"
41:
42: /* macros: */
43: #define TME_M68K_SSW8_RR 0x8000
44: #define TME_M68K_SSW8_IF 0x2000
45: #define TME_M68K_SSW8_DF 0x1000
46: #define TME_M68K_SSW8_RM 0x0800
47: #define TME_M68K_SSW8_HI 0x0400
48: #define TME_M68K_SSW8_BX 0x0200
49: #define TME_M68K_SSW8_RW 0x0100
50:
51: /* structures: */
52:
53: /* the format 8 stack frame: */
54: /* XXX we assume that this will pack: */
55: struct tme_m68k_fmt8 {
56:
57: /* the special status word: */
58: tme_uint16_t tme_m68k_fmt8_ssw;
59:
60: /* the faulting address: */
61: tme_uint16_t tme_m68k_fmt8_addr_high;
62: tme_uint16_t tme_m68k_fmt8_addr_low;
63:
64: /* the first unused word: */
65: tme_uint8_t tme_m68k_fmt8_state0[2];
66:
67: /* the data output buffer: */
68: tme_uint8_t tme_m68k_fmt8_dob[2];
69:
70: /* the second unused word: */
71: tme_uint8_t tme_m68k_fmt8_state1[2];
72:
73: /* the data input buffer: */
74: tme_uint8_t tme_m68k_fmt8_dib[2];
75:
76: /* the third unused word: */
77: tme_uint8_t tme_m68k_fmt8_state2[2];
78:
79: /* the instruction input buffer: */
80: tme_uint8_t tme_m68k_fmt8_iib[2];
81:
82: /* the internal information: */
83: tme_uint8_t tme_m68k_fmt8_state3[32];
84: };
85:
86: /* both executors are for the 68010: */
87: #define _TME_M68K_EXECUTE_CPU TME_M68K_M68010
88:
89: /* create the slow executor: */
90: #define _TME_M68K_EXECUTE_NAME _tme_m68010_execute_slow
91: #undef _TME_M68K_EXECUTE_FAST
92: #undef _TME_M68K_EXECUTE_SLOW
93: #include "m68k-execute.c"
94: #undef _TME_M68K_EXECUTE_NAME
95: #undef _TME_M68K_EXECUTE_FAST
96: #undef _TME_M68K_EXECUTE_SLOW
97:
98: /* create the fast executor: */
99: #define _TME_M68K_EXECUTE_NAME _tme_m68010_execute
100: #define _TME_M68K_EXECUTE_FAST
101: #define _TME_M68K_EXECUTE_SLOW _tme_m68010_execute_slow
102: #include "m68k-execute.c"
103: #undef _TME_M68K_EXECUTE_NAME
104: #undef _TME_M68K_EXECUTE_FAST
105: #undef _TME_M68K_EXECUTE_SLOW
106:
107: #undef _TME_M68K_EXECUTE_CPU
108:
109: /* m68010 exception processing: */
110: static void
111: _tme_m68010_exception(struct tme_m68k *ic)
112: {
113: tme_uint32_t exceptions;
114: tme_uint8_t raw_state[19 * sizeof(tme_uint16_t)], *raw;
115: unsigned int raw_avail, raw_used;
116: struct tme_m68k_fmt8 fmt8;
117: unsigned int flags;
118: tme_uint8_t function_code;
119: tme_uint16_t ssw;
120:
121: /* get the set of exceptions: */
122: exceptions = ic->_tme_m68k_exceptions;
123:
124: /* a reset exception: */
125: if (exceptions & TME_M68K_EXCEPTION_GROUP0_RESET) {
126:
127: /* do the common reset processing: */
128: tme_m68k_do_reset(ic);
129: /* NOTREACHED */
130: }
131:
132: /* an address or bus error: */
133: else if (exceptions & (TME_M68K_EXCEPTION_GROUP0_AERR
134: | TME_M68K_EXCEPTION_GROUP0_BERR)) {
135:
136: /* start the exception processing: */
137: tme_m68k_exception_process_start(ic, 0);
138:
139: /* start assembling the raw data: */
140: raw = raw_state;
141: raw_avail = sizeof(raw_state);
142: #define RAW_PUT(v) \
143: do { \
144: assert(raw_avail >= sizeof(v)); \
145: memcpy(raw, &v, sizeof(v)); \
146: raw += sizeof(v); \
147: raw_avail -= sizeof(v); \
148: } while (/* CONSTCOND */ 0)
149:
150: /* put in the sequence: */
151: raw_used = tme_m68k_sequence_empty(ic, raw, raw_avail);
152: raw += raw_used;
153: raw_avail -= raw_used;
154:
155: /* dispatch on the mode: */
156: switch (ic->_tme_m68k_group0_sequence._tme_m68k_sequence_mode) {
157:
158: case TME_M68K_MODE_EXECUTION:
159:
160: /* put in the instruction buffer: */
161: raw_used = tme_m68k_insn_buffer_empty(ic, raw, raw_avail);
162: raw += raw_used;
163: raw_avail -= raw_used;
164:
165: /* put in the EA address: */
166: function_code = ic->_tme_m68k_ea_function_code;
167: RAW_PUT(function_code);
168: RAW_PUT(ic->_tme_m68k_ea_address);
169:
170: /* put in the memory X and Y buffers: */
171: RAW_PUT(ic->tme_m68k_ireg_memx32);
172: RAW_PUT(ic->tme_m68k_ireg_memy32);
173:
174: /* done: */
175: break;
176:
177: case TME_M68K_MODE_EXCEPTION:
178:
179: /* put in the exceptions set: */
180: RAW_PUT(ic->_tme_m68k_exceptions);
181:
182: /* put in the shadow status register: */
183: RAW_PUT(ic->tme_m68k_ireg_shadow_sr);
184:
185: /* done: */
186: break;
187:
188: case TME_M68K_MODE_RTE:
189:
190: /* put in the shadow status register: */
191: RAW_PUT(ic->tme_m68k_ireg_shadow_sr);
192:
193: /* put in the next program counter: */
194: RAW_PUT(ic->tme_m68k_ireg_pc_next);
195:
196: /* put in the format/offset word: */
197: RAW_PUT(ic->tme_m68k_ireg_format_offset);
198:
199: break;
200:
201: default: abort();
202: }
203:
204: /* put in the internal state: */
205: raw_avail = raw - raw_state;
206: raw = raw_state;
207: #undef RAW_PUT
208: #define RAW_PUT(f) \
209: do { \
210: raw_used = TME_MIN(sizeof(f), raw_avail); \
211: memcpy(f, raw, raw_used); \
212: raw += raw_used; \
213: raw_avail -= raw_used; \
214: } while (/* CONSTCOND */ 0)
215:
216: /* use all of the reserved regions: */
217: RAW_PUT(fmt8.tme_m68k_fmt8_state0);
218: RAW_PUT(fmt8.tme_m68k_fmt8_state1);
219: RAW_PUT(fmt8.tme_m68k_fmt8_state2);
220: RAW_PUT(fmt8.tme_m68k_fmt8_state3);
221: #undef RAW_PUT
222:
223: /* put in the special status word and the data output buffer: */
224: ssw = 0;
225: flags = ic->_tme_m68k_group0_flags;
226: if (flags & TME_M68K_BUS_CYCLE_READ) {
227: ssw |= (TME_M68K_SSW8_RW
228: | ((flags & TME_M68K_BUS_CYCLE_FETCH)
229: ? TME_M68K_SSW8_IF
230: : TME_M68K_SSW8_DF));
231: assert(ic->_tme_m68k_group0_buffer_read_size <= sizeof(tme_uint16_t));
232: if (ic->_tme_m68k_group0_buffer_read_size == sizeof(tme_uint8_t)) {
233: ssw |= TME_M68K_SSW8_BX;
234: }
235: }
236: else {
237: assert(ic->_tme_m68k_group0_buffer_write_size <= sizeof(tme_uint16_t));
238: if (ic->_tme_m68k_group0_buffer_write_size == sizeof(tme_uint8_t)) {
239: ssw |= TME_M68K_SSW8_BX;
240: }
241: memcpy(fmt8.tme_m68k_fmt8_dob
242: + sizeof(fmt8.tme_m68k_fmt8_dob)
243: - ic->_tme_m68k_group0_buffer_write_size,
244: ic->_tme_m68k_group0_buffer_write,
245: ic->_tme_m68k_group0_buffer_write_size);
246: }
247: if (flags & TME_M68K_BUS_CYCLE_RMW) {
248: ssw |= TME_M68K_SSW8_RM;
249: }
250: ssw |= ic->_tme_m68k_group0_function_code;
251: fmt8.tme_m68k_fmt8_ssw = tme_htobe_u16(ssw);
252:
253: /* put in the fault address: */
254: fmt8.tme_m68k_fmt8_addr_high = tme_htobe_u16(ic->_tme_m68k_group0_address >> 16);
255: fmt8.tme_m68k_fmt8_addr_low = tme_htobe_u16(ic->_tme_m68k_group0_address & 0xffff);
256:
257: /* push the format 8 contents. we don't need to worry about
258: restarting here, because any fault is a double fault: */
259: ic->tme_m68k_ireg_a7 -= sizeof(fmt8);
260: ic->_tme_m68k_ea_address = ic->tme_m68k_ireg_a7;
261: ic->_tme_m68k_ea_function_code = TME_M68K_FC_SD; /* XXX right? */
262: tme_m68k_write_mem(ic, (tme_uint8_t *) &fmt8, sizeof(fmt8));
263:
264: /* now finish the processing for this exception: */
265: tme_m68k_exception_process_finish(ic, TME_M68K_FORMAT_8,
266: ((exceptions & TME_M68K_EXCEPTION_GROUP0_BERR)
267: ? 2
268: : 3));
269: ic->_tme_m68k_exceptions = (exceptions &= ~ (TME_M68K_EXCEPTION_GROUP0_AERR
270: | TME_M68K_EXCEPTION_GROUP0_BERR));
271: }
272:
273: /* do normal exception processing: */
274: tme_m68k_exception_process(ic);
275: /* NOTREACHED */
276: }
277:
278: /* m68010 RTE processing: */
279: static void
280: _tme_m68010_rte(struct tme_m68k *ic)
281: {
282: tme_uint16_t format;
283: struct tme_m68k_fmt8 fmt8;
284: tme_uint32_t fmt8_address;
285: tme_uint8_t raw_state[19 * sizeof(tme_uint16_t)], *raw;
286: unsigned int raw_avail, raw_used;
287: tme_uint8_t function_code;
288: tme_uint16_t ssw;
289: unsigned int flags;
290: tme_uint8_t *ib;
291: unsigned int buffer_size;
292:
293: /* start the RTE: */
294: format = tme_m68k_rte_start(ic);
295:
296: /* if this is a format 0 stack frame, finish it now: */
297: if (format == TME_M68K_FORMAT_0) {
298: ic->_tme_m68k_mode = TME_M68K_MODE_EXECUTION;
299: TME_M68K_SEQUENCE_START;
300: tme_m68k_rte_finish(ic, 0);
301: /* NOTREACHED */
302: }
303:
304: /* whenever we detect a format error, begin exception processing
305: for a format error. we have to back the PC up by the size of the
306: RTE instruction so the PC points to it: */
307: #define FORMAT_ERROR_IF(e) \
308: do { \
309: if (e) { \
310: ic->tme_m68k_ireg_pc -= sizeof(tme_uint16_t); \
311: tme_m68k_exception(ic, TME_M68K_EXCEPTION_GROUP2(0xE)); \
312: /* NOTREACHED */ \
313: } \
314: } while (/* CONSTCOND */ 0)
315:
316: /* this frame must be a format 8 frame: */
317: FORMAT_ERROR_IF(format != TME_M68K_FORMAT_8);
318:
319: /* do a read of the last word in the stack frame to determine
320: accessibility. we rely on tme_m68k_rte_start leaving
321: ic->_tme_m68k_ea_address pointing after the format/offset word: */
322: fmt8_address = ic->_tme_m68k_ea_address;
323: ic->_tme_m68k_ea_address += sizeof(fmt8) - sizeof(tme_uint16_t);
324: tme_m68k_read_memx16(ic);
325:
326: /* read in the format 8 information. if we get a bus error
327: during this operation it's a double fault: */
328: assert(ic->_tme_m68k_exceptions == 0);
329: ic->_tme_m68k_exceptions = TME_M68K_EXCEPTION_GROUP0_BERR;
330: ic->_tme_m68k_ea_address = fmt8_address;
331: tme_m68k_read_mem(ic, (tme_uint8_t *) &fmt8, sizeof(fmt8));
332: ic->_tme_m68k_exceptions = 0;
333:
334: /* get out the fault address: */
335: ic->_tme_m68k_group0_address = ((((tme_uint32_t) tme_betoh_u16(fmt8.tme_m68k_fmt8_addr_high)) << 16)
336: | tme_betoh_u16(fmt8.tme_m68k_fmt8_addr_low));
337:
338: /* get out the special status word and either the data/instruction
339: input buffer or the data output buffer: */
340: ssw = tme_betoh_u16(fmt8.tme_m68k_fmt8_ssw);
341: FORMAT_ERROR_IF(ssw & TME_M68K_SSW8_HI);
342: flags = 0;
343: ic->_tme_m68k_group0_buffer_read_size = 0;
344: ic->_tme_m68k_group0_buffer_read_softrr = 0;
345: ic->_tme_m68k_group0_buffer_write_size = 0;
346: ic->_tme_m68k_group0_buffer_write_softrr = 0;
347: buffer_size = ((ssw & TME_M68K_SSW8_BX)
348: ? sizeof(tme_uint8_t)
349: : sizeof(tme_uint16_t));
350:
351: /* if this was a read cycle: */
352: if (ssw & TME_M68K_SSW8_RW) {
353: flags |= TME_M68K_BUS_CYCLE_READ;
354:
355: /* if this was an instruction fetch cycle: */
356: if (ssw & TME_M68K_SSW8_IF) {
357: flags |= TME_M68K_BUS_CYCLE_FETCH;
358: FORMAT_ERROR_IF(ssw & TME_M68K_SSW8_DF);
359: ib = fmt8.tme_m68k_fmt8_iib;
360: }
361:
362: /* otherwise, this was a data fetch cycle: */
363: else {
364: FORMAT_ERROR_IF((ssw & (TME_M68K_SSW8_IF
365: | TME_M68K_SSW8_DF))
366: != TME_M68K_SSW8_DF);
367: ib = fmt8.tme_m68k_fmt8_dib;
368: }
369:
370: /* if the user reran this cycle, read in the appropriate
371: input buffer: */
372: if (ssw & TME_M68K_SSW8_RR) {
373: memcpy(ic->_tme_m68k_group0_buffer_read,
374: ib + sizeof(tme_uint16_t) - buffer_size,
375: buffer_size);
376: ic->_tme_m68k_group0_buffer_read_softrr = buffer_size;
377: ic->_tme_m68k_group0_buffer_read_size = buffer_size;
378: }
379: }
380:
381: /* otherwise, this was a write cycle: */
382: else {
383:
384: /* if the user reran this cycle, note that, otherwise
385: copy in the data output buffer: */
386: if (ssw & TME_M68K_SSW8_RR) {
387: ic->_tme_m68k_group0_buffer_write_softrr = buffer_size;
388: }
389: else {
390: memcpy(ic->_tme_m68k_group0_buffer_write,
391: fmt8.tme_m68k_fmt8_dob + sizeof(tme_uint16_t) - buffer_size,
392: buffer_size);
393: ic->_tme_m68k_group0_buffer_write_size = buffer_size;
394: }
395: }
396:
397: /* get the fault function code and address: */
398: ic->_tme_m68k_group0_function_code = ssw & TME_M68K_FC_7;
399: ic->_tme_m68k_group0_address =
400: ((((tme_uint32_t) tme_betoh_u16(fmt8.tme_m68k_fmt8_addr_high)) << 16)
401: | tme_betoh_u16(fmt8.tme_m68k_fmt8_addr_low));
402:
403: /* get out our internal state: */
404: raw = raw_state;
405: raw_avail = sizeof(raw_state);
406: #define RAW_GET(f) \
407: do { \
408: raw_used = TME_MIN(sizeof(f), raw_avail); \
409: memcpy(raw, f, raw_used); \
410: raw += raw_used; \
411: raw_avail -= raw_used; \
412: } while (/* CONSTCOND */ 0)
413:
414: /* use all of the reserved regions: */
415: RAW_GET(fmt8.tme_m68k_fmt8_state0);
416: RAW_GET(fmt8.tme_m68k_fmt8_state1);
417: RAW_GET(fmt8.tme_m68k_fmt8_state2);
418: RAW_GET(fmt8.tme_m68k_fmt8_state3);
419: #undef RAW_GET
420:
421: /* take apart the internal state: */
422: raw = raw_state;
423: raw_avail = sizeof(raw_state) - raw_avail;
424: #define RAW_GET(v) \
425: do { \
426: FORMAT_ERROR_IF(raw_avail < sizeof(v)); \
427: memcpy(&v, raw, sizeof(v)); \
428: raw += sizeof(v); \
429: raw_avail -= sizeof(v); \
430: } while (/* CONSTCOND */ 0)
431:
432: /* get out the sequence: */
433: raw_used = tme_m68k_sequence_fill(ic, raw, raw_avail);
434: FORMAT_ERROR_IF(raw_used < 0);
435: raw += raw_used;
436: raw_avail -= raw_used;
437:
438: /* dispatch on the mode: */
439: switch (ic->_tme_m68k_group0_sequence._tme_m68k_sequence_mode) {
440:
441: case TME_M68K_MODE_EXECUTION:
442:
443: /* get out the instruction buffer: */
444: raw_used = tme_m68k_insn_buffer_fill(ic, raw, raw_avail);
445: FORMAT_ERROR_IF(raw_used < 0);
446: raw += raw_used;
447: raw_avail -= raw_used;
448:
449: /* get out the EA address: */
450: RAW_GET(function_code);
451: ic->_tme_m68k_ea_function_code = function_code;
452: RAW_GET(ic->_tme_m68k_ea_address);
453:
454: /* get out the memory X and Y buffers: */
455: RAW_GET(ic->tme_m68k_ireg_memx32);
456: RAW_GET(ic->tme_m68k_ireg_memy32);
457:
458: /* done: */
459: break;
460:
461: case TME_M68K_MODE_EXCEPTION:
462:
463: /* get out the exceptions set: */
464: RAW_GET(ic->_tme_m68k_exceptions);
465:
466: /* get out the shadow status register: */
467: RAW_GET(ic->tme_m68k_ireg_shadow_sr);
468:
469: /* done: */
470: break;
471:
472: case TME_M68K_MODE_RTE:
473:
474: /* get out the shadow status register: */
475: RAW_GET(ic->tme_m68k_ireg_shadow_sr);
476:
477: /* get out the next program counter: */
478: RAW_GET(ic->tme_m68k_ireg_pc_next);
479:
480: /* get out the format/offset word: */
481: RAW_GET(ic->tme_m68k_ireg_format_offset);
482:
483: break;
484:
485: default: FORMAT_ERROR_IF(TRUE);
486: }
487:
488: /* finish the RTE: */
489: ic->_tme_m68k_sequence = ic->_tme_m68k_group0_sequence;
490: TME_M68K_SEQUENCE_RESTART;
491: tme_m68k_rte_finish(ic, sizeof(fmt8));
492: /* NOTREACHED */
493: }
494:
495: /* this creates and returns a new m68010: */
496: TME_ELEMENT_X_NEW_DECL(tme_ic_,m68k,m68010) {
497: struct tme_m68k *ic;
498:
499: /* allocate the m68k structure: */
500: ic = tme_new0(struct tme_m68k, 1);
501: ic->tme_m68k_element = element;
502:
503: /* fill in the m68010-specific parts of the structure: */
504: ic->tme_m68k_type = TME_M68K_M68010;
505: ic->_tme_m68k_mode_execute = _tme_m68010_execute;
506: ic->_tme_m68k_mode_exception = _tme_m68010_exception;
507: ic->_tme_m68k_mode_rte = _tme_m68010_rte;
508: _tme_m68010_decoder_map_init(ic);
509:
510: /* call the common m68k new function: */
511: return (tme_m68k_new(ic, args, extra, _output));
512: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.