← Back to branch summary

~ubuntu-branches/ubuntu/raring/mame/raring-proposed

« back to all changes in this revision

Viewing changes to mess/src/emu/cpu/sh4/sh4dasm.c

  • Committer: Package Import Robot
  • Author(s): Jordi Mallach, Jordi Mallach, Emmanuel Kasper
  • Date: 2011-12-19 22:56:27 UTC
  • mfrom: (0.1.2)
  • Revision ID: package-import@ubuntu.com-20111219225627-ub5oga1oys4ogqzm
Tags: 0.144-1
http://bugs.debian.org/651538
[ Jordi Mallach ]
* Fix syntax errors in DEP5 copyright file (lintian).
* Use a versioned copyright Format specification field.
* Update Vcs-* URLs.
* Move transitional packages to the new metapackages section, and make
  them priority extra.
* Remove references to GNU/Linux and MESS sources from copyright.
* Add build variables for s390x.
* Use .xz tarballs as it cuts 4MB for the upstream sources.
* Add nplayers.ini as a patch. Update copyright file to add CC-BY-SA-3.0.

[ Emmanuel Kasper ]
* New upstream release. Closes: #651538.
* Add Free Desktop compliant png icons of various sizes taken from
  the hydroxygen iconset
* Mess is now built from a new source package, to avoid possible source
  incompatibilities between mame and the mess overlay.
* Mame-tools are not built from the mame source package anymore, but
  from the mess source package

Show diffs side-by-side

added added

removed removed

Lines of Context:
mess/src/emu/cpu/sh4/sh4dasm.c
1
 
#include "emu.h"
2
 
#include "debugger.h"
3
 
#include "sh4.h"
4
 
 
5
 
#define SIGNX8(x)       (((INT32)(x) << 24) >> 24)
6
 
#define SIGNX12(x)      (((INT32)(x) << 20) >> 20)
7
 
 
8
 
#define Rn ((opcode >> 8) & 15)
9
 
#define Rm ((opcode >> 4) & 15)
10
 
 
11
 
static const char *const regname[16] = {
12
 
        "R0", "R1", "R2", "R3", "R4", "R5", "R6", "R7",
13
 
        "R8", "R9", "R10","R11","R12","R13","R14","R15"
14
 
};
15
 
 
16
 
static UINT32 op0000(char *buffer, UINT32 pc, UINT16 opcode)
17
 
{
18
 
        UINT32  flags = 0;
19
 
        switch (opcode & 0xF)
20
 
        {
21
 
        case 0x0:
22
 
        case 0x1:
23
 
                sprintf(buffer, "??????  $%04X", opcode); break;
24
 
        case 0x2:
25
 
                if (opcode & 0x80) {
26
 
                        sprintf(buffer,"STC     %s_BANK,%s", regname[(Rm) & 7],regname[Rn]);
27
 
                        return flags;
28
 
                }
29
 
                switch (opcode & 0x70)
30
 
                {
31
 
                case 0x00:
32
 
                        sprintf(buffer,"STC     SR,%s", regname[Rn]); break;
33
 
                case 0x10:
34
 
                        sprintf(buffer,"STC     GBR,%s", regname[Rn]); break;
35
 
                case 0x20:
36
 
                        sprintf(buffer,"STC     VBR,%s", regname[Rn]); break;
37
 
                case 0x30:
38
 
                        sprintf(buffer,"STC     SSR,%s", regname[Rn]); break;
39
 
                case 0x40:
40
 
                        sprintf(buffer,"STC     SPC,%s", regname[Rn]); break;
41
 
                }
42
 
                break;
43
 
        case 0x3:
44
 
                switch (opcode & 0xF0)
45
 
                {
46
 
                case 0x00:
47
 
                        sprintf(buffer,"BSRF    %s", regname[Rn]); break;
48
 
                case 0x20:
49
 
                        sprintf(buffer,"BRAF    %s", regname[Rn]); break;
50
 
                case 0x80:
51
 
                        sprintf(buffer,"PREF    @%s", regname[Rn]); break;
52
 
                case 0x90:
53
 
                        sprintf(buffer,"OCBI    @%s", regname[Rn]); break;
54
 
                case 0xA0:
55
 
                        sprintf(buffer,"OCBP    @%s", regname[Rn]); break;
56
 
                case 0xB0:
57
 
                        sprintf(buffer,"OCBWB   @%s", regname[Rn]); break;
58
 
                case 0xC0:
59
 
                        sprintf(buffer,"MOVCA.L R0,@%s", regname[Rn]); break;
60
 
                }
61
 
                break;
62
 
        case 0x4:
63
 
                sprintf(buffer, "MOV.B   %s,@(R0,%s)", regname[Rm], regname[Rn]); break;
64
 
        case 0x5:
65
 
                sprintf(buffer, "MOV.W   %s,@(R0,%s)", regname[Rm], regname[Rn]); break;
66
 
        case 0x6:
67
 
                sprintf(buffer, "MOV.L   %s,@(R0,%s)", regname[Rm], regname[Rn]); break;
68
 
        case 0x7:
69
 
                sprintf(buffer, "MUL.L   %s,%s", regname[Rm], regname[Rn]); break;
70
 
        case 0x8:
71
 
                switch (opcode & 0x70)
72
 
                {
73
 
                case 0x00:
74
 
                        sprintf(buffer,"CLRT"); break;
75
 
                case 0x10:
76
 
                        sprintf(buffer,"SETT"); break;
77
 
                case 0x20:
78
 
                        sprintf(buffer,"CLRMAC"); break;
79
 
                case 0x30:
80
 
                        sprintf(buffer,"LDTLB"); break;
81
 
                case 0x40:
82
 
                        sprintf(buffer,"CLRS"); break;
83
 
                case 0x50:
84
 
                        sprintf(buffer,"SETS"); break;
85
 
                }
86
 
                break;
87
 
        case 0x9:
88
 
                switch (opcode & 0x30)
89
 
                {
90
 
                case 0x00:
91
 
                        sprintf(buffer,"NOP"); break;
92
 
                case 0x10:
93
 
                        sprintf(buffer,"DIV0U"); break;
94
 
                case 0x20:
95
 
                        sprintf(buffer,"MOVT    %s", regname[Rn]); break;
96
 
                }
97
 
                break;
98
 
        case 0xA:
99
 
                switch (opcode & 0x70)
100
 
                {
101
 
                case 0x00:
102
 
                        sprintf(buffer,"STS     MACH,%s", regname[Rn]); break;
103
 
                case 0x10:
104
 
                        sprintf(buffer,"STS     MACL,%s", regname[Rn]); break;
105
 
                case 0x20:
106
 
                        sprintf(buffer,"STS     PR,%s", regname[Rn]); break;
107
 
                case 0x30:
108
 
                        sprintf(buffer,"STC     SGR,%s", regname[Rn]); break;
109
 
                case 0x50:
110
 
                        sprintf(buffer,"STS     FPUL,%s", regname[Rn]); break;
111
 
                case 0x60:
112
 
                        sprintf(buffer,"STS     FPSCR,%s", regname[Rn]); break;
113
 
                case 0x70:
114
 
                        sprintf(buffer,"STC     DBR,%s", regname[Rn]); break;
115
 
                }
116
 
                break;
117
 
        case 0xB:
118
 
                switch (opcode & 0x30)
119
 
                {
120
 
                case 0x00:
121
 
                        sprintf(buffer,"RTS");
122
 
                        flags = DASMFLAG_STEP_OUT;
123
 
                        break;
124
 
                case 0x10:
125
 
                        sprintf(buffer,"SLEEP"); break;
126
 
                case 0x20:
127
 
                        sprintf(buffer,"RTE");
128
 
                        flags = DASMFLAG_STEP_OUT;
129
 
                        break;
130
 
                }
131
 
                break;
132
 
        case 0xC:
133
 
                sprintf(buffer, "MOV.B   @(R0,%s),%s", regname[Rm], regname[Rn]); break;
134
 
        case 0xD:
135
 
                sprintf(buffer, "MOV.W   @(R0,%s),%s", regname[Rm], regname[Rn]); break;
136
 
        case 0xE:
137
 
                sprintf(buffer, "MOV.L   @(R0,%s),%s", regname[Rm], regname[Rn]); break;
138
 
        case 0xF:
139
 
                sprintf(buffer, "MAC.L   @%s+,@%s+", regname[Rn], regname[Rm]); break;
140
 
        }
141
 
        return flags;
142
 
}
143
 
 
144
 
static UINT32 op0001(char *buffer, UINT32 pc, UINT16 opcode)
145
 
{
146
 
        sprintf(buffer, "MOV.L   %s,@($%02X,%s)", regname[Rm], (opcode & 15) * 4, regname[Rn]);
147
 
        return 0;
148
 
}
149
 
 
150
 
static UINT32 op0010(char *buffer, UINT32 pc, UINT16 opcode)
151
 
{
152
 
        switch (opcode & 15)
153
 
        {
154
 
        case  0:
155
 
                sprintf(buffer, "MOV.B   %s,@%s", regname[Rm], regname[Rn]);
156
 
                break;
157
 
        case  1:
158
 
                sprintf(buffer, "MOV.W   %s,@%s", regname[Rm], regname[Rn]);
159
 
                break;
160
 
        case  2:
161
 
                sprintf(buffer, "MOV.L   %s,@%s", regname[Rm], regname[Rn]);
162
 
                break;
163
 
        case  3:
164
 
                sprintf(buffer, "??????  $%04X", opcode);
165
 
                break;
166
 
        case  4:
167
 
                sprintf(buffer, "MOV.B   %s,@-%s", regname[Rm], regname[Rn]);
168
 
                break;
169
 
        case  5:
170
 
                sprintf(buffer, "MOV.W   %s,@-%s", regname[Rm], regname[Rn]);
171
 
                break;
172
 
        case  6:
173
 
                sprintf(buffer, "MOV.L   %s,@-%s", regname[Rm], regname[Rn]);
174
 
                break;
175
 
        case  7:
176
 
                sprintf(buffer, "DIV0S   %s,%s", regname[Rm], regname[Rn]);
177
 
                break;
178
 
        case  8:
179
 
                sprintf(buffer, "TST     %s,%s", regname[Rm], regname[Rn]);
180
 
                break;
181
 
        case  9:
182
 
                sprintf(buffer, "AND     %s,%s", regname[Rm], regname[Rn]);
183
 
                break;
184
 
        case 10:
185
 
                sprintf(buffer, "XOR     %s,%s", regname[Rm], regname[Rn]);
186
 
                break;
187
 
        case 11:
188
 
                sprintf(buffer, "OR      %s,%s", regname[Rm], regname[Rn]);
189
 
                break;
190
 
        case 12:
191
 
                sprintf(buffer, "CMP/STR %s,%s", regname[Rm], regname[Rn]);
192
 
                break;
193
 
        case 13:
194
 
                sprintf(buffer, "XTRCT   %s,%s", regname[Rm], regname[Rn]);
195
 
                break;
196
 
        case 14:
197
 
                sprintf(buffer, "MULU.W  %s,%s", regname[Rm], regname[Rn]);
198
 
                break;
199
 
        case 15:
200
 
                sprintf(buffer, "MULS.W  %s,%s", regname[Rm], regname[Rn]);
201
 
                break;
202
 
        }
203
 
        return 0;
204
 
}
205
 
 
206
 
static UINT32 op0011(char *buffer, UINT32 pc, UINT16 opcode)
207
 
{
208
 
        switch (opcode & 15)
209
 
        {
210
 
        case  0:
211
 
                sprintf(buffer, "CMP/EQ  %s,%s", regname[Rm], regname[Rn]);
212
 
                break;
213
 
        case  1:
214
 
                sprintf(buffer, "??????  %s,%s", regname[Rm], regname[Rn]);
215
 
                break;
216
 
        case  2:
217
 
                sprintf(buffer, "CMP/HS  %s,%s", regname[Rm], regname[Rn]);
218
 
                break;
219
 
        case  3:
220
 
                sprintf(buffer, "CMP/GE  %s,%s", regname[Rm], regname[Rn]);
221
 
                break;
222
 
        case  4:
223
 
                sprintf(buffer, "DIV1    %s,%s", regname[Rm], regname[Rn]);
224
 
                break;
225
 
        case  5:
226
 
                sprintf(buffer, "DMULU.L %s,%s", regname[Rm], regname[Rn]);
227
 
                break;
228
 
        case  6:
229
 
                sprintf(buffer, "CMP/HI  %s,%s", regname[Rm], regname[Rn]);
230
 
                break;
231
 
        case  7:
232
 
                sprintf(buffer, "CMP/GT  %s,%s", regname[Rm], regname[Rn]);
233
 
                break;
234
 
        case  8:
235
 
                sprintf(buffer, "SUB     %s,%s", regname[Rm], regname[Rn]);
236
 
                break;
237
 
        case  9:
238
 
                sprintf(buffer, "??????  %s,%s", regname[Rm], regname[Rn]);
239
 
                break;
240
 
        case 10:
241
 
                sprintf(buffer, "SUBC    %s,%s", regname[Rm], regname[Rn]);
242
 
                break;
243
 
        case 11:
244
 
                sprintf(buffer, "SUBV    %s,%s", regname[Rm], regname[Rn]);
245
 
                break;
246
 
        case 12:
247
 
                sprintf(buffer, "ADD     %s,%s", regname[Rm], regname[Rn]);
248
 
                break;
249
 
        case 13:
250
 
                sprintf(buffer, "DMULS.L %s,%s", regname[Rm], regname[Rn]);
251
 
                break;
252
 
        case 14:
253
 
                sprintf(buffer, "ADDC    %s,%s", regname[Rm], regname[Rn]);
254
 
                break;
255
 
        case 15:
256
 
                sprintf(buffer, "ADDV    %s,%s", regname[Rm], regname[Rn]);
257
 
                break;
258
 
        }
259
 
        return 0;
260
 
}
261
 
 
262
 
static UINT32 op0100(char *buffer, UINT32 pc, UINT16 opcode)
263
 
{
264
 
        UINT32 flags = 0;
265
 
        switch (opcode & 0xF)
266
 
        {
267
 
        case 0x0:
268
 
                switch (opcode & 0x30)
269
 
                {
270
 
                case 0x00:
271
 
                        sprintf(buffer, "SHLL    %s", regname[Rn]); break;
272
 
                case 0x10:
273
 
                        sprintf(buffer, "DT      %s", regname[Rn]); break;
274
 
                case 0x20:
275
 
                        sprintf(buffer, "SHAL    %s", regname[Rn]); break;
276
 
                }
277
 
                break;
278
 
        case 0x1:
279
 
                switch (opcode & 0x30)
280
 
                {
281
 
                case 0x00:
282
 
                        sprintf(buffer, "SHLR    %s", regname[Rn]); break;
283
 
                case 0x10:
284
 
                        sprintf(buffer, "CMP/PZ  %s", regname[Rn]); break;
285
 
                case 0x20:
286
 
                        sprintf(buffer, "SHAR    %s", regname[Rn]); break;
287
 
                }
288
 
                break;
289
 
        case 0x2:
290
 
                switch (opcode & 0xF0)
291
 
                {
292
 
                case 0x00:
293
 
                        sprintf(buffer, "STS.L   MACH,@-%s", regname[Rn]); break;
294
 
                case 0x10:
295
 
                        sprintf(buffer, "STS.L   MACL,@-%s", regname[Rn]); break;
296
 
                case 0x20:
297
 
                        sprintf(buffer, "STS.L   PR,@-%s", regname[Rn]); break;
298
 
                case 0x30:
299
 
                        sprintf(buffer, "STC.L   SGR,@-%s", regname[Rn]); break;
300
 
                case 0x50:
301
 
                        sprintf(buffer, "STS.L   FPUL,@-%s", regname[Rn]); break;
302
 
                case 0x60:
303
 
                        sprintf(buffer, "STS.L   FPSCR,@-%s", regname[Rn]); break;
304
 
                case 0xF0:
305
 
                        sprintf(buffer, "STC.L   DBR,@-%s", regname[Rn]); break;
306
 
                }
307
 
                break;
308
 
        case 0x3:
309
 
                if (opcode & 0x80) {
310
 
                        sprintf(buffer, "STC.L   %s_BANK,@-%s", regname[(Rm) & 7],regname[Rn]);
311
 
                        return flags;
312
 
                }
313
 
                switch (opcode & 0x70)
314
 
                {
315
 
                case 0x00:
316
 
                        sprintf(buffer, "STC.L   SR,@-%s", regname[Rn]); break;
317
 
                case 0x10:
318
 
                        sprintf(buffer, "STC.L   GBR,@-%s", regname[Rn]); break;
319
 
                case 0x20:
320
 
                        sprintf(buffer, "STC.L   VBR,@-%s", regname[Rn]); break;
321
 
                case 0x30:
322
 
                        sprintf(buffer, "STC.L   SSR,@-%s", regname[Rn]); break;
323
 
                case 0x40:
324
 
                        sprintf(buffer, "STC.L   SPC,@-%s", regname[Rn]); break;
325
 
                }
326
 
                break;
327
 
        case 0x4:
328
 
                switch (opcode & 0x30)
329
 
                {
330
 
                case 0x00:
331
 
                        sprintf(buffer, "ROTL    %s", regname[Rn]); break;
332
 
                case 0x20:
333
 
                        sprintf(buffer, "ROTCL   %s", regname[Rn]); break;
334
 
                }
335
 
                break;
336
 
        case 0x5:
337
 
                switch (opcode & 0x30)
338
 
                {
339
 
                case 0x00:
340
 
                        sprintf(buffer, "ROTR    %s", regname[Rn]); break;
341
 
                case 0x10:
342
 
                        sprintf(buffer, "CMP/PL  %s", regname[Rn]); break;
343
 
                case 0x20:
344
 
                        sprintf(buffer, "ROTCR   %s", regname[Rn]); break;
345
 
                }
346
 
                break;
347
 
        case 0x6:
348
 
                switch (opcode & 0xF0)
349
 
                {
350
 
                case 0x00:
351
 
                        sprintf(buffer, "LDS.L   @%s+,MACH", regname[Rn]); break;
352
 
                case 0x10:
353
 
                        sprintf(buffer, "LDS.L   @%s+,MACL", regname[Rn]); break;
354
 
                case 0x20:
355
 
                        sprintf(buffer, "LDS.L   @%s+,PR", regname[Rn]); break;
356
 
                case 0x50:
357
 
                        sprintf(buffer, "LDS.L   @%s+,FPUL", regname[Rn]); break;
358
 
                case 0x60:
359
 
                        sprintf(buffer, "LDS.L   @%s+,FPSCR", regname[Rn]); break;
360
 
                case 0xF0:
361
 
                        sprintf(buffer, "LDC.L   @%s+,DBR", regname[Rn]); break;
362
 
                }
363
 
                break;
364
 
        case 0x7:
365
 
                if (opcode & 0x80) {
366
 
                        sprintf(buffer, "LDC.L   @%s+,%s_BANK", regname[Rn],regname[(Rm) & 7]);
367
 
                        return flags;
368
 
                }
369
 
                switch (opcode & 0x70)
370
 
                {
371
 
                case 0x00:
372
 
                        sprintf(buffer, "LDC.L   @%s+,SR", regname[Rn]); break;
373
 
                case 0x10:
374
 
                        sprintf(buffer, "LDC.L   @%s+,GBR", regname[Rn]); break;
375
 
                case 0x20:
376
 
                        sprintf(buffer, "LDC.L   @%s+,VBR", regname[Rn]); break;
377
 
                case 0x30:
378
 
                        sprintf(buffer, "LDC.L   @%s+,SSR", regname[Rn]); break;
379
 
                case 0x40:
380
 
                        sprintf(buffer, "LDC.L   @%s+,SPC", regname[Rn]); break;
381
 
                }
382
 
                break;
383
 
        case 0x8:
384
 
                switch (opcode & 0x30)
385
 
                {
386
 
                case 0x00:
387
 
                        sprintf(buffer, "SHLL2   %s", regname[Rn]); break;
388
 
                case 0x10:
389
 
                        sprintf(buffer, "SHLL8   %s", regname[Rn]); break;
390
 
                case 0x20:
391
 
                        sprintf(buffer, "SHLL16  %s", regname[Rn]); break;
392
 
                }
393
 
                break;
394
 
        case 0x9:
395
 
                switch (opcode & 0x30)
396
 
                {
397
 
                case 0x00:
398
 
                        sprintf(buffer, "SHLR2   %s", regname[Rn]); break;
399
 
                case 0x10:
400
 
                        sprintf(buffer, "SHLR8   %s", regname[Rn]); break;
401
 
                case 0x20:
402
 
                        sprintf(buffer, "SHLR16  %s", regname[Rn]); break;
403
 
                }
404
 
                break;
405
 
        case 0xA:
406
 
                switch (opcode & 0xF0)
407
 
                {
408
 
                case 0x00:
409
 
                        sprintf(buffer, "LDS     %s,MACH", regname[Rn]); break;
410
 
                case 0x10:
411
 
                        sprintf(buffer, "LDS     %s,MACL", regname[Rn]); break;
412
 
                case 0x20:
413
 
                        sprintf(buffer, "LDS     %s,PR", regname[Rn]); break;
414
 
                case 0x50:
415
 
                        sprintf(buffer, "LDS     %s,FPUL", regname[Rn]); break;
416
 
                case 0x60:
417
 
                        sprintf(buffer, "LDS     %s,FPSCR", regname[Rn]); break;
418
 
                case 0xF0:
419
 
                        sprintf(buffer, "LDC     %s,DBR", regname[Rn]); break;
420
 
                }
421
 
                break;
422
 
        case 0xB:
423
 
                switch (opcode & 0x30)
424
 
                {
425
 
                case 0x00:
426
 
                        sprintf(buffer, "JSR     %s", regname[Rn]);
427
 
                        flags = DASMFLAG_STEP_OVER | DASMFLAG_STEP_OVER_EXTRA(1);
428
 
                        break;
429
 
                case 0x10:
430
 
                        sprintf(buffer, "TAS     %s", regname[Rn]); break;
431
 
                case 0x20:
432
 
                        sprintf(buffer, "JMP     %s", regname[Rn]); break;
433
 
                }
434
 
                break;
435
 
        case 0xC:
436
 
                sprintf(buffer, "SHAD    %s,%s", regname[Rm], regname[Rn]); break;
437
 
        case 0xD:
438
 
                sprintf(buffer, "SHLD    %s,%s", regname[Rm], regname[Rn]); break;
439
 
        case 0xE:
440
 
                if (opcode & 0x80) {
441
 
                        sprintf(buffer, "LDC     %s,%s_BANK", regname[Rn],regname[(Rm) & 7]);
442
 
                        return flags;
443
 
                }
444
 
                switch (opcode & 0x70)
445
 
                {
446
 
                case 0x00:
447
 
                        sprintf(buffer, "LDC     %s,SR", regname[Rn]); break;
448
 
                case 0x10:
449
 
                        sprintf(buffer, "LDC     %s,GBR", regname[Rn]); break;
450
 
                case 0x20:
451
 
                        sprintf(buffer, "LDC     %s,VBR", regname[Rn]); break;
452
 
                case 0x30:
453
 
                        sprintf(buffer, "LDC     %s,SSR", regname[Rn]); break;
454
 
                case 0x40:
455
 
                        sprintf(buffer, "LDC     %s,SPC", regname[Rn]); break;
456
 
                }
457
 
                break;
458
 
        case 0xF:
459
 
                sprintf(buffer, "MAC.W   @%s+,@%s+", regname[Rm], regname[Rn]); break;
460
 
        }
461
 
        return flags;
462
 
}
463
 
 
464
 
static UINT32 op0101(char *buffer, UINT32 pc, UINT16 opcode)
465
 
{
466
 
        sprintf(buffer, "MOV.L   @($%02X,%s),%s", (opcode & 15) * 4, regname[Rm], regname[Rn]);
467
 
        return 0;
468
 
}
469
 
 
470
 
static UINT32 op0110(char *buffer, UINT32 pc, UINT16 opcode)
471
 
 
472
 
{
473
 
        switch(opcode & 0xF)
474
 
        {
475
 
        case 0x00:
476
 
                sprintf(buffer, "MOV.B   @%s,%s", regname[Rm], regname[Rn]);
477
 
                break;
478
 
        case 0x01:
479
 
                sprintf(buffer, "MOV.W   @%s,%s", regname[Rm], regname[Rn]);
480
 
                break;
481
 
        case 0x02:
482
 
                sprintf(buffer, "MOV.L   @%s,%s", regname[Rm], regname[Rn]);
483
 
                break;
484
 
        case 0x03:
485
 
                sprintf(buffer, "MOV     %s,%s", regname[Rm], regname[Rn]);
486
 
                break;
487
 
        case 0x04:
488
 
                sprintf(buffer, "MOV.B   @%s+,%s", regname[Rm], regname[Rn]);
489
 
                break;
490
 
        case 0x05:
491
 
                sprintf(buffer, "MOV.W   @%s+,%s", regname[Rm], regname[Rn]);
492
 
                break;
493
 
        case 0x06:
494
 
                sprintf(buffer, "MOV.L   @%s+,%s", regname[Rm], regname[Rn]);
495
 
                break;
496
 
        case 0x07:
497
 
                sprintf(buffer, "NOT     %s,%s", regname[Rm], regname[Rn]);
498
 
                break;
499
 
        case 0x08:
500
 
                sprintf(buffer, "SWAP.B  %s,%s", regname[Rm], regname[Rn]);
501
 
                break;
502
 
        case 0x09:
503
 
                sprintf(buffer, "SWAP.W  %s,%s", regname[Rm], regname[Rn]);
504
 
                break;
505
 
        case 0x0a:
506
 
                sprintf(buffer, "NEGC    %s,%s", regname[Rm], regname[Rn]);
507
 
                break;
508
 
        case 0x0b:
509
 
                sprintf(buffer, "NEG     %s,%s", regname[Rm], regname[Rn]);
510
 
                break;
511
 
        case 0x0c:
512
 
                sprintf(buffer, "EXTU.B  %s,%s", regname[Rm], regname[Rn]);
513
 
                break;
514
 
        case 0x0d:
515
 
                sprintf(buffer, "EXTU.W  %s,%s", regname[Rm], regname[Rn]);
516
 
                break;
517
 
        case 0x0e:
518
 
                sprintf(buffer, "EXTS.B  %s,%s", regname[Rm], regname[Rn]);
519
 
                break;
520
 
        case 0x0f:
521
 
                sprintf(buffer, "EXTS.W  %s,%s", regname[Rm], regname[Rn]);
522
 
                break;
523
 
        }
524
 
        return 0;
525
 
}
526
 
 
527
 
static UINT32 op0111(char *buffer, UINT32 pc, UINT16 opcode)
528
 
{
529
 
        sprintf(buffer, "ADD     #$%02X,%s", opcode & 0xff, regname[Rn]);
530
 
        return 0;
531
 
}
532
 
 
533
 
static UINT32 op1000(char *buffer, UINT32 pc, UINT16 opcode)
534
 
{
535
 
        switch((opcode >> 8) & 15)
536
 
        {
537
 
        case  0:
538
 
                sprintf(buffer, "MOV.B   R0,@($%02X,%s)", (opcode & 15), regname[Rm]);
539
 
                break;
540
 
        case  1:
541
 
                sprintf(buffer, "MOV.W   R0,@($%02X,%s)", (opcode & 15) * 2, regname[Rm]);
542
 
                break;
543
 
        case  4:
544
 
                sprintf(buffer, "MOV.B   @($%02X,%s),R0", (opcode & 15), regname[Rm]);
545
 
                break;
546
 
        case  5:
547
 
                sprintf(buffer, "MOV.W   @($%02X,%s),R0", (opcode & 15) * 2, regname[Rm]);
548
 
                break;
549
 
        case  8:
550
 
                sprintf(buffer, "CMP/EQ  #$%02X,R0", (opcode & 0xff));
551
 
                break;
552
 
        case  9:
553
 
                sprintf(buffer, "BT      $%08X", pc + SIGNX8(opcode & 0xff) * 2 + 2);
554
 
                break;
555
 
        case 11:
556
 
                sprintf(buffer, "BF      $%08X", pc + SIGNX8(opcode & 0xff) * 2 + 2);
557
 
                break;
558
 
        case 13:
559
 
                sprintf(buffer, "BTS     $%08X", pc + SIGNX8(opcode & 0xff) * 2 + 2);
560
 
                break;
561
 
        case 15:
562
 
                sprintf(buffer, "BFS     $%08X", pc + SIGNX8(opcode & 0xff) * 2 + 2);
563
 
                break;
564
 
        default :
565
 
                sprintf(buffer, "invalid $%04X", opcode);
566
 
        }
567
 
        return 0;
568
 
}
569
 
 
570
 
static UINT32 op1001(char *buffer, UINT32 pc, UINT16 opcode)
571
 
{
572
 
UINT32 ea=(pc+((opcode & 0xff) * 2)+2);
573
 
 
574
 
        sprintf(buffer, "MOV.W   @($%04X,PC),%s [%08X]", (opcode & 0xff) * 2, regname[Rn], ea);
575
 
        return 0;
576
 
}
577
 
 
578
 
static UINT32 op1010(char *buffer, UINT32 pc, UINT16 opcode)
579
 
{
580
 
        sprintf(buffer, "BRA     $%08X", SIGNX12(opcode & 0xfff) * 2 + pc + 2);
581
 
        return 0;
582
 
}
583
 
 
584
 
static UINT32 op1011(char *buffer, UINT32 pc, UINT16 opcode)
585
 
{
586
 
        sprintf(buffer, "BSR     $%08X", SIGNX12(opcode & 0xfff) * 2 + pc + 2);
587
 
        return DASMFLAG_STEP_OVER | DASMFLAG_STEP_OVER_EXTRA(1);
588
 
}
589
 
 
590
 
static UINT32 op1100(char *buffer, UINT32 pc, UINT16 opcode)
591
 
{
592
 
        UINT32 flags = 0;
593
 
        switch((opcode >> 8) & 15)
594
 
        {
595
 
        case  0:
596
 
                sprintf(buffer, "MOV.B   R0,@($%02X,GBR)", opcode & 0xff);
597
 
                break;
598
 
        case  1:
599
 
                sprintf(buffer, "MOV.W   R0,@($%04X,GBR)", (opcode & 0xff) * 2);
600
 
                break;
601
 
        case  2:
602
 
                sprintf(buffer, "MOV.L   R0,@($%04X,GBR)", (opcode & 0xff) * 4);
603
 
                break;
604
 
        case  3:
605
 
                sprintf(buffer, "TRAPA   #$%02X", opcode & 0xff);
606
 
                flags = DASMFLAG_STEP_OVER;
607
 
                break;
608
 
        case  4:
609
 
                sprintf(buffer, "MOV.B   @($%02X,GBR),R0", opcode & 0xff);
610
 
                break;
611
 
        case  5:
612
 
                sprintf(buffer, "MOV.W   @($%04X,GBR),R0", (opcode & 0xff) * 2);
613
 
                break;
614
 
        case  6:
615
 
                sprintf(buffer, "MOV.L   @($%04X,GBR),R0", (opcode & 0xff) * 4);
616
 
                break;
617
 
        case  7:
618
 
                sprintf(buffer, "MOVA    @($%04X,PC),R0 [%08X]", (opcode & 0xff) * 4, ((pc + 2) & ~3) + (opcode & 0xff) * 4);
619
 
                break;
620
 
        case  8:
621
 
                sprintf(buffer, "TST     #$%02X,R0", opcode & 0xff);
622
 
                break;
623
 
        case  9:
624
 
                sprintf(buffer, "AND     #$%02X,R0", opcode & 0xff);
625
 
                break;
626
 
        case 10:
627
 
                sprintf(buffer, "XOR     #$%02X,R0", opcode & 0xff);
628
 
                break;
629
 
        case 11:
630
 
                sprintf(buffer, "OR      #$%02X,R0", opcode & 0xff);
631
 
                break;
632
 
        case 12:
633
 
                sprintf(buffer, "TST.B   #$%02X,@(R0,GBR)", opcode & 0xff);
634
 
                break;
635
 
        case 13:
636
 
                sprintf(buffer, "AND.B   #$%02X,@(R0,GBR)", opcode & 0xff);
637
 
                break;
638
 
        case 14:
639
 
                sprintf(buffer, "XOR.B   #$%02X,@(R0,GBR)", opcode & 0xff);
640
 
                break;
641
 
        case 15:
642
 
                sprintf(buffer, "OR.B    #$%02X,@(R0,GBR)", opcode & 0xff);
643
 
                break;
644
 
        }
645
 
        return flags;
646
 
}
647
 
 
648
 
static UINT32 op1101(char *buffer, UINT32 pc, UINT16 opcode)
649
 
{
650
 
UINT32 ea=((pc + 2) & ~3) + (opcode & 0xff) * 4;
651
 
 
652
 
        sprintf(buffer, "MOV.L   @($%04X,PC),%s [%08X]", (opcode & 0xff) * 4, regname[Rn], ea);
653
 
        return 0;
654
 
}
655
 
 
656
 
static UINT32 op1110(char *buffer, UINT32 pc, UINT16 opcode)
657
 
{
658
 
        sprintf(buffer, "MOV     #$%02X,%s", (opcode & 0xff), regname[Rn]);
659
 
        return 0;
660
 
}
661
 
 
662
 
static UINT32 op1111(char *buffer, UINT32 pc, UINT16 opcode)
663
 
{
664
 
        switch (opcode & 0xf)
665
 
        {
666
 
                case 0:
667
 
                        sprintf(buffer, "FADD    F%s, F%s", regname[Rm], regname[Rn]);
668
 
                        break;
669
 
                case 1:
670
 
                        sprintf(buffer, "FSUB    F%s, F%s", regname[Rm], regname[Rn]);
671
 
                        break;
672
 
                case 2:
673
 
                        sprintf(buffer, "FMUL    F%s, F%s", regname[Rm], regname[Rn]);
674
 
                        break;
675
 
                case 3:
676
 
                        sprintf(buffer, "FDIV    F%s, F%s", regname[Rm], regname[Rn]);
677
 
                        break;
678
 
                case 4:
679
 
                        sprintf(buffer, "FCMP/EQ    F%s, F%s", regname[Rm], regname[Rn]);
680
 
                        break;
681
 
                case 5:
682
 
                        sprintf(buffer, "FCMP/GT    F%s, F%s", regname[Rm], regname[Rn]);
683
 
                        break;
684
 
                case 6:
685
 
                        sprintf(buffer, "FMOV.S  @(R0,%s),F%s", regname[Rm], regname[Rn]);
686
 
                        break;
687
 
                case 7:
688
 
                        sprintf(buffer, "FMOV.S  F%s, @(R0,%s)", regname[Rm], regname[Rn]);
689
 
                        break;
690
 
                case 8:
691
 
                        sprintf(buffer, "FMOV.S  @%s, F%s", regname[Rm], regname[Rn]);
692
 
                        break;
693
 
                case 9:
694
 
                        sprintf(buffer, "FMOV.S  @%s+, F%s", regname[Rm], regname[Rn]);
695
 
                        break;
696
 
                case 10:
697
 
                        sprintf(buffer, "FMOV.S  F%s, @%s", regname[Rm], regname[Rn]);
698
 
                        break;
699
 
                case 11:
700
 
                        sprintf(buffer, "FMOV.S  F%s, @-%s", regname[Rm], regname[Rn]);
701
 
                        break;
702
 
                case 12:
703
 
                        sprintf(buffer, "FMOV.S  F%s, F%s", regname[Rm], regname[Rn]);
704
 
                        break;
705
 
                case 13:
706
 
                        switch (opcode & 0xF0)
707
 
                        {
708
 
                                case 0x00:
709
 
                                        sprintf(buffer, "FSTS    FPUL, F%s", regname[Rn]);
710
 
                                        break;
711
 
                                case 0x10:
712
 
                                        sprintf(buffer, "FLDS    F%s, FPUL", regname[Rn]);
713
 
                                        break;
714
 
                                case 0x20:
715
 
                                        sprintf(buffer, "FLOAT   FPUL, F%s", regname[Rn]);
716
 
                                        break;
717
 
                                case 0x30:
718
 
                                        sprintf(buffer, "FTRC    F%s, FPUL", regname[Rn]);
719
 
                                        break;
720
 
                                case 0x40:
721
 
                                        sprintf(buffer, "FNEG    F%s", regname[Rn]);
722
 
                                        break;
723
 
                                case 0x50:
724
 
                                        sprintf(buffer, "FABS    F%s", regname[Rn]);
725
 
                                        break;
726
 
                                case 0x60:
727
 
                                        sprintf(buffer, "FSQRT   F%s", regname[Rn]);
728
 
                                        break;
729
 
                                case 0x70:
730
 
                                        sprintf(buffer, "FSRRA   F%s", regname[Rn]);
731
 
                                        break;
732
 
                                case 0x80:
733
 
                                        sprintf(buffer, "FLDI0   F%s", regname[Rn]);
734
 
                                        break;
735
 
                                case 0x90:
736
 
                                        sprintf(buffer, "FLDI1   F%s", regname[Rn]);
737
 
                                        break;
738
 
                                case 0xA0:
739
 
                                        sprintf(buffer, "FCNVSD  FPUL, D%s", regname[Rn]);
740
 
                                        break;
741
 
                                case 0xB0:
742
 
                                        sprintf(buffer, "FCNVDS  D%s, FPUL", regname[Rn]);
743
 
                                        break;
744
 
                                case 0xE0:
745
 
                                        sprintf(buffer, "FIPR    FV%d, FV%d", (Rn & 3) << 2, Rn & 12);
746
 
                                        break;
747
 
                                case 0xF0:
748
 
                                        if (opcode & 0x100) {
749
 
                                                if (opcode & 0x200) {
750
 
                                                        switch (opcode & 0xC00)
751
 
                                                        {
752
 
                                                                case 0x000:
753
 
                                                                        sprintf(buffer, "FSCHG");
754
 
                                                                        break;
755
 
                                                                case 0x800:
756
 
                                                                        sprintf(buffer, "FRCHG");
757
 
                                                                        break;
758
 
                                                                default:
759
 
                                                                        sprintf(buffer, "Funknown $%04X", opcode);
760
 
                                                                        break;
761
 
                                                        }
762
 
                                                } else {
763
 
                                                        sprintf(buffer, "FTRV    XMTRX, FV%d", Rn & 12);
764
 
                                                }
765
 
                                        } else {
766
 
                                                sprintf(buffer, "FSCA   FPUL, F%s", regname[Rn & 14]);
767
 
                                        }
768
 
                                        break;
769
 
                                default:
770
 
                                        sprintf(buffer, "Funknown $%04X", opcode);
771
 
                                        break;
772
 
                        }
773
 
                        break;
774
 
                case 14:
775
 
                        sprintf(buffer, "FMAC    FR0, F%s,F%s", regname[Rm], regname[Rn]);
776
 
                        break;
777
 
                default:
778
 
                        sprintf(buffer, "Funknown $%04X", opcode);
779
 
                        break;
780
 
 
781
 
        }
782
 
 
783
 
        return 0;
784
 
}
785
 
 
786
 
unsigned DasmSH4(char *buffer, unsigned pc, UINT16 opcode)
787
 
{
788
 
        UINT32 flags;
789
 
 
790
 
        pc += 2;
791
 
 
792
 
        switch((opcode >> 12) & 15)
793
 
        {
794
 
        case  0: flags = op0000(buffer,pc,opcode);        break;
795
 
        case  1: flags = op0001(buffer,pc,opcode);        break;
796
 
        case  2: flags = op0010(buffer,pc,opcode);        break;
797
 
        case  3: flags = op0011(buffer,pc,opcode);        break;
798
 
        case  4: flags = op0100(buffer,pc,opcode);        break;
799
 
        case  5: flags = op0101(buffer,pc,opcode);        break;
800
 
        case  6: flags = op0110(buffer,pc,opcode);        break;
801
 
        case  7: flags = op0111(buffer,pc,opcode);        break;
802
 
        case  8: flags = op1000(buffer,pc,opcode);        break;
803
 
        case  9: flags = op1001(buffer,pc,opcode);        break;
804
 
        case 10: flags = op1010(buffer,pc,opcode);        break;
805
 
        case 11: flags = op1011(buffer,pc,opcode);        break;
806
 
        case 12: flags = op1100(buffer,pc,opcode);        break;
807
 
        case 13: flags = op1101(buffer,pc,opcode);        break;
808
 
        case 14: flags = op1110(buffer,pc,opcode);        break;
809
 
        default: flags = op1111(buffer,pc,opcode);        break;
810
 
        }
811
 
        return 2 | flags | DASMFLAG_SUPPORTED;
812
 
}
813
 
 
814
 
CPU_DISASSEMBLE( sh4 )
815
 
{
816
 
        return DasmSH4( buffer, pc, (oprom[1] << 8) | oprom[0] );
817
 
}
818