← 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/am29000/am29dasm.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/am29000/am29dasm.c
1
 
/***************************************************************************
2
 
 
3
 
    am29dasm.c
4
 
    Disassembler for the portable Am29000 emulator.
5
 
    Written by Phil Bennett
6
 
 
7
 
***************************************************************************/
8
 
 
9
 
#include "emu.h"
10
 
#include "am29000.h"
11
 
 
12
 
 
13
 
/***************************************************************************
14
 
    DEFINES AND MACROS
15
 
***************************************************************************/
16
 
 
17
 
#define OP_M_BIT        (1 << 24)
18
 
#define OP_RC           ((op >> 16) & 0xff)
19
 
#define OP_RA           ((op >> 8) & 0xff)
20
 
#define OP_RB           (op & 0xff)
21
 
#define OP_I8           (op & 0xff)
22
 
#define OP_SA           ((op >> 8) & 0xff)
23
 
#define OP_I16          (((op >> 8) & 0xff00) | (op & 0xff))
24
 
#define OP_IJMP         (OP_I16 << 2)
25
 
#define OP_VN           ((op >> 16) & 0xff)
26
 
 
27
 
#define OP_CE           ((op >> 23) & 1)
28
 
#define OP_CNTL         ((op >> 16) & 0x7f)
29
 
 
30
 
#define OP_SJMP         ((INT32)(INT16)OP_I16 << 2)
31
 
 
32
 
 
33
 
/***************************************************************************
34
 
    CODE
35
 
***************************************************************************/
36
 
 
37
 
static const char *dasm_type1(UINT32 op)
38
 
{
39
 
        static char buf[32];
40
 
 
41
 
        if (op & OP_M_BIT)
42
 
                sprintf(buf, "r%d, r%d, $%.2x", OP_RC, OP_RA, OP_I8);
43
 
        else
44
 
                sprintf(buf, "r%d, r%d, r%d", OP_RC, OP_RA, OP_RB);
45
 
 
46
 
        return buf;
47
 
}
48
 
 
49
 
static const char *dasm_type2(UINT32 op)
50
 
{
51
 
        static char buf[32];
52
 
 
53
 
        sprintf(buf, "r%d, r%d, r%d", OP_RC, OP_RA, OP_RB);
54
 
 
55
 
        return buf;
56
 
}
57
 
 
58
 
static const char *dasm_type3(UINT32 op)
59
 
{
60
 
        static char buf[32];
61
 
 
62
 
        sprintf(buf, "r%d, $%.4x", OP_RA, OP_I16);
63
 
 
64
 
        return buf;
65
 
}
66
 
 
67
 
static const char *dasm_type4(UINT32 op, UINT32 pc)
68
 
{
69
 
        static char buf[32];
70
 
 
71
 
        if (op & OP_M_BIT)
72
 
                sprintf(buf, "r%d, $%.4x", OP_RA, OP_IJMP);
73
 
        else
74
 
                sprintf(buf, "r%d, $%.4x", OP_RA, pc + OP_SJMP);
75
 
 
76
 
        return buf;
77
 
}
78
 
 
79
 
static const char *dasm_type5(UINT32 op)
80
 
{
81
 
        static char buf[32];
82
 
 
83
 
        if (op & OP_M_BIT)
84
 
                sprintf(buf, "trap%d, r%d, $%.2x", OP_VN, OP_RA, OP_I8);
85
 
        else
86
 
                sprintf(buf, "trap%d, r%d, r%d", OP_VN, OP_RA, OP_RB);
87
 
 
88
 
        return buf;
89
 
}
90
 
 
91
 
static const char *dasm_type6(UINT32 op)
92
 
{
93
 
        static char buf[32];
94
 
 
95
 
        if (op & OP_M_BIT)
96
 
                sprintf(buf, "%d, %x, r%d, $%.2x", OP_CE, OP_CNTL, OP_RA, OP_I8);
97
 
        else
98
 
                sprintf(buf, "%d, %x, r%d, r%d", OP_CE, OP_CNTL, OP_RA, OP_RB);
99
 
 
100
 
        return buf;
101
 
}
102
 
 
103
 
#define TYPE_1          dasm_type1(op)
104
 
#define TYPE_2          dasm_type2(op)
105
 
#define TYPE_3          dasm_type3(op)
106
 
#define TYPE_4          dasm_type4(op, pc)
107
 
#define TYPE_5          dasm_type5(op)
108
 
#define TYPE_6          dasm_type6(op)
109
 
 
110
 
 
111
 
static const char* get_spr(int spid)
112
 
{
113
 
        switch (spid)
114
 
        {
115
 
                case   0: return "VAB";
116
 
                case   1: return "OPS";
117
 
                case   2: return "CPS";
118
 
                case   3: return "CFG";
119
 
                case   4: return "CHA";
120
 
                case   5: return "CHD";
121
 
                case   6: return "CHC";
122
 
                case   7: return "RBP";
123
 
                case   8: return "TMC";
124
 
                case   9: return "TMR";
125
 
                case  10: return "PC0";
126
 
                case  11: return "PC1";
127
 
                case  12: return "PC2";
128
 
                case  13: return "MMU";
129
 
                case  14: return "LRU";
130
 
                case 128: return "IPC";
131
 
                case 129: return "IPA";
132
 
                case 130: return "IPB";
133
 
                case 131: return "Q";
134
 
                case 132: return "ALU";
135
 
                case 133: return "BP";
136
 
                case 134: return "FC";
137
 
                case 135: return "CR";
138
 
                case 160: return "FPE";
139
 
                case 161: return "INTE";
140
 
                case 162: return "FPS";
141
 
                case 164: return "EXOP";
142
 
                default:  return "????";
143
 
        }
144
 
}
145
 
 
146
 
CPU_DISASSEMBLE( am29000 )
147
 
{
148
 
        UINT32 op = (oprom[0] << 24) | (oprom[1] << 16) | (oprom[2] << 8) | oprom[3];
149
 
        UINT32 flags = 0;
150
 
 
151
 
        switch (op >> 24)
152
 
        {
153
 
                case 0x01:                              sprintf(buffer, "constn  %s", TYPE_3);                                                  break;
154
 
                case 0x02:                              sprintf(buffer, "consth  %s", TYPE_3);                                                  break;
155
 
                case 0x03:                              sprintf(buffer, "const   %s", TYPE_3);                                                  break;
156
 
                case 0x04:                              sprintf(buffer, "mtsrim  %s, $%.4x", get_spr(OP_SA), OP_I16);   break;
157
 
                case 0x06: case 0x07:   sprintf(buffer, "loadl   %s", TYPE_6);                                                  break;
158
 
                case 0x08:                              sprintf(buffer, "clz     r%d, %d", OP_RC, OP_RB);                               break;
159
 
                case 0x09:                              sprintf(buffer, "clz     %d, %.2x", OP_RC, OP_I8);                              break;
160
 
                case 0x0a: case 0x0b:   sprintf(buffer, "exbyte  %s", TYPE_1);                                                  break;
161
 
                case 0x0c: case 0x0d:   sprintf(buffer, "inbyte  %s", TYPE_1);                                                  break;
162
 
                case 0x0e: case 0x0f:   sprintf(buffer, "storel  %s", TYPE_6);                                                  break;
163
 
                case 0x10: case 0x11:   sprintf(buffer, "adds    %s", TYPE_1);                                                  break;
164
 
                case 0x12: case 0x13:   sprintf(buffer, "addu    %s", TYPE_1);                                                  break;
165
 
                case 0x14: case 0x15:   sprintf(buffer, "add     %s", TYPE_1);                                                  break;
166
 
                case 0x16: case 0x17:   sprintf(buffer, "load    %s", TYPE_6);                                                  break;
167
 
                case 0x18: case 0x19:   sprintf(buffer, "addcs   %s", TYPE_1);                                                  break;
168
 
                case 0x1a: case 0x1b:   sprintf(buffer, "addcu   %s", TYPE_1);                                                  break;
169
 
                case 0x1c: case 0x1d:   sprintf(buffer, "addc    %s", TYPE_1);                                                  break;
170
 
                case 0x1e: case 0x1f:   sprintf(buffer, "store   %s", TYPE_6);                                                  break;
171
 
                case 0x20: case 0x21:   sprintf(buffer, "subs    %s", TYPE_1);                                                  break;
172
 
                case 0x22: case 0x23:   sprintf(buffer, "subu    %s", TYPE_1);                                                  break;
173
 
                case 0x24: case 0x25:   sprintf(buffer, "sub     %s", TYPE_1);                                                  break;
174
 
                case 0x26: case 0x27:   sprintf(buffer, "loadset %s", TYPE_6);                                                  break;
175
 
                case 0x28: case 0x29:   sprintf(buffer, "subcs   %s", TYPE_1);                                                  break;
176
 
                case 0x2a: case 0x2b:   sprintf(buffer, "subcu   %s", TYPE_1);                                                  break;
177
 
                case 0x2c: case 0x2d:   sprintf(buffer, "subc    %s", TYPE_1);                                                  break;
178
 
                case 0x2e: case 0x2f:   sprintf(buffer, "cpbyte  %s", TYPE_1);                                                  break;
179
 
                case 0x30: case 0x31:   sprintf(buffer, "subrs   %s", TYPE_1);                                                  break;
180
 
                case 0x32: case 0x33:   sprintf(buffer, "subru   %s", TYPE_1);                                                  break;
181
 
                case 0x34: case 0x35:   sprintf(buffer, "subr    %s", TYPE_1);                                                  break;
182
 
                case 0x36: case 0x37:   sprintf(buffer, "loadm   %s", TYPE_6);                                                  break;
183
 
                case 0x38: case 0x39:   sprintf(buffer, "subrcs  %s", TYPE_1);                                                  break;
184
 
                case 0x3a: case 0x3b:   sprintf(buffer, "subrcu  %s", TYPE_1);                                                  break;
185
 
                case 0x3c: case 0x3d:   sprintf(buffer, "subrc   %s", TYPE_1);                                                  break;
186
 
                case 0x3e: case 0x3f:   sprintf(buffer, "storem  %s", TYPE_6);                                                  break;
187
 
                case 0x40: case 0x41:   sprintf(buffer, "cplt    %s", TYPE_1);                                                  break;
188
 
                case 0x42: case 0x43:   sprintf(buffer, "cpltu   %s", TYPE_1);                                                  break;
189
 
                case 0x44: case 0x45:   sprintf(buffer, "cple    %s", TYPE_1);                                                  break;
190
 
                case 0x46: case 0x47:   sprintf(buffer, "cpleu   %s", TYPE_1);                                                  break;
191
 
                case 0x48: case 0x49:   sprintf(buffer, "cpgt    %s", TYPE_1);                                                  break;
192
 
                case 0x4a: case 0x4b:   sprintf(buffer, "cpgtu   %s", TYPE_1);                                                  break;
193
 
                case 0x4c: case 0x4d:   sprintf(buffer, "cpge    %s", TYPE_1);                                                  break;
194
 
                case 0x4e: case 0x4f:   sprintf(buffer, "cpgeu   %s", TYPE_1);                                                  break;
195
 
                case 0x50: case 0x51:   sprintf(buffer, "aslt    %s", TYPE_5);                                                  break;
196
 
                case 0x52: case 0x53:   sprintf(buffer, "asltu   %s", TYPE_5);                                                  break;
197
 
                case 0x54: case 0x55:   sprintf(buffer, "asle    %s", TYPE_5);                                                  break;
198
 
                case 0x56: case 0x57:   sprintf(buffer, "asleu   %s", TYPE_5);                                                  break;
199
 
                case 0x58: case 0x59:   sprintf(buffer, "asgt    %s", TYPE_5);                                                  break;
200
 
                case 0x5a: case 0x5b:   sprintf(buffer, "asgtu   %s", TYPE_5);                                                  break;
201
 
                case 0x5c: case 0x5d:   sprintf(buffer, "asge    %s", TYPE_5);                                                  break;
202
 
                case 0x5e: case 0x5f:   sprintf(buffer, "asgeu   %s", TYPE_5);                                                  break;
203
 
                case 0x60: case 0x61:   sprintf(buffer, "cpeq    %s", TYPE_1);                                                  break;
204
 
                case 0x62: case 0x63:   sprintf(buffer, "cpneq   %s", TYPE_1);                                                  break;
205
 
                case 0x64: case 0x65:   sprintf(buffer, "mul     %s", TYPE_1);                                                  break;
206
 
                case 0x66: case 0x67:   sprintf(buffer, "mull    %s", TYPE_1);                                                  break;
207
 
                case 0x68:                              sprintf(buffer, "div0    r%d, r%d", OP_RC, OP_RB);                              break;
208
 
                case 0x69:                              sprintf(buffer, "div0    r%d, %.2x", OP_RC, OP_I8);                             break;
209
 
                case 0x6a: case 0x6b:   sprintf(buffer, "div     %s", TYPE_1);                                                  break;
210
 
                case 0x6c: case 0x6d:   sprintf(buffer, "divl    %s", TYPE_1);                                                  break;
211
 
                case 0x6e: case 0x6f:   sprintf(buffer, "divrem  %s", TYPE_1);                                                  break;
212
 
                case 0x70: case 0x71:   sprintf(buffer, "aseq    %s", TYPE_5);                                                  break;
213
 
                case 0x72: case 0x73:   sprintf(buffer, "asneq   %s", TYPE_5);                                                  break;
214
 
                case 0x74: case 0x75:   sprintf(buffer, "mulu    %s", TYPE_1);                                                  break;
215
 
                case 0x78: case 0x79:   sprintf(buffer, "inhw    %s", TYPE_1);                                                  break;
216
 
                case 0x7a: case 0x7b:   sprintf(buffer, "extract %s", TYPE_1);                                                  break;
217
 
                case 0x7c: case 0x7d:   sprintf(buffer, "exhw    %s", TYPE_1);                                                  break;
218
 
                case 0x7e:                              sprintf(buffer, "exhws   %s", TYPE_1);                                                  break;
219
 
                case 0x80: case 0x81:   sprintf(buffer, "sll     %s", TYPE_1);                                                  break;
220
 
                case 0x82: case 0x83:   sprintf(buffer, "srl     %s", TYPE_1);                                                  break;
221
 
                case 0x86: case 0x87:   sprintf(buffer, "sra     %s", TYPE_1);                                                  break;
222
 
                case 0x88:                              sprintf(buffer, "iret");                                                                                break;
223
 
                case 0x89:                              sprintf(buffer, "halt");                                                                                break;
224
 
                case 0x8c:                              sprintf(buffer, "iretinv");                                                                             break;
225
 
                case 0x90: case 0x91:   sprintf(buffer, "and     %s", TYPE_1);                                                  break;
226
 
                case 0x92: case 0x93:   sprintf(buffer, "or      %s", TYPE_1);                                                  break;
227
 
                case 0x94: case 0x95:   sprintf(buffer, "xor     %s", TYPE_1);                                                  break;
228
 
                case 0x96: case 0x97:   sprintf(buffer, "xnor    %s", TYPE_1);                                                  break;
229
 
                case 0x98: case 0x99:   sprintf(buffer, "nor     %s", TYPE_1);                                                  break;
230
 
                case 0x9a: case 0x9b:   sprintf(buffer, "nand    %s", TYPE_1);                                                  break;
231
 
                case 0x9c: case 0x9d:   sprintf(buffer, "andn    %s", TYPE_1);                                                  break;
232
 
                case 0x9e:                              sprintf(buffer, "setip   %s", TYPE_2);                                                  break;
233
 
                case 0x9f:                              sprintf(buffer, "inv");                                                                                 break;
234
 
                case 0xa0:                              sprintf(buffer, "jmp     $%.4x", pc + OP_SJMP);                                 break;
235
 
                case 0xa1:                              sprintf(buffer, "jmp     $%.4x", OP_IJMP);                                              break;
236
 
                case 0xa4: case 0xa5:   sprintf(buffer, "jmpf    %s", TYPE_4);                                                  break;
237
 
                case 0xa8: case 0xa9:   sprintf(buffer, "call    %s", TYPE_4);                                                  break;
238
 
                case 0xac: case 0xad:   sprintf(buffer, "jmpt    %s", TYPE_4);                                                  break;
239
 
                case 0xb4: case 0xb5:   sprintf(buffer, "jmpfdec %s", TYPE_4);                                                  break;
240
 
                case 0xb6:                              sprintf(buffer, "mftlb   r%d, r%d", OP_RC, OP_RA);                              break;
241
 
                case 0xbe:                              sprintf(buffer, "mttlb   r%d, r%d", OP_RA, OP_RB);                              break;
242
 
                case 0xc0:                              sprintf(buffer, "jmpi    r%d", OP_RB);                                                  break;
243
 
                case 0xc4:                              sprintf(buffer, "jmpfi   r%d, r%d", OP_RA, OP_RB);                              break;
244
 
                case 0xc6:                              sprintf(buffer, "mfsr    r%d, %s", OP_RC, get_spr(OP_SA));              break;
245
 
                case 0xc8:                              sprintf(buffer, "calli   r%d, r%d", OP_RA, OP_RB);                              break;
246
 
                case 0xcc:                              sprintf(buffer, "jmpti   r%d, r%d", OP_RA, OP_RB);                              break;
247
 
                case 0xce:                              sprintf(buffer, "mtsr    %s, r%d", get_spr(OP_SA), OP_RB);              break;
248
 
                case 0xd7:                              sprintf(buffer, "emulate %s", TYPE_5);                                                  break;
249
 
                case 0xde:                              sprintf(buffer, "multm   %s", TYPE_2);                                                  break;
250
 
                case 0xdf:                              sprintf(buffer, "multmu  %s", TYPE_2);                                                  break;
251
 
 
252
 
                case 0xe0:                              sprintf(buffer, "multiply  %s", TYPE_2);                                                break;
253
 
                case 0xe1:                              sprintf(buffer, "divide  %s", TYPE_2);                                                  break;
254
 
                default:                                sprintf(buffer, "??????");                                                                              break;
255
 
        }
256
 
        return 4 | flags | DASMFLAG_SUPPORTED;
257
 
}