Previous 199869 Revisions Next

r20127 Tuesday 8th January, 2013 at 05:44:36 UTC by Andrew Gardner
dsp16: Few more opcodes & spaces->tabs. (nw)
[src/emu/cpu/dsp16]dsp16.c dsp16.h dsp16dis.c dsp16ops.c

trunk/src/emu/cpu/dsp16/dsp16dis.c
r20126r20127
33
44astring disasmF1Field(const UINT8& F1, const UINT8& D, const UINT8& S)
55{
6    astring ret = "";
7    switch (F1)
8    {
9        case 0x00: ret.printf("a%d = p, p = x*y", D); break;
10        case 0x01: ret.printf("a%d = a%d + p, p = x*y", D, S); break;
11        case 0x02: ret.printf("p = x*y"); break;
12        case 0x03: ret.printf("a%d = a%d - p, p = x*y", D, S); break;
13        case 0x04: ret.printf("a%d = p", D); break;
14        case 0x05: ret.printf("a%d = a%d + p", D, S); break;
15        case 0x06: ret.printf("NOP"); break;
16        case 0x07: ret.printf("a%d = a%d - p", D, S); break;
17        case 0x08: ret.printf("a%d = a%d | y", D, S); break;
18        case 0x09: ret.printf("a%d = a%d ^ y", D, S); break;
19        case 0x0a: ret.printf("a%d & y", S); break;
20        case 0x0b: ret.printf("a%d - y", S); break;
21        case 0x0c: ret.printf("a%d = y", D); break;
22        case 0x0d: ret.printf("a%d = a%d + y", D, S); break;
23        case 0x0e: ret.printf("a%d = a%d & y", D, S); break;
24        case 0x0f: ret.printf("a%d = a%d - y", D, S); break;
6   astring ret = "";
7   switch (F1)
8   {
9      case 0x00: ret.printf("a%d = p, p = x*y", D); break;
10      case 0x01: ret.printf("a%d = a%d + p, p = x*y", D, S); break;
11      case 0x02: ret.printf("p = x*y"); break;
12      case 0x03: ret.printf("a%d = a%d - p, p = x*y", D, S); break;
13      case 0x04: ret.printf("a%d = p", D); break;
14      case 0x05: ret.printf("a%d = a%d + p", D, S); break;
15      case 0x06: ret.printf("NOP"); break;
16      case 0x07: ret.printf("a%d = a%d - p", D, S); break;
17      case 0x08: ret.printf("a%d = a%d | y", D, S); break;
18      case 0x09: ret.printf("a%d = a%d ^ y", D, S); break;
19      case 0x0a: ret.printf("a%d & y", S); break;
20      case 0x0b: ret.printf("a%d - y", S); break;
21      case 0x0c: ret.printf("a%d = y", D); break;
22      case 0x0d: ret.printf("a%d = a%d + y", D, S); break;
23      case 0x0e: ret.printf("a%d = a%d & y", D, S); break;
24      case 0x0f: ret.printf("a%d = a%d - y", D, S); break;
2525
26        default: return "UNKNOWN";
27    }
28    return ret;
26      default: return "UNKNOWN";
27   }
28   return ret;
2929}
3030
3131astring disasmYField(const UINT8& Y)
3232{
33    switch (Y)
34    {
35        case 0x00: return "*r0";
36        case 0x01: return "*r0++";
37        case 0x02: return "*r0--";
38        case 0x03: return "*r0++j";
33   switch (Y)
34   {
35      case 0x00: return "*r0";
36      case 0x01: return "*r0++";
37      case 0x02: return "*r0--";
38      case 0x03: return "*r0++j";
3939
40        case 0x04: return "*r1";
41        case 0x05: return "*r1++";
42        case 0x06: return "*r1--";
43        case 0x07: return "*r1++j";
40      case 0x04: return "*r1";
41      case 0x05: return "*r1++";
42      case 0x06: return "*r1--";
43      case 0x07: return "*r1++j";
4444
45        case 0x08: return "*r2";
46        case 0x09: return "*r2++";
47        case 0x0a: return "*r2--";
48        case 0x0b: return "*r2++j";
45      case 0x08: return "*r2";
46      case 0x09: return "*r2++";
47      case 0x0a: return "*r2--";
48      case 0x0b: return "*r2++j";
4949
50        case 0x0c: return "*r3";
51        case 0x0d: return "*r3++";
52        case 0x0e: return "*r3--";
53        case 0x0f: return "*r3++j";
50      case 0x0c: return "*r3";
51      case 0x0d: return "*r3++";
52      case 0x0e: return "*r3--";
53      case 0x0f: return "*r3++j";
5454
55        default: return "UNKNOWN";
56    }
57    return "";
55      default: return "UNKNOWN";
56   }
57   return "";
5858}
5959
6060astring disasmZField(const UINT8& Z)
6161{
62    switch (Z)
63    {
64        case 0x00: return "*r0zp";
65        case 0x01: return "*r0pz";
66        case 0x02: return "*r0m2";
67        case 0x03: return "*r0jk";
62   switch (Z)
63   {
64      case 0x00: return "*r0zp";
65      case 0x01: return "*r0pz";
66      case 0x02: return "*r0m2";
67      case 0x03: return "*r0jk";
6868
69        case 0x04: return "*r1zp";
70        case 0x05: return "*r1pz";
71        case 0x06: return "*r1m2";
72        case 0x07: return "*r1jk";
69      case 0x04: return "*r1zp";
70      case 0x05: return "*r1pz";
71      case 0x06: return "*r1m2";
72      case 0x07: return "*r1jk";
7373
74        case 0x08: return "*r2zp";
75        case 0x09: return "*r2pz";
76        case 0x0a: return "*r2m2";
77        case 0x0b: return "*r2jk";
74      case 0x08: return "*r2zp";
75      case 0x09: return "*r2pz";
76      case 0x0a: return "*r2m2";
77      case 0x0b: return "*r2jk";
7878
79        case 0x0c: return "*r3zp";
80        case 0x0d: return "*r3pz";
81        case 0x0e: return "*r3m2";
82        case 0x0f: return "*r3jk";
79      case 0x0c: return "*r3zp";
80      case 0x0d: return "*r3pz";
81      case 0x0e: return "*r3m2";
82      case 0x0f: return "*r3jk";
8383
84        default: return "UNKNOWN";
85    }
86    return "";
84      default: return "UNKNOWN";
85   }
86   return "";
8787}
8888
8989astring disasmF2Field(const UINT8& F2, const UINT8& D, const UINT8& S)
9090{
91    astring ret = "";
92    switch (F2)
93    {
94        case 0x00: ret.printf("a%d = a%d >> 1", D, S); break;
95        case 0x01: ret.printf("a%d = a%d << 1", D, S); break;
96        case 0x02: ret.printf("a%d = a%d >> 4", D, S); break;
97        case 0x03: ret.printf("a%d = a%d << 4", D, S); break;
98        case 0x04: ret.printf("a%d = a%d >> 8", D, S); break;
99        case 0x05: ret.printf("a%d = a%d << 8", D, S); break;
100        case 0x06: ret.printf("a%d = a%d >> 16", D, S); break;
101        case 0x07: ret.printf("a%d = a%d << 16", D, S); break;
91   astring ret = "";
92   switch (F2)
93   {
94      case 0x00: ret.printf("a%d = a%d >> 1", D, S); break;
95      case 0x01: ret.printf("a%d = a%d << 1", D, S); break;
96      case 0x02: ret.printf("a%d = a%d >> 4", D, S); break;
97      case 0x03: ret.printf("a%d = a%d << 4", D, S); break;
98      case 0x04: ret.printf("a%d = a%d >> 8", D, S); break;
99      case 0x05: ret.printf("a%d = a%d << 8", D, S); break;
100      case 0x06: ret.printf("a%d = a%d >> 16", D, S); break;
101      case 0x07: ret.printf("a%d = a%d << 16", D, S); break;
102102
103        case 0x08: ret.printf("a%d = p", D); break;
104        case 0x09: ret.printf("a%dh = a%dh + 1", D, S); break;
105        case 0x0a: ret.printf("RESERVED"); break;
106        case 0x0b: ret.printf("a%d = rnd(a%d)", D, S); break;
107        case 0x0c: ret.printf("a%d = y", D); break;
108        case 0x0d: ret.printf("a%d = a%d + 1", D, S); break;
109        case 0x0e: ret.printf("a%d = a%d", D, S); break;
110        case 0x0f: ret.printf("a%d = -a%d", D, S); break;
103      case 0x08: ret.printf("a%d = p", D); break;
104      case 0x09: ret.printf("a%dh = a%dh + 1", D, S); break;
105      case 0x0a: ret.printf("RESERVED"); break;
106      case 0x0b: ret.printf("a%d = rnd(a%d)", D, S); break;
107      case 0x0c: ret.printf("a%d = y", D); break;
108      case 0x0d: ret.printf("a%d = a%d + 1", D, S); break;
109      case 0x0e: ret.printf("a%d = a%d", D, S); break;
110      case 0x0f: ret.printf("a%d = -a%d", D, S); break;
111111
112        default: return "UNKNOWN";
113    }
114    return "";
112      default: return "UNKNOWN";
113   }
114   return "";
115115}
116116
117117astring disasmCONField(const UINT8& CON)
118118{
119    switch (CON)
120    {
121        case 0x00: return "mi";
122        case 0x01: return "pl";
123        case 0x02: return "eq";
124        case 0x03: return "ne";
125        case 0x04: return "lvs";
126        case 0x05: return "lvc";
127        case 0x06: return "mvs";
128        case 0x07: return "mvc";
129        case 0x08: return "heads";
130        case 0x09: return "tails";
131        case 0x0a: return "c0ge";
132        case 0x0b: return "c0lt";
133        case 0x0c: return "c1ge";
134        case 0x0d: return "c1lt";
135        case 0x0e: return "true";
136        case 0x0f: return "false";
137        case 0x10: return "gt";
138        case 0x11: return "le";
119   switch (CON)
120   {
121      case 0x00: return "mi";
122      case 0x01: return "pl";
123      case 0x02: return "eq";
124      case 0x03: return "ne";
125      case 0x04: return "lvs";
126      case 0x05: return "lvc";
127      case 0x06: return "mvs";
128      case 0x07: return "mvc";
129      case 0x08: return "heads";
130      case 0x09: return "tails";
131      case 0x0a: return "c0ge";
132      case 0x0b: return "c0lt";
133      case 0x0c: return "c1ge";
134      case 0x0d: return "c1lt";
135      case 0x0e: return "true";
136      case 0x0f: return "false";
137      case 0x10: return "gt";
138      case 0x11: return "le";
139139
140        default: return "RESERVED";
141    }
142    return "";
140      default: return "RESERVED";
141   }
142   return "";
143143}
144144
145145astring disasmBField(const UINT8& B)
146146{
147    switch (B)
148    {
149        case 0x00: return "return";
150        case 0x01: return "ireturn";
151        case 0x02: return "goto pt";
152        case 0x03: return "call pt";
153        case 0x04:
154        case 0x05:
155        case 0x06:
156        case 0x07: return "RESERVED";
147   switch (B)
148   {
149      case 0x00: return "return";
150      case 0x01: return "ireturn";
151      case 0x02: return "goto pt";
152      case 0x03: return "call pt";
153      case 0x04:
154      case 0x05:
155      case 0x06:
156      case 0x07: return "RESERVED";
157157
158        default: return "UNKNOWN";
159    }
160    return "";
158      default: return "UNKNOWN";
159   }
160   return "";
161161}
162162
163163astring disasmRImmediateField(const UINT8& R)
164164{
165    switch (R)
166    {
167        case 0x00: return "j";
168        case 0x01: return "k";
169        case 0x02: return "rb";
170        case 0x03: return "re";
171        case 0x04: return "r0";
172        case 0x05: return "r1";
173        case 0x06: return "r2";
174        case 0x07: return "r3";
165   switch (R)
166   {
167      case 0x00: return "j";
168      case 0x01: return "k";
169      case 0x02: return "rb";
170      case 0x03: return "re";
171      case 0x04: return "r0";
172      case 0x05: return "r1";
173      case 0x06: return "r2";
174      case 0x07: return "r3";
175175
176        default: return "UNKNOWN";
177    }
178    return "";
176      default: return "UNKNOWN";
177   }
178   return "";
179179}
180180
181181astring disasmRField(const UINT8& R)
182182{
183    switch (R)
184    {
183   switch (R)
184   {
185185      case 0x00: return "r0";
186        case 0x01: return "r1";
187        case 0x02: return "r2";
188        case 0x03: return "r3";
189        case 0x04: return "j";
190        case 0x05: return "k";
191        case 0x06: return "rb";
192        case 0x07: return "re";
193        case 0x08: return "pt";
194        case 0x09: return "pr";
195        case 0x0a: return "pi";
196        case 0x0b: return "i";
186      case 0x01: return "r1";
187      case 0x02: return "r2";
188      case 0x03: return "r3";
189      case 0x04: return "j";
190      case 0x05: return "k";
191      case 0x06: return "rb";
192      case 0x07: return "re";
193      case 0x08: return "pt";
194      case 0x09: return "pr";
195      case 0x0a: return "pi";
196      case 0x0b: return "i";
197197
198        case 0x10: return "x";
199        case 0x11: return "y";
200        case 0x12: return "yl";
201        case 0x13: return "auc";
202        case 0x14: return "psw";
203        case 0x15: return "c0";
204        case 0x16: return "c1";
205        case 0x17: return "c2";
198      case 0x10: return "x";
199      case 0x11: return "y";
200      case 0x12: return "yl";
201      case 0x13: return "auc";
202      case 0x14: return "psw";
203      case 0x15: return "c0";
204      case 0x16: return "c1";
205      case 0x17: return "c2";
206206      case 0x18: return "sioc";
207        case 0x19: return "srta";
208        case 0x1a: return "sdx";
209        case 0x1b: return "tdms";
210        case 0x1c: return "pioc";
211        case 0x1d: return "pdx0";
212        case 0x1e: return "pdx1";
207      case 0x19: return "srta";
208      case 0x1a: return "sdx";
209      case 0x1b: return "tdms";
210      case 0x1c: return "pioc";
211      case 0x1d: return "pdx0";
212      case 0x1e: return "pdx1";
213213
214        default: return "RESERVED";
215    }
216    return "";
214      default: return "RESERVED";
215   }
216   return "";
217217}
218218
219219astring disasmIField(const UINT8& I)
220220{
221    switch (I)
222    {
223        case 0x00: return "r0/j";
224        case 0x01: return "r1/k";
225        case 0x02: return "r2/rb";
226        case 0x03: return "r3/re";
221   switch (I)
222   {
223      case 0x00: return "r0/j";
224      case 0x01: return "r1/k";
225      case 0x02: return "r2/rb";
226      case 0x03: return "r3/re";
227227
228        default: return "UNKNOWN";
229    }
230    return "";
228      default: return "UNKNOWN";
229   }
230   return "";
231231}
232232
233233bool disasmSIField(const UINT8& SI)
234234{
235    switch (SI)
236    {
237        case 0x00: return 0;    // Not a software interrupt
238        case 0x01: return 1;    // Software Interrupt
239    }
240    return false;
235   switch (SI)
236   {
237      case 0x00: return 0;   // Not a software interrupt
238      case 0x01: return 1;   // Software Interrupt
239   }
240   return false;
241241}
242242
243243
244244CPU_DISASSEMBLE( dsp16a )
245245{
246    UINT8 opSize = 1;
247    UINT32 dasmflags = 0;
248    UINT16 op  = oprom[0] | (oprom[1] << 8);
249    UINT16 op2 = oprom[2] | (oprom[3] << 8);
246   UINT8 opSize = 1;
247   UINT32 dasmflags = 0;
248   UINT16 op  = oprom[0] | (oprom[1] << 8);
249   UINT16 op2 = oprom[2] | (oprom[3] << 8);
250250
251    // TODO: Test for previous "if CON" instruction and tab the next instruction in?
251   // TODO: Test for previous "if CON" instruction and tab the next instruction in?
252252
253    const UINT8 opcode = (op >> 11) & 0x1f;
254    switch(opcode)
255    {
256        // Format 1: Multiply/ALU Read/Write Group
257        case 0x06:
258        {
259            // F1, Y
260            const UINT8 Y = (op & 0x000f);
261            const UINT8 S = (op & 0x0200) >> 9;
262            const UINT8 D = (op & 0x0400) >> 10;
263            const UINT8 F1 = (op & 0x01e0) >> 5;
264            astring yString = disasmYField(Y);
265            astring fString = disasmF1Field(F1, D, S);
266            sprintf(buffer, "%s, %s", fString.cstr(), yString.cstr());
267            break;
268        }
269        case 0x04: case 0x1c:
270        {
271            // F1 Y=a0[1] | F1 Y=a1[1]
272            const UINT8 Y = (op & 0x000f);
273            const UINT8 S = (op & 0x0200) >> 9;
274            const UINT8 D = (op & 0x0400) >> 10;
275            const UINT8 F1 = (op & 0x01e0) >> 5;
276            astring yString = disasmYField(Y);
277            astring fString = disasmF1Field(F1, D, S);
278            astring aString = (opcode == 0x1c) ? "a0" : "a1";
279            sprintf(buffer, "%s = %s, %s", yString.cstr(), aString.cstr(), fString.cstr());
280            break;
281        }
282        case 0x16:
283        {
284            // F1, x = Y
285            const UINT8 Y = (op & 0x000f);
286            const UINT8 S = (op & 0x0200) >> 9;
287            const UINT8 D = (op & 0x0400) >> 10;
288            const UINT8 F1 = (op & 0x01e0) >> 5;
289            astring yString = disasmYField(Y);
290            astring fString = disasmF1Field(F1, D, S);
291            sprintf(buffer, "%s, x = %s", fString.cstr(), yString.cstr());
292            break;
293        }
294        case 0x17:
295        {
296            // F1, y[l] = Y
297            const UINT8 Y = (op & 0x000f);
298            const UINT8 X = (op & 0x0010) >> 4;
299            const UINT8 S = (op & 0x0200) >> 9;
300            const UINT8 D = (op & 0x0400) >> 10;
301            const UINT8 F1 = (op & 0x01e0) >> 5;
302            astring yString = disasmYField(Y);
303            astring fString = disasmF1Field(F1, D, S);
304            astring xString = (X ? "y" : "y1");
305            sprintf(buffer, "%s, %s = %s", fString.cstr(), xString.cstr(), yString.cstr());
306            break;
307        }
308        case 0x1f:
309        {
310            // F1, y = Y, x = *pt++[i]
311            const UINT8 Y = (op & 0x000f);
312            const UINT8 X = (op & 0x0010) >> 4;
313            const UINT8 S = (op & 0x0200) >> 9;
314            const UINT8 D = (op & 0x0400) >> 10;
315            const UINT8 F1 = (op & 0x01e0) >> 5;
316            astring yString = disasmYField(Y);
317            astring fString = disasmF1Field(F1, D, S);
318            astring xString = (X ? "*pt++i" : "*pt++");
319            sprintf(buffer, "%s, y = %s, x = %s", fString.cstr(), yString.cstr(), xString.cstr());
320            break;
321        }
322        case 0x19: case 0x1b:
323        {
324            // F1, y = a0|1, x = *pt++[i]
325            const UINT8 Y = (op & 0x000f);
326            const UINT8 X = (op & 0x0010) >> 4;
327            const UINT8 S = (op & 0x0200) >> 9;
328            const UINT8 D = (op & 0x0400) >> 10;
329            const UINT8 F1 = (op & 0x01e0) >> 5;
330            astring fString = disasmF1Field(F1, D, S);
331            astring xString = (X ? "*pt++i" : "*pt++");
332            astring aString = (opcode == 0x19) ? "a0" : "a1";
333            sprintf(buffer, "%s, y = %s, x = %s", fString.cstr(), aString.cstr(), xString.cstr());
334            if (Y != 0x00) sprintf(buffer, "UNKNOWN");
335            break;
336        }
337        case 0x14:
338        {
339            // F1, Y = y[1]
340            const UINT8 Y = (op & 0x000f);
341            const UINT8 X = (op & 0x0010) >> 4;
342            const UINT8 S = (op & 0x0200) >> 9;
343            const UINT8 D = (op & 0x0400) >> 10;
344            const UINT8 F1 = (op & 0x01e0) >> 5;
345            astring yString = disasmYField(Y);
346            astring xString = (X ? "y" : "y1");
347            astring fString = disasmF1Field(F1, D, S);
348            sprintf(buffer, "%s, %s = %s", fString.cstr(), yString.cstr(), xString.cstr());
349            break;
350        }
253   const UINT8 opcode = (op >> 11) & 0x1f;
254   switch(opcode)
255   {
256      // Format 1: Multiply/ALU Read/Write Group
257      case 0x06:
258      {
259         // F1, Y
260         const UINT8 Y = (op & 0x000f);
261         const UINT8 S = (op & 0x0200) >> 9;
262         const UINT8 D = (op & 0x0400) >> 10;
263         const UINT8 F1 = (op & 0x01e0) >> 5;
264         astring yString = disasmYField(Y);
265         astring fString = disasmF1Field(F1, D, S);
266         sprintf(buffer, "%s, %s", fString.cstr(), yString.cstr());
267         break;
268      }
269      case 0x04: case 0x1c:
270      {
271         // F1 Y=a0[1] | F1 Y=a1[1]
272         const UINT8 Y = (op & 0x000f);
273         const UINT8 S = (op & 0x0200) >> 9;
274         const UINT8 D = (op & 0x0400) >> 10;
275         const UINT8 F1 = (op & 0x01e0) >> 5;
276         astring yString = disasmYField(Y);
277         astring fString = disasmF1Field(F1, D, S);
278         astring aString = (opcode == 0x1c) ? "a0" : "a1";
279         sprintf(buffer, "%s = %s, %s", yString.cstr(), aString.cstr(), fString.cstr());
280         break;
281      }
282      case 0x16:
283      {
284         // F1, x = Y
285         const UINT8 Y = (op & 0x000f);
286         const UINT8 S = (op & 0x0200) >> 9;
287         const UINT8 D = (op & 0x0400) >> 10;
288         const UINT8 F1 = (op & 0x01e0) >> 5;
289         astring yString = disasmYField(Y);
290         astring fString = disasmF1Field(F1, D, S);
291         sprintf(buffer, "%s, x = %s", fString.cstr(), yString.cstr());
292         break;
293      }
294      case 0x17:
295      {
296         // F1, y[l] = Y
297         const UINT8 Y = (op & 0x000f);
298         const UINT8 X = (op & 0x0010) >> 4;
299         const UINT8 S = (op & 0x0200) >> 9;
300         const UINT8 D = (op & 0x0400) >> 10;
301         const UINT8 F1 = (op & 0x01e0) >> 5;
302         astring yString = disasmYField(Y);
303         astring fString = disasmF1Field(F1, D, S);
304         astring xString = (X ? "y" : "y1");
305         sprintf(buffer, "%s, %s = %s", fString.cstr(), xString.cstr(), yString.cstr());
306         break;
307      }
308      case 0x1f:
309      {
310         // F1, y = Y, x = *pt++[i]
311         const UINT8 Y = (op & 0x000f);
312         const UINT8 X = (op & 0x0010) >> 4;
313         const UINT8 S = (op & 0x0200) >> 9;
314         const UINT8 D = (op & 0x0400) >> 10;
315         const UINT8 F1 = (op & 0x01e0) >> 5;
316         astring yString = disasmYField(Y);
317         astring fString = disasmF1Field(F1, D, S);
318         astring xString = (X ? "*pt++i" : "*pt++");
319         sprintf(buffer, "%s, y = %s, x = %s", fString.cstr(), yString.cstr(), xString.cstr());
320         break;
321      }
322      case 0x19: case 0x1b:
323      {
324         // F1, y = a0|1, x = *pt++[i]
325         const UINT8 Y = (op & 0x000f);
326         const UINT8 X = (op & 0x0010) >> 4;
327         const UINT8 S = (op & 0x0200) >> 9;
328         const UINT8 D = (op & 0x0400) >> 10;
329         const UINT8 F1 = (op & 0x01e0) >> 5;
330         astring fString = disasmF1Field(F1, D, S);
331         astring xString = (X ? "*pt++i" : "*pt++");
332         astring aString = (opcode == 0x19) ? "a0" : "a1";
333         sprintf(buffer, "%s, y = %s, x = %s", fString.cstr(), aString.cstr(), xString.cstr());
334         if (Y != 0x00) sprintf(buffer, "UNKNOWN");
335         break;
336      }
337      case 0x14:
338      {
339         // F1, Y = y[1]
340         const UINT8 Y = (op & 0x000f);
341         const UINT8 X = (op & 0x0010) >> 4;
342         const UINT8 S = (op & 0x0200) >> 9;
343         const UINT8 D = (op & 0x0400) >> 10;
344         const UINT8 F1 = (op & 0x01e0) >> 5;
345         astring yString = disasmYField(Y);
346         astring xString = (X ? "y" : "y1");
347         astring fString = disasmF1Field(F1, D, S);
348         sprintf(buffer, "%s, %s = %s", fString.cstr(), yString.cstr(), xString.cstr());
349         break;
350      }
351351
352        // Format 1a: Multiply/ALU Read/Write Group (major typo in docs on p3-51)
353        case 0x07:
354        {
355            // F1, At[1] = Y
356            const UINT8 Y = (op & 0x000f);
357            const UINT8 S = (op & 0x0200) >> 9;
358            const UINT8 aT = (op & 0x0400) >> 10;
359            const UINT8 F1 = (op & 0x01e0) >> 5;
360            astring yString = disasmYField(Y);
361            astring atString = (aT ? "a0" : "a1");
362            astring fString = disasmF1Field(F1, aT, S);
363            sprintf(buffer, "%s, %s = %s", fString.cstr(), atString.cstr(), yString.cstr());
364            break;
365        }
352      // Format 1a: Multiply/ALU Read/Write Group (major typo in docs on p3-51)
353      case 0x07:
354      {
355         // F1, At[1] = Y
356         const UINT8 Y = (op & 0x000f);
357         const UINT8 S = (op & 0x0200) >> 9;
358         const UINT8 aT = (op & 0x0400) >> 10;
359         const UINT8 F1 = (op & 0x01e0) >> 5;
360         astring yString = disasmYField(Y);
361         astring atString = (aT ? "a0" : "a1");
362         astring fString = disasmF1Field(F1, aT, S);
363         sprintf(buffer, "%s, %s = %s", fString.cstr(), atString.cstr(), yString.cstr());
364         break;
365      }
366366
367        // Format 2: Multiply/ALU Read/Write Group
368        case 0x15:
369        {
370            // F1, Z : y[1]
371            const UINT8 Z = (op & 0x000f);
372            const UINT8 X = (op & 0x0010) >> 4;
373            const UINT8 S = (op & 0x0200) >> 9;
374            const UINT8 D = (op & 0x0400) >> 10;
375            const UINT8 F1 = (op & 0x01e0) >> 5;
376            astring zString = disasmZField(Z);
377            astring xString = (X ? "y" : "y1");
378            astring fString = disasmF1Field(F1, D, S);
379            sprintf(buffer, "%s, %s <=> %s", fString.cstr(), xString.cstr(), zString.cstr());
380            break;
381        }
382        case 0x1d:
383        {
384            // F1, Z : y, x=*pt++[i]
385            const UINT8 Z = (op & 0x000f);
386            const UINT8 X = (op & 0x0010) >> 4;
387            const UINT8 S = (op & 0x0200) >> 9;
388            const UINT8 D = (op & 0x0400) >> 10;
389            const UINT8 F1 = (op & 0x01e0) >> 5;
390            astring zString = disasmZField(Z);
391            astring xString = (X ? "*pt++i" : "*pt++");
392            astring fString = disasmF1Field(F1, D, S);
393            sprintf(buffer, "%s, %s <=> y, x = %s", fString.cstr(), zString.cstr(), xString.cstr());
394            break;
395        }
367      // Format 2: Multiply/ALU Read/Write Group
368      case 0x15:
369      {
370         // F1, Z : y[1]
371         const UINT8 Z = (op & 0x000f);
372         const UINT8 X = (op & 0x0010) >> 4;
373         const UINT8 S = (op & 0x0200) >> 9;
374         const UINT8 D = (op & 0x0400) >> 10;
375         const UINT8 F1 = (op & 0x01e0) >> 5;
376         astring zString = disasmZField(Z);
377         astring xString = (X ? "y" : "y1");
378         astring fString = disasmF1Field(F1, D, S);
379         sprintf(buffer, "%s, %s <=> %s", fString.cstr(), xString.cstr(), zString.cstr());
380         break;
381      }
382      case 0x1d:
383      {
384         // F1, Z : y, x=*pt++[i]
385         const UINT8 Z = (op & 0x000f);
386         const UINT8 X = (op & 0x0010) >> 4;
387         const UINT8 S = (op & 0x0200) >> 9;
388         const UINT8 D = (op & 0x0400) >> 10;
389         const UINT8 F1 = (op & 0x01e0) >> 5;
390         astring zString = disasmZField(Z);
391         astring xString = (X ? "*pt++i" : "*pt++");
392         astring fString = disasmF1Field(F1, D, S);
393         sprintf(buffer, "%s, %s <=> y, x = %s", fString.cstr(), zString.cstr(), xString.cstr());
394         break;
395      }
396396
397        // Format 2a: Multiply/ALU Read/Write Group
398        case 0x05:
399        {
400            // F1, Z : aT[1]
401            const UINT8 Z = (op & 0x000f);
402            const UINT8 X = (op & 0x0010) >> 4;
403            const UINT8 S = (op & 0x0200) >> 9;
404            const UINT8 aT = (op & 0x0400) >> 10;
405            const UINT8 F1 = (op & 0x01e0) >> 5;
406            astring zString = disasmZField(Z);
407            astring atString = (aT ? "a0" : "a1");
408            atString += X ? "" : "1";   // TODO: Figure out unclear wording.
409            astring fString = disasmF1Field(F1, aT, S);
410            sprintf(buffer, "%s, %s <=> %s", fString.cstr(), zString.cstr(), atString.cstr());
411            break;
412        }
397      // Format 2a: Multiply/ALU Read/Write Group
398      case 0x05:
399      {
400         // F1, Z : aT[1]
401         const UINT8 Z = (op & 0x000f);
402         const UINT8 X = (op & 0x0010) >> 4;
403         const UINT8 S = (op & 0x0200) >> 9;
404         const UINT8 aT = (op & 0x0400) >> 10;
405         const UINT8 F1 = (op & 0x01e0) >> 5;
406         astring zString = disasmZField(Z);
407         astring atString = (aT ? "a0" : "a1");
408         atString += X ? "" : "1";   // TODO: Figure out unclear wording.
409         astring fString = disasmF1Field(F1, aT, S);
410         sprintf(buffer, "%s, %s <=> %s", fString.cstr(), zString.cstr(), atString.cstr());
411         break;
412      }
413413
414        // Format 3: Special Functions
415        case 0x12:
416        case 0x13:
417        {
418            // if|ifc CON F2
419            const UINT8 CON = (op & 0x001f);
420            const UINT8 S = (op & 0x0200) >> 9;
421            const UINT8 D = (op & 0x0400) >> 10;
422            const UINT8 F2 = (op & 0x01e0) >> 5;
423            astring fString = disasmF2Field(F2, D, S);
424            astring conString = disasmCONField(CON);
425            if (op & 0x0800) sprintf(buffer,  "if %s : %s", conString.cstr(), fString.cstr());
426            else             sprintf(buffer, "ifc %s : %s", conString.cstr(), fString.cstr());
427            break;
428        }
414      // Format 3: Special Functions
415      case 0x12:
416      case 0x13:
417      {
418         // if|ifc CON F2
419         const UINT8 CON = (op & 0x001f);
420         const UINT8 S = (op & 0x0200) >> 9;
421         const UINT8 D = (op & 0x0400) >> 10;
422         const UINT8 F2 = (op & 0x01e0) >> 5;
423         astring fString = disasmF2Field(F2, D, S);
424         astring conString = disasmCONField(CON);
425         if (op & 0x0800) sprintf(buffer,  "if %s : %s", conString.cstr(), fString.cstr());
426         else             sprintf(buffer, "ifc %s : %s", conString.cstr(), fString.cstr());
427         break;
428      }
429429
430        // Format 4: Branch Direct Group
431        case 0x00: case 0x01:
432        {
430      // Format 4: Branch Direct Group
431      case 0x00: case 0x01:
432      {
433433         // goto JA
434            const UINT16 JA = (op & 0x0fff) | (pc & 0xf000);
434         const UINT16 JA = (op & 0x0fff) | (pc & 0xf000);
435435         sprintf(buffer, "goto 0x%04x", JA);
436            break;
437        }
436         break;
437      }
438438      case 0x10: case 0x11:
439439      {
440440         // call JA
r20126r20127
443443         break;
444444      }
445445
446        // Format 5: Branch Indirect Group
447        case 0x18:
448        {
449            // goto B
450            const UINT8 B = (op & 0x0700) >> 8;
451            astring bString = disasmBField(B);
452            sprintf(buffer, "%s", bString.cstr());
453            break;
454        }
446      // Format 5: Branch Indirect Group
447      case 0x18:
448      {
449         // goto B
450         const UINT8 B = (op & 0x0700) >> 8;
451         astring bString = disasmBField(B);
452         sprintf(buffer, "%s", bString.cstr());
453         break;
454      }
455455
456        // Format 6: Contitional Branch Qualifier/Software Interrupt (icall)
457        case 0x1a:
458        {
459            // if CON [goto/call/return]
460            const UINT8 CON = (op & 0x001f);
461            astring conString = disasmCONField(CON);
462            sprintf(buffer, "if %s:", conString.cstr());
463            // TODO: Test for invalid ops
464            // icall
465            if (op == 0xd40e) sprintf(buffer, "icall");
466            break;
467        }
456      // Format 6: Contitional Branch Qualifier/Software Interrupt (icall)
457      case 0x1a:
458      {
459         // if CON [goto/call/return]
460         const UINT8 CON = (op & 0x001f);
461         astring conString = disasmCONField(CON);
462         sprintf(buffer, "if %s:", conString.cstr());
463         // TODO: Test for invalid ops
464         // icall
465         if (op == 0xd40e) sprintf(buffer, "icall");
466         break;
467      }
468468
469        // Format 7: Data Move Group
470        case 0x09: case 0x0b:
471        {
472            // R = aS
473            const UINT8 R = (op & 0x03f0) >> 4;
474            const UINT8 S = (op & 0x1000) >> 12;
475            astring rString = disasmRField(R);
476            sprintf(buffer, "%s = %s", rString.cstr(), (S ? "a1" : "a0"));
477            break;
478        }
479        case 0x08:
480        {
481            // aT = R
482            const UINT8 R  = (op & 0x03f0) >> 4;
483            const UINT8 aT = (op & 0x0400) >> 10;
484            astring rString = disasmRField(R);
485            sprintf(buffer, "%s = %s", (aT ? "a0" : "a1"), rString.cstr());
486            break;
487        }
488        case 0x0f:
489        {
490            // R = Y
491            const UINT8 Y = (op & 0x000f);
492            const UINT8 R = (op & 0x03f0) >> 4;
493            astring yString = disasmYField(Y);
494            astring rString = disasmRField(R);
495            sprintf(buffer, "%s = %s", rString.cstr(), yString.cstr());
496            // TODO: Special case the R == [y, y1, or x] case
497            break;
498        }
499        case 0x0c:
500        {
501            // Y = R
502            const UINT8 Y = (op & 0x000f);
503            const UINT8 R = (op & 0x03f0) >> 4;
504            astring yString = disasmYField(Y);
505            astring rString = disasmRField(R);
506            sprintf(buffer, "%s = %s", yString.cstr(), rString.cstr());
507            break;
508        }
509        case 0x0d:
510        {
511            // Z : R
512            const UINT8 Z = (op & 0x000f);
513            const UINT8 R = (op & 0x03f0) >> 4;
514            astring zString = disasmZField(Z);
515            astring rString = disasmRField(R);
516            sprintf(buffer, "%s <=> %s", zString.cstr(), rString.cstr());
517            break;
518        }
469      // Format 7: Data Move Group
470      case 0x09: case 0x0b:
471      {
472         // R = aS
473         const UINT8 R = (op & 0x03f0) >> 4;
474         const UINT8 S = (op & 0x1000) >> 12;
475         astring rString = disasmRField(R);
476         sprintf(buffer, "%s = %s", rString.cstr(), (S ? "a1" : "a0"));
477         break;
478      }
479      case 0x08:
480      {
481         // aT = R
482         const UINT8 R  = (op & 0x03f0) >> 4;
483         const UINT8 aT = (op & 0x0400) >> 10;
484         astring rString = disasmRField(R);
485         sprintf(buffer, "%s = %s", (aT ? "a0" : "a1"), rString.cstr());
486         break;
487      }
488      case 0x0f:
489      {
490         // R = Y
491         const UINT8 Y = (op & 0x000f);
492         const UINT8 R = (op & 0x03f0) >> 4;
493         astring yString = disasmYField(Y);
494         astring rString = disasmRField(R);
495         sprintf(buffer, "%s = %s", rString.cstr(), yString.cstr());
496         // TODO: Special case the R == [y, y1, or x] case
497         break;
498      }
499      case 0x0c:
500      {
501         // Y = R
502         const UINT8 Y = (op & 0x000f);
503         const UINT8 R = (op & 0x03f0) >> 4;
504         astring yString = disasmYField(Y);
505         astring rString = disasmRField(R);
506         sprintf(buffer, "%s = %s", yString.cstr(), rString.cstr());
507         break;
508      }
509      case 0x0d:
510      {
511         // Z : R
512         const UINT8 Z = (op & 0x000f);
513         const UINT8 R = (op & 0x03f0) >> 4;
514         astring zString = disasmZField(Z);
515         astring rString = disasmRField(R);
516         sprintf(buffer, "%s <=> %s", zString.cstr(), rString.cstr());
517         break;
518      }
519519
520        // Format 8: Data Move (immediate operand - 2 words)
521        case 0x0a:
522        {
523            // R = N
524            const UINT8 R = (op & 0x03f0) >> 4;
525            astring rString = disasmRField(R);
520      // Format 8: Data Move (immediate operand - 2 words)
521      case 0x0a:
522      {
523         // R = N
524         const UINT8 R = (op & 0x03f0) >> 4;
525         astring rString = disasmRField(R);
526526         sprintf(buffer, "%s = 0x%04x", rString.cstr(), op2);
527            opSize = 2;
528            break;
529        }
527         opSize = 2;
528         break;
529      }
530530
531        // Format 9: Short Immediate Group
532        case 0x02: case 0x03:
533        {
534            // R = M
535            const UINT8 M = (op & 0x00ff);
536            const UINT8 R = (op & 0x0e00) >> 9;
537            astring rString = disasmRImmediateField(R);
538            sprintf(buffer, "%s = 0x%02x", rString.cstr(), M);
539            break;
540        }
531      // Format 9: Short Immediate Group
532      case 0x02: case 0x03:
533      {
534         // R = M
535         const UINT8 M = (op & 0x00ff);
536         const UINT8 R = (op & 0x0e00) >> 9;
537         astring rString = disasmRImmediateField(R);
538         sprintf(buffer, "%s = 0x%02x", rString.cstr(), M);
539         break;
540      }
541541
542        // Format 10: do - redo
543        case 0x0e:
544        {
545            // do|redo K
546            const UINT8 K = (op & 0x007f);
547            const UINT8 NI = (op & 0x0780) >> 7;
548            sprintf(buffer, "do (next %d inst) %d times", NI, K);
549            // TODO: Limits on K & NI
550            if (NI == 0x00)
542      // Format 10: do - redo
543      case 0x0e:
544      {
545         // do|redo K
546         const UINT8 K = (op & 0x007f);
547         const UINT8 NI = (op & 0x0780) >> 7;
548         sprintf(buffer, "do (next %d inst) %d times", NI, K);
549         // TODO: Limits on K & NI
550         if (NI == 0x00)
551551            sprintf(buffer, "redo %d", K);
552            break;
553        }
552         break;
553      }
554554
555        // RESERVED
556        case 0x1e:
557        {
558            sprintf(buffer, "RESERVED");
559            break;
560        }
555      // RESERVED
556      case 0x1e:
557      {
558         sprintf(buffer, "RESERVED");
559         break;
560      }
561561
562        // UNKNOWN
563        default:
564        {
565            sprintf(buffer, "UNKNOWN");
566            break;
567        }
568    }
562      // UNKNOWN
563      default:
564      {
565         sprintf(buffer, "UNKNOWN");
566         break;
567      }
568   }
569569
570    return opSize | dasmflags | DASMFLAG_SUPPORTED;
570   return opSize | dasmflags | DASMFLAG_SUPPORTED;
571571}
trunk/src/emu/cpu/dsp16/dsp16.c
r20126r20127
3131dsp16_device::dsp16_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
3232   : cpu_device(mconfig, DSP16, "DSP16", tag, owner, clock),
3333     m_program_config("program", ENDIANNESS_LITTLE, 16, 16, -1),
34     m_data_config("data", ENDIANNESS_LITTLE, 16, 16, -1),
3435     m_i(0),
3536     m_pc(0),
3637     m_pt(0),
r20126r20127
6263     m_cacheRedoNextPC(CACHE_INVALID),
6364     m_cacheIterations(0),
6465     m_program(NULL),
66     m_data(NULL),
6567     m_direct(NULL),
6668     m_icount(0)
6769{
68    // Allocate & setup
70   // Allocate & setup
6971}
7072
7173
r20126r20127
140142
141143   // get our address spaces
142144   m_program = &space(AS_PROGRAM);
145   m_data = &space(AS_DATA);
143146   m_direct = &m_program->direct();
144147
145148   // set our instruction counter
r20126r20127
178181
179182const address_space_config *dsp16_device::memory_space_config(address_spacenum spacenum) const
180183{
181   return (spacenum == AS_PROGRAM) ? &m_program_config : NULL;
184   return (spacenum == AS_PROGRAM) ? &m_program_config :
185         (spacenum == AS_DATA) ? &m_data_config :
186         NULL;
182187}
183188
184189
r20126r20127
242247    MEMORY ACCESSORS
243248***************************************************************************/
244249
245inline UINT32 dsp16_device::program_read(UINT32 addr)
250inline UINT32 dsp16_device::data_read(const UINT16& addr)
246251{
247   return m_program->read_dword(addr << 1);
252   return m_data->read_word(addr << 1);
248253}
249254
250inline void dsp16_device::program_write(UINT32 addr, UINT32 data)
255inline void dsp16_device::data_write(const UINT16& addr, const UINT16& data)
251256{
252   m_program->write_dword(addr << 1, data & 0xffff);
257   m_data->write_word(addr << 1, data & 0xffff);
253258}
254259
255260inline UINT32 dsp16_device::opcode_read(const UINT8 pcOffset)
r20126r20127
312317
313318      // instruction fetch & execute
314319      UINT8 cycles;
315      INT16 pcAdvance;
320      UINT8 pcAdvance;
316321      const UINT16 op = opcode_read();
317      printf("%d ", m_cacheIterations);
318322      execute_one(op, cycles, pcAdvance);
319      printf("%d\n", m_cacheIterations);
320323
321324      // step
322325      m_pc += pcAdvance;
trunk/src/emu/cpu/dsp16/dsp16ops.c
r20126r20127
103103}
104104
105105
106void dsp16_device::execute_one(const UINT16& op, UINT8& cycles, INT16& pcAdvance)
106void dsp16_device::executeF1Field(const UINT8& F1, const UINT8& D, const UINT8& S)
107107{
108   // Where is the first operation being written?
109   //UINT64* destinationReg = NULL;
110   //switch (D)
111   //{
112   //   case 0x00: destinationReg = &m_a0;
113   //   case 0x01: destinationReg = &m_a1;
114   //   default: break;
115   //}
116
117   // Which source is being used?
118   //UINT64* sourceReg = NULL;
119   //switch (S)
120   //{
121   //   case 0x00: sourceReg = &m_a0;
122   //   case 0x01: sourceReg = &m_a1;
123   //   default: break;
124   //}
125   
126   switch (F1)
127   {
128      case 0x00: printf("UNIMPLEMENTED F1 operation @ PC 0x%04x\n", m_pc); break;
129      case 0x01: printf("UNIMPLEMENTED F1 operation @ PC 0x%04x\n", m_pc); break;
130      case 0x02: m_p = (INT32)((INT16)m_x * (INT16)m_y); break;
131      case 0x03: printf("UNIMPLEMENTED F1 operation @ PC 0x%04x\n", m_pc); break;
132      case 0x04: printf("UNIMPLEMENTED F1 operation @ PC 0x%04x\n", m_pc); break;
133      case 0x05: printf("UNIMPLEMENTED F1 operation @ PC 0x%04x\n", m_pc); break;
134      case 0x06: /* nop */ break;
135      case 0x07: printf("UNIMPLEMENTED F1 operation @ PC 0x%04x\n", m_pc); break;
136      case 0x08: printf("UNIMPLEMENTED F1 operation @ PC 0x%04x\n", m_pc); break;
137      case 0x09: printf("UNIMPLEMENTED F1 operation @ PC 0x%04x\n", m_pc); break;
138      case 0x0a: printf("UNIMPLEMENTED F1 operation @ PC 0x%04x\n", m_pc); break;
139      case 0x0b: printf("UNIMPLEMENTED F1 operation @ PC 0x%04x\n", m_pc); break;
140      case 0x0c: printf("UNIMPLEMENTED F1 operation @ PC 0x%04x\n", m_pc); break;
141      case 0x0d: printf("UNIMPLEMENTED F1 operation @ PC 0x%04x\n", m_pc); break;
142      case 0x0e: printf("UNIMPLEMENTED F1 operation @ PC 0x%04x\n", m_pc); break;
143      case 0x0f: printf("UNIMPLEMENTED F1 operation @ PC 0x%04x\n", m_pc); break;
144   }
145}
146
147
148void* dsp16_device::registerFromYFieldUpper(const UINT8& Y)
149{
150   UINT16* destinationReg = NULL;
151   const UINT8 N = (Y & 0x0c) >> 2;
152   switch (N)
153   {
154      case 0x00: destinationReg = &m_r0; break;
155      case 0x01: destinationReg = &m_r1; break;
156      case 0x02: destinationReg = &m_r2; break;
157      case 0x03: destinationReg = &m_r3; break;
158      default: break;
159   }
160   return destinationReg;
161}
162
163
164void dsp16_device::executeYFieldPost(const UINT8& Y)
165{
166   UINT16* opReg = NULL;
167   const UINT8 N = (Y & 0x0c) >> 2;
168   switch (N)
169   {
170      case 0x00: opReg = &m_r0; break;
171      case 0x01: opReg = &m_r1; break;
172      case 0x02: opReg = &m_r2; break;
173      case 0x03: opReg = &m_r3; break;
174      default: break;
175   }
176   
177   const UINT8 lower = Y & 0x03;
178   switch (lower)
179   {
180      case 0x00: /* nop */ break;
181      case 0x01: (*opReg)++; break;
182      case 0x02: (*opReg)--; break;
183      case 0x03: (*opReg) += m_j; break;
184   }
185}
186
187
188void dsp16_device::execute_one(const UINT16& op, UINT8& cycles, UINT8& pcAdvance)
189{
108190   cycles = 1;
109   pcAdvance = 1;
191   pcAdvance = 0;
110192
111193   const UINT8 opcode = (op >> 11) & 0x1f;
112194   switch(opcode)
r20126r20127
114196      // Format 1: Multiply/ALU Read/Write Group
115197      case 0x06:
116198      {
117         // F1, Y
118         //const UINT8 Y = (op & 0x000f);
119         //const UINT8 S = (op & 0x0200) >> 9;
120         //const UINT8 D = (op & 0x0400) >> 10;
121         //const UINT8 F1 = (op & 0x01e0) >> 5;
199         // F1, Y  :  (page 3-38)
200         const UINT8 Y = (op & 0x000f);
201         const UINT8 S = (op & 0x0200) >> 9;
202         const UINT8 D = (op & 0x0400) >> 10;
203         const UINT8 F1 = (op & 0x01e0) >> 5;
204         executeF1Field(F1, D, S);
205         executeYFieldPost(Y);
206         cycles = 1;
207         pcAdvance = 1;
122208         break;
123209      }
124210      case 0x04: case 0x1c:
r20126r20127
171257      }
172258      case 0x14:
173259      {
174         // F1, Y = y[1]
175         //const UINT8 Y = (op & 0x000f);
176         //const UINT8 X = (op & 0x0010) >> 4;
177         //const UINT8 S = (op & 0x0200) >> 9;
178         //const UINT8 D = (op & 0x0400) >> 10;
179         //const UINT8 F1 = (op & 0x01e0) >> 5;
260         // F1, Y = y[1]  :  (page 3-53)
261         const UINT8 Y = (op & 0x000f);
262         const UINT8 X = (op & 0x0010) >> 4;
263         const UINT8 S = (op & 0x0200) >> 9;
264         const UINT8 D = (op & 0x0400) >> 10;
265         const UINT8 F1 = (op & 0x01e0) >> 5;
266         executeF1Field(F1, D, S);
267         UINT16* destinationReg = (UINT16*)registerFromYFieldUpper(Y);
268         UINT16 yRegValue = 0x0000;
269         switch (X)
270         {
271            case 0x00: yRegValue = (m_y & 0x0000ffff); break;
272            case 0x01: yRegValue = (m_y & 0xffff0000) >> 16; break;
273            default: break;
274         }
275         data_write(*destinationReg, yRegValue);
276         executeYFieldPost(Y);
277         cycles = 2;
278         pcAdvance = 1;
180279         break;
181280      }
182281
r20126r20127
240339      // Format 4: Branch Direct Group
241340      case 0x00: case 0x01:
242341      {
243         // goto JA
342         // goto JA  :  (page 3-20)
244343         const UINT16 JA = (op & 0x0fff) | (m_pc & 0xf000);
245344         m_pc = JA;
246345         cycles = 2;
r20126r20127
250349
251350      case 0x10: case 0x11:
252351      {
253         // call JA
254         //const UINT16 JA = (op & 0x0fff) | (m_pc & 0xf000);
352         // call JA  :  (page 3-23)
353         const UINT16 JA = (op & 0x0fff) | (m_pc & 0xf000);
354         m_pr = m_pc + 1;
355         m_pc = JA;
356         cycles = 2;
357         pcAdvance = 0;
255358         break;
256359      }
257360
r20126r20127
295398      }
296399      case 0x0c:
297400      {
298         // Y = R
299         //const UINT8 Y = (op & 0x000f);
300         //const UINT8 R = (op & 0x03f0) >> 4;
401         // Y = R  :  (page 3-33)
402         const UINT8 Y = (op & 0x000f);
403         const UINT8 R = (op & 0x03f0) >> 4;
404         UINT16* destinationReg = (UINT16*)registerFromYFieldUpper(Y);
405         UINT16* sourceReg = (UINT16*)registerFromRTable(R);
406         data_write(*destinationReg, *sourceReg);
407         executeYFieldPost(Y);
408         cycles = 2;
409         pcAdvance = 1;
301410         break;
302411      }
303412      case 0x0d:
r20126r20127
311420      // Format 8: Data Move (immediate operand - 2 words)
312421      case 0x0a:
313422      {
314         // R = N
423         // R = N  :  (page 3-28)
315424         const UINT8 R = (op & 0x03f0) >> 4;
316425         const UINT16 iVal = opcode_read(1);
317426         void* reg = registerFromRTable(R);
r20126r20127
324433      // Format 9: Short Immediate Group
325434      case 0x02: case 0x03:
326435      {
327         // R = M
436         // R = M  :  (page 3-27)
328437         const INT8 M = (op & 0x00ff);
329438         const UINT8 R = (op & 0x0e00) >> 9;
330439         void* reg = registerFromRImmediateField(R);
331440         writeRegister(reg, (INT16)M);   // Sign extend 8 bit int
332441         cycles = 1;
442         pcAdvance = 1;
333443         break;
334444      }
335445
336446      // Format 10: do - redo
337447      case 0x0e:
338448      {
339         // do|redo K
449         // do|redo K  :  (pages 3-25 & 3-26)
340450         const UINT8 K = (op & 0x007f);
341451         const UINT8 NI = (op & 0x0780) >> 7;
342452         if (NI != 0)
r20126r20127
344454            // Do
345455            m_cacheStart = m_pc + 1;
346456            m_cacheEnd = m_pc + NI + 1;
347            m_cacheIterations = K+1;
457            m_cacheIterations = K-1;   // -1 because we check the counter below
348458            cycles = 1;
459            pcAdvance = 1;
349460         }
350461         else
351462         {
352463            // Redo
353            m_cacheIterations = K+1;
464            m_cacheIterations = K-1;   // -1 because we check the counter below
354465            m_cacheRedoNextPC = m_pc + 1;
355            pcAdvance = m_cacheStart - m_pc;
466            m_pc = m_cacheStart;
467            pcAdvance = 0;
356468            cycles = 2;
469            pcAdvance = 1;
357470         }
358471         break;
359472      }
r20126r20127
375488   if (m_cacheIterations == 0 && m_cacheRedoNextPC != CACHE_INVALID)
376489   {
377490      // You've reached the end of a cache loop after a redo opcode.
378      pcAdvance = m_cacheRedoNextPC - m_pc;
491      m_pc = m_cacheRedoNextPC;
379492      m_cacheRedoNextPC = CACHE_INVALID;
493      pcAdvance = 0;
380494   }
381495   if (m_cacheIterations > 0 && (m_pc+pcAdvance == m_cacheEnd))
382496   {
383497      // A regular iteration on a cached loop.
384498      m_cacheIterations--;
385      pcAdvance = m_cacheStart - m_pc;
499      m_pc = m_cacheStart;
500      pcAdvance = 0;
386501   }
387502}
trunk/src/emu/cpu/dsp16/dsp16.h
r20126r20127
5151
5252   // address spaces
5353   const address_space_config m_program_config;
54   const address_space_config m_data_config;
5455
5556   // CPU registers
5657   // ROM Address Arithmetic Unit (XAAU)
r20126r20127
8384   UINT16 m_sioc;
8485   UINT16 m_pioc;
8586
86    // internal stuff
87   // internal stuff
8788   UINT16 m_ppc;
8889
8990   // This core handles the cache as more of a loop than 15 seperate memory elements.
r20126r20127
9596   static const UINT16 CACHE_INVALID = 0xffff;
9697
9798   // memory access
98   inline UINT32 program_read(UINT32 addr);
99   inline void program_write(UINT32 addr, UINT32 data);
99   inline UINT32 data_read(const UINT16& addr);
100   inline void data_write(const UINT16& addr, const UINT16& data);
100101   inline UINT32 opcode_read(const UINT8 pcOffset=0);
101102
102103   // address spaces
103    address_space* m_program;
104    direct_read_data* m_direct;
104   address_space* m_program;
105   address_space* m_data;
106   direct_read_data* m_direct;
105107
106108   // other internal states
107    int m_icount;
109   int m_icount;
108110
109111   // operations
110   void execute_one(const UINT16& op, UINT8& cycles, INT16& pcAdvance);
112   void execute_one(const UINT16& op, UINT8& cycles, UINT8& pcAdvance);
111113
112114   // table decoders
113115   void* registerFromRImmediateField(const UINT8& R);
114116   void* registerFromRTable(const UINT8& R);
117   void* registerFromYFieldUpper(const UINT8& Y);
115118
119   // execution
120   void executeF1Field(const UINT8& F1, const UINT8& D, const UINT8& S);
121   void executeYFieldPost(const UINT8& Y);
122
116123   // helpers
117124   void* addressYL();
118125   void writeRegister(void* reg, const UINT16& value);

Previous 199869 Revisions Next

© 1997-2024 The MAME Team